The Tor Browser: toolkit/components/social/test/xpcshell/head.js@129ffea94266 (annotated)

toolkit/components/social/test/xpcshell/head.js@129ffea94266 (annotated)

toolkit/components/social/test/xpcshell/head.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 const { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
   "resource://gre/modules/Promise.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
   "resource://gre/modules/PlacesUtils.jsm");
 const MANIFEST_PREFS = Services.prefs.getBranch("social.manifest.");
 const gProfD = do_get_profile();
 const XULAPPINFO_CONTRACTID = "@mozilla.org/xre/app-info;1";
 const XULAPPINFO_CID = Components.ID("{c763b610-9d49-455a-bbd2-ede71682a1ac}");
 function createAppInfo(id, name, version, platformVersion) {
   gAppInfo = {
     // nsIXULAppInfo
     vendor: "Mozilla",
     name: name,
     ID: id,
     version: version,
     appBuildID: "2007010101",
     platformVersion: platformVersion ? platformVersion : "1.0",
     platformBuildID: "2007010101",
     // nsIXULRuntime
     inSafeMode: false,
     logConsoleErrors: true,
     OS: "XPCShell",
     XPCOMABI: "noarch-spidermonkey",
     invalidateCachesOnRestart: function invalidateCachesOnRestart() {
       // Do nothing
     },
     // nsICrashReporter
     annotations: {},
     annotateCrashReport: function(key, data) {
       this.annotations[key] = data;
     },
     QueryInterface: XPCOMUtils.generateQI([Ci.nsIXULAppInfo,
                                            Ci.nsIXULRuntime,
                                            Ci.nsICrashReporter,
                                            Ci.nsISupports])
   };
   var XULAppInfoFactory = {
     createInstance: function (outer, iid) {
       if (outer != null)
         throw Components.results.NS_ERROR_NO_AGGREGATION;
       return gAppInfo.QueryInterface(iid);
     }
   };
   var registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
   registrar.registerFactory(XULAPPINFO_CID, "XULAppInfo",
                             XULAPPINFO_CONTRACTID, XULAppInfoFactory);
 }
 function initApp() {
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9");
   // prepare a blocklist file for the blocklist service
   var blocklistFile = gProfD.clone();
   blocklistFile.append("blocklist.xml");
   if (blocklistFile.exists())
     blocklistFile.remove(false);
   var source = do_get_file("blocklist.xml");
   source.copyTo(gProfD, "blocklist.xml");
   blocklistFile.lastModifiedTime = Date.now();
 }
 function AsyncRunner() {
   do_test_pending();
   do_register_cleanup((function () this.destroy()).bind(this));
   this._callbacks = {
     done: do_test_finished,
     error: function (err) {
       // xpcshell test functions like do_check_eq throw NS_ERROR_ABORT on
       // failure.  Ignore those so they aren't rethrown here.
       if (err !== Cr.NS_ERROR_ABORT) {
         if (err.stack) {
           err = err + " - See following stack:\n" + err.stack +
                       "\nUseless do_throw stack";
         }
         do_throw(err);
       }
     },
     consoleError: function (scriptErr) {
       // Try to ensure the error is related to the test.
       let filename = scriptErr.sourceName || scriptErr.toString() || "";
       if (filename.indexOf("/toolkit/components/social/") >= 0)
         do_throw(scriptErr);
     },
   };
   this._iteratorQueue = [];
   // This catches errors reported to the console, e.g., via Cu.reportError, but
   // not on the runner's stack.
   Cc["@mozilla.org/consoleservice;1"].
     getService(Ci.nsIConsoleService).
     registerListener(this);
 }
 AsyncRunner.prototype = {
   appendIterator: function appendIterator(iter) {
     this._iteratorQueue.push(iter);
   },
   next: function next(/* ... */) {
     if (!this._iteratorQueue.length) {
       this.destroy();
       this._callbacks.done();
       return;
     }
     // send() discards all arguments after the first, so there's no choice here
     // but to send only one argument to the yielder.
     let args = [arguments.length <= 1 ? arguments[0] : Array.slice(arguments)];
     try {
       var val = this._iteratorQueue[0].send.apply(this._iteratorQueue[0], args);
     }
     catch (err if err instanceof StopIteration) {
       this._iteratorQueue.shift();
       this.next();
       return;
     }
     catch (err) {
       this._callbacks.error(err);
     }
     // val is an iterator => prepend it to the queue and start on it
     // val is otherwise truthy => call next
     if (val) {
       if (typeof(val) != "boolean")
         this._iteratorQueue.unshift(val);
       this.next();
     }
   },
   destroy: function destroy() {
     Cc["@mozilla.org/consoleservice;1"].
       getService(Ci.nsIConsoleService).
       unregisterListener(this);
     this.destroy = function alreadyDestroyed() {};
   },
   observe: function observe(msg) {
     if (msg instanceof Ci.nsIScriptError &&
         !(msg.flags & Ci.nsIScriptError.warningFlag))
     {
       this._callbacks.consoleError(msg);
     }
   },
 };
 function promiseAddVisits(aPlaceInfo)
 {
   let deferred = Promise.defer();
   let places = [];
   if (aPlaceInfo instanceof Ci.nsIURI) {
     places.push({ uri: aPlaceInfo });
   }
   else if (Array.isArray(aPlaceInfo)) {
     places = places.concat(aPlaceInfo);
   } else {
     places.push(aPlaceInfo)
   }
   // Create mozIVisitInfo for each entry.
   let now = Date.now();
   for (let i = 0; i < places.length; i++) {
     if (!places[i].title) {
       places[i].title = "test visit for " + places[i].uri.spec;
     }
     places[i].visits = [{
       transitionType: places[i].transition === undefined ? Ci.nsINavHistoryService.TRANSITION_LINK
                                                          : places[i].transition,
       visitDate: places[i].visitDate || (now++) * 1000,
       referrerURI: places[i].referrer
     }];
   }
   PlacesUtils.asyncHistory.updatePlaces(
     places,
     {
       handleError: function handleError(aResultCode, aPlaceInfo) {
         let ex = new Components.Exception("Unexpected error in adding visits.",
                                           aResultCode);
         deferred.reject(ex);
       },
       handleResult: function () {},
       handleCompletion: function handleCompletion() {
         deferred.resolve();
       }
     }
   );
   return deferred.promise;
 }
 function promiseTopicObserved(aTopic)
 {
   let deferred = Promise.defer();
   Services.obs.addObserver(
     function PTO_observe(aSubject, aTopic, aData) {
       Services.obs.removeObserver(PTO_observe, aTopic);
       deferred.resolve([aSubject, aData]);
     }, aTopic, false);
   return deferred.promise;
 }
 function promiseClearHistory() {
   let promise = promiseTopicObserved(PlacesUtils.TOPIC_EXPIRATION_FINISHED);
   do_execute_soon(function() PlacesUtils.bhistory.removeAllPages());
   return promise;
 }