The Tor Browser: toolkit/identity/MinimalIdentity.jsm@129ffea94266 (annotated)

toolkit/identity/MinimalIdentity.jsm@129ffea94266 (annotated)

toolkit/identity/MinimalIdentity.jsm

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.

 /* -*- Mode: js2; js2-basic-offset: 2; indent-tabs-mode: nil; -*- */
 /* vim: set ft=javascript ts=2 et sw=2 tw=80: */
 /* 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/. */
 /*
  * This alternate implementation of IdentityService provides just the
  * channels for navigator.id, leaving the certificate storage to a
  * server-provided app.
  *
  * On b2g, the messages identity-controller-watch, -request, and
  * -logout, are observed by the component SignInToWebsite.jsm.
  */
 "use strict";
 this.EXPORTED_SYMBOLS = ["IdentityService"];
 const Cu = Components.utils;
 const Ci = Components.interfaces;
 const Cc = Components.classes;
 const Cr = Components.results;
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/identity/LogUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "objectCopy",
                                   "resource://gre/modules/identity/IdentityUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "makeMessageObject",
                                   "resource://gre/modules/identity/IdentityUtils.jsm");
 function log(...aMessageArgs) {
   Logger.log.apply(Logger, ["minimal core"].concat(aMessageArgs));
 }
 function reportError(...aMessageArgs) {
   Logger.reportError.apply(Logger, ["core"].concat(aMessageArgs));
 }
 function IDService() {
   Services.obs.addObserver(this, "quit-application-granted", false);
   // simplify, it's one object
   this.RP = this;
   this.IDP = this;
   // keep track of flows
   this._rpFlows = {};
   this._authFlows = {};
   this._provFlows = {};
 }
 IDService.prototype = {
   QueryInterface: XPCOMUtils.generateQI([Ci.nsISupports, Ci.nsIObserver]),
   observe: function observe(aSubject, aTopic, aData) {
     switch (aTopic) {
       case "quit-application-granted":
         this.shutdown();
         break;
     }
   },
   shutdown: function() {
     Services.obs.removeObserver(this, "quit-application-granted");
   },
   /**
    * Parse an email into username and domain if it is valid, else return null
    */
   parseEmail: function parseEmail(email) {
     var match = email.match(/^([^@]+)@([^@^/]+.[a-z]+)$/);
     if (match) {
       return {
         username: match[1],
         domain: match[2]
       };
     }
     return null;
   },
   /**
    * Register a listener for a given windowID as a result of a call to
    * navigator.id.watch().
    *
    * @param aCaller
    *        (Object)  an object that represents the caller document, and
    *                  is expected to have properties:
    *                  - id (unique, e.g. uuid)
    *                  - loggedInUser (string or null)
    *                  - origin (string)
    *
    *                  and a bunch of callbacks
    *                  - doReady()
    *                  - doLogin()
    *                  - doLogout()
    *                  - doError()
    *                  - doCancel()
    *
    */
   watch: function watch(aRpCaller) {
     // store the caller structure and notify the UI observers
     this._rpFlows[aRpCaller.id] = aRpCaller;
     log("flows:", Object.keys(this._rpFlows).join(', '));
     let options = makeMessageObject(aRpCaller);
     log("sending identity-controller-watch:", options);
     Services.obs.notifyObservers({wrappedJSObject: options},"identity-controller-watch", null);
   },
   /*
    * The RP has gone away; remove handles to the hidden iframe.
    * It's probable that the frame will already have been cleaned up.
    */
   unwatch: function unwatch(aRpId, aTargetMM) {
     let rp = this._rpFlows[aRpId];
     if (!rp) {
       return;
     }
     let options = makeMessageObject({
       id: aRpId,
       origin: rp.origin,
       messageManager: aTargetMM
     });
     log("sending identity-controller-unwatch for id", options.id, options.origin);
     Services.obs.notifyObservers({wrappedJSObject: options}, "identity-controller-unwatch", null);
     // Stop sending messages to this window
     delete this._rpFlows[aRpId];
   },
   /**
    * Initiate a login with user interaction as a result of a call to
    * navigator.id.request().
    *
    * @param aRPId
    *        (integer)  the id of the doc object obtained in .watch()
    *
    * @param aOptions
    *        (Object)  options including privacyPolicy, termsOfService
    */
   request: function request(aRPId, aOptions) {
     let rp = this._rpFlows[aRPId];
     if (!rp) {
       reportError("request() called before watch()");
       return;
     }
     // Notify UX to display identity picker.
     // Pass the doc id to UX so it can pass it back to us later.
     let options = makeMessageObject(rp);
     objectCopy(aOptions, options);
     Services.obs.notifyObservers({wrappedJSObject: options}, "identity-controller-request", null);
   },
   /**
    * Invoked when a user wishes to logout of a site (for instance, when clicking
    * on an in-content logout button).
    *
    * @param aRpCallerId
    *        (integer)  the id of the doc object obtained in .watch()
    *
    */
   logout: function logout(aRpCallerId) {
     let rp = this._rpFlows[aRpCallerId];
     if (!rp) {
       reportError("logout() called before watch()");
       return;
     }
     let options = makeMessageObject(rp);
     Services.obs.notifyObservers({wrappedJSObject: options}, "identity-controller-logout", null);
   },
   childProcessShutdown: function childProcessShutdown(messageManager) {
     Object.keys(this._rpFlows).forEach(function(key) {
       if (this._rpFlows[key]._mm === messageManager) {
         log("child process shutdown for rp", key, "- deleting flow");
         delete this._rpFlows[key];
       }
     }, this);
   },
   /*
    * once the UI-and-display-logic components have received
    * notifications, they call back with direct invocation of the
    * following functions (doLogin, doLogout, or doReady)
    */
   doLogin: function doLogin(aRpCallerId, aAssertion, aInternalParams) {
     let rp = this._rpFlows[aRpCallerId];
     if (!rp) {
       log("WARNING: doLogin found no rp to go with callerId " + aRpCallerId);
       return;
     }
     rp.doLogin(aAssertion, aInternalParams);
   },
   doLogout: function doLogout(aRpCallerId) {
     let rp = this._rpFlows[aRpCallerId];
     if (!rp) {
       log("WARNING: doLogout found no rp to go with callerId " + aRpCallerId);
       return;
     }
     // Logout from every site with the same origin
     let origin = rp.origin;
     Object.keys(this._rpFlows).forEach(function(key) {
       let rp = this._rpFlows[key];
       if (rp.origin === origin) {
         rp.doLogout();
       }
     }.bind(this));
   },
   doReady: function doReady(aRpCallerId) {
     let rp = this._rpFlows[aRpCallerId];
     if (!rp) {
       log("WARNING: doReady found no rp to go with callerId " + aRpCallerId);
       return;
     }
     rp.doReady();
   },
   doCancel: function doCancel(aRpCallerId) {
     let rp = this._rpFlows[aRpCallerId];
     if (!rp) {
       log("WARNING: doCancel found no rp to go with callerId " + aRpCallerId);
       return;
     }
     rp.doCancel();
   }
 };
 this.IdentityService = new IDService();

The Tor Browser / annotate

toolkit/identity/MinimalIdentity.jsm@129ffea94266 (annotated)

toolkit/identity/MinimalIdentity.jsm