The Tor Browser: comparison addon-sdk/source/lib/sdk/deprecated/window-utils.js

comparison: addon-sdk/source/lib/sdk/deprecated/window-utils.js

addon-sdk/source/lib/sdk/deprecated/window-utils.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:356b05ee8bf4
+/* 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(); });
+});