The Tor Browser: addon-sdk/source/lib/sdk/deprecated/window-utils.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/deprecated/window-utils.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/deprecated/window-utils.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/. */
 'use strict';
 module.metadata = {
   'stability': 'deprecated'
 };
 const { Cc, Ci } = require('chrome');
 const { EventEmitter } = require('../deprecated/events');
 const { Trait } = require('../deprecated/traits');
 const { when } = require('../system/unload');
 const events = require('../system/events');
 const { getInnerId, getOuterId, windows, isDocumentLoaded, isBrowser,
         getMostRecentBrowserWindow, getMostRecentWindow } = require('../window/utils');
 const errors = require('../deprecated/errors');
 const { deprecateFunction } = require('../util/deprecate');
 const { ignoreWindow, isGlobalPBSupported } = require('sdk/private-browsing/utils');
 const { isPrivateBrowsingSupported } = require('../self');
 const windowWatcher = Cc['@mozilla.org/embedcomp/window-watcher;1'].
                        getService(Ci.nsIWindowWatcher);
 const appShellService = Cc['@mozilla.org/appshell/appShellService;1'].
                         getService(Ci.nsIAppShellService);
 // Bug 834961: ignore private windows when they are not supported
 function getWindows() windows(null, { includePrivate: isPrivateBrowsingSupported || isGlobalPBSupported });
 /**
  * An iterator for XUL windows currently in the application.
  *
  * @return A generator that yields XUL windows exposing the
  *         nsIDOMWindow interface.
  */
 function windowIterator() {
   // Bug 752631: We only pass already loaded window in order to avoid
   // breaking XUL windows DOM. DOM is broken when some JS code try
   // to access DOM during "uninitialized" state of the related document.
   let list = getWindows().filter(isDocumentLoaded);
   for (let i = 0, l = list.length; i < l; i++) {
     yield list[i];
   }
 };
 exports.windowIterator = windowIterator;
 /**
  * An iterator for browser windows currently open in the application.
  * @returns {Function}
  *    A generator that yields browser windows exposing the `nsIDOMWindow`
  *    interface.
  */
 function browserWindowIterator() {
   for each (let window in windowIterator()) {
     if (isBrowser(window))
       yield window;
   }
 }
 exports.browserWindowIterator = browserWindowIterator;
 function WindowTracker(delegate) {
    if (!(this instanceof WindowTracker)) {
      return new WindowTracker(delegate);
    }
   this._delegate = delegate;
   this._loadingWindows = [];
   for each (let window in getWindows())
     this._regWindow(window);
   windowWatcher.registerNotification(this);
   this._onToplevelWindowReady = this._onToplevelWindowReady.bind(this);
   events.on('toplevel-window-ready', this._onToplevelWindowReady);
   require('../system/unload').ensure(this);
   return this;
 };
 WindowTracker.prototype = {
   _regLoadingWindow: function _regLoadingWindow(window) {
     // Bug 834961: ignore private windows when they are not supported
     if (ignoreWindow(window))
       return;
     this._loadingWindows.push(window);
     window.addEventListener('load', this, true);
   },
   _unregLoadingWindow: function _unregLoadingWindow(window) {
     var index = this._loadingWindows.indexOf(window);
     if (index != -1) {
       this._loadingWindows.splice(index, 1);
       window.removeEventListener('load', this, true);
     }
   },
   _regWindow: function _regWindow(window) {
     // Bug 834961: ignore private windows when they are not supported
     if (ignoreWindow(window))
       return;
     if (window.document.readyState == 'complete') {
       this._unregLoadingWindow(window);
       this._delegate.onTrack(window);
     } else
       this._regLoadingWindow(window);
   },
   _unregWindow: function _unregWindow(window) {
     if (window.document.readyState == 'complete') {
       if (this._delegate.onUntrack)
         this._delegate.onUntrack(window);
     } else {
       this._unregLoadingWindow(window);
     }
   },
   unload: function unload() {
     windowWatcher.unregisterNotification(this);
     events.off('toplevel-window-ready', this._onToplevelWindowReady);
     for each (let window in getWindows())
       this._unregWindow(window);
   },
   handleEvent: errors.catchAndLog(function handleEvent(event) {
     if (event.type == 'load' && event.target) {
       var window = event.target.defaultView;
       if (window)
         this._regWindow(window);
     }
   }),
   _onToplevelWindowReady: function _onToplevelWindowReady({subject}) {
     let window = subject;
     // ignore private windows if they are not supported
     if (ignoreWindow(window))
       return;
     this._regWindow(window);
   },
   observe: errors.catchAndLog(function observe(subject, topic, data) {
     var window = subject.QueryInterface(Ci.nsIDOMWindow);
     // ignore private windows if they are not supported
     if (ignoreWindow(window))
       return;
     if (topic == 'domwindowclosed')
       this._unregWindow(window);
   })
 };
 exports.WindowTracker = WindowTracker;
 const WindowTrackerTrait = Trait.compose({
   _onTrack: Trait.required,
   _onUntrack: Trait.required,
   constructor: function WindowTrackerTrait() {
     WindowTracker({
       onTrack: this._onTrack.bind(this),
       onUntrack: this._onUntrack.bind(this)
     });
   }
 });
 exports.WindowTrackerTrait = WindowTrackerTrait;
 var gDocsToClose = [];
 function onDocUnload(event) {
   var index = gDocsToClose.indexOf(event.target);
   if (index == -1)
     throw new Error('internal error: unloading document not found');
   var document = gDocsToClose.splice(index, 1)[0];
   // Just in case, let's remove the event listener too.
   document.defaultView.removeEventListener('unload', onDocUnload, false);
 }
 onDocUnload = require('./errors').catchAndLog(onDocUnload);
 exports.closeOnUnload = function closeOnUnload(window) {
   window.addEventListener('unload', onDocUnload, false);
   gDocsToClose.push(window.document);
 };
 Object.defineProperties(exports, {
   activeWindow: {
     enumerable: true,
     get: function() {
       return getMostRecentWindow(null);
     },
     set: function(window) {
       try {
         window.focus();
       } catch (e) {}
     }
   },
   activeBrowserWindow: {
     enumerable: true,
     get: getMostRecentBrowserWindow
   }
 });
 /**
  * Returns the ID of the window's current inner window.
  */
 exports.getInnerId = deprecateFunction(getInnerId,
   'require("window-utils").getInnerId is deprecated, ' +
   'please use require("sdk/window/utils").getInnerId instead'
 );
 exports.getOuterId = deprecateFunction(getOuterId,
   'require("window-utils").getOuterId is deprecated, ' +
   'please use require("sdk/window/utils").getOuterId instead'
 );
 exports.isBrowser = deprecateFunction(isBrowser,
   'require("window-utils").isBrowser is deprecated, ' +
   'please use require("sdk/window/utils").isBrowser instead'
 );
 exports.hiddenWindow = appShellService.hiddenDOMWindow;
 when(
   function() {
     gDocsToClose.slice().forEach(
       function(doc) { doc.defaultView.close(); });
   });