The Tor Browser: comparison browser/components/sessionstore/content/content-sessionStore.js

comparison: browser/components/sessionstore/content/content-sessionStore.js

browser/components/sessionstore/content/content-sessionStore.js

branch: TOR_BUG_3246
changeset 5: 4ab42b5ab56c

equal deleted inserted replaced

--1:000000000000
+:ee396da990da
+/* 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";
+function debug(msg) {
+Services.console.logStringMessage("SessionStoreContent: " + msg);
+}
+let Cu = Components.utils;
+let Cc = Components.classes;
+let Ci = Components.interfaces;
+let Cr = Components.results;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm", this);
+Cu.import("resource://gre/modules/Timer.jsm", this);
+XPCOMUtils.defineLazyModuleGetter(this, "DocShellCapabilities",
+"resource:///modules/sessionstore/DocShellCapabilities.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "FormData",
+"resource://gre/modules/FormData.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PageStyle",
+"resource:///modules/sessionstore/PageStyle.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ScrollPosition",
+"resource://gre/modules/ScrollPosition.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "SessionHistory",
+"resource:///modules/sessionstore/SessionHistory.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "SessionStorage",
+"resource:///modules/sessionstore/SessionStorage.jsm");
+Cu.import("resource:///modules/sessionstore/FrameTree.jsm", this);
+let gFrameTree = new FrameTree(this);
+Cu.import("resource:///modules/sessionstore/ContentRestore.jsm", this);
+XPCOMUtils.defineLazyGetter(this, 'gContentRestore',
+() => { return new ContentRestore(this) });
+/**
+* Returns a lazy function that will evaluate the given
+* function |fn| only once and cache its return value.
+*/
+function createLazy(fn) {
+let cached = false;
+let cachedValue = null;
+return function lazy() {
+if (!cached) {
+cachedValue = fn();
+cached = true;
+}
+return cachedValue;
+};
+}
+/**
+* Determines whether the given storage event was triggered by changes
+* to the sessionStorage object and not the local or globalStorage.
+*/
+function isSessionStorageEvent(event) {
+try {
+return event.storageArea == content.sessionStorage;
+} catch (ex if ex instanceof Ci.nsIException && ex.result == Cr.NS_ERROR_NOT_AVAILABLE) {
+// This page does not have a DOMSessionStorage
+// (this is typically the case for about: pages)
+return false;
+}
+}
+/**
+* Listens for and handles content events that we need for the
+* session store service to be notified of state changes in content.
+*/
+let EventListener = {
+init: function () {
+addEventListener("load", this, true);
+},
+handleEvent: function (event) {
+// Ignore load events from subframes.
+if (event.target != content.document) {
+return;
+}
+// If we're in the process of restoring, this load may signal
+// the end of the restoration.
+let epoch = gContentRestore.getRestoreEpoch();
+if (!epoch) {
+return;
+}
+// Restore the form data and scroll position.
+gContentRestore.restoreDocument();
+// Ask SessionStore.jsm to trigger SSTabRestored.
+sendAsyncMessage("SessionStore:restoreDocumentComplete", {epoch: epoch});
+}
+};
+/**
+* Listens for and handles messages sent by the session store service.
+*/
+let MessageListener = {
+MESSAGES: [
+"SessionStore:restoreHistory",
+"SessionStore:restoreTabContent",
+"SessionStore:resetRestore",
+],
+init: function () {
+this.MESSAGES.forEach(m => addMessageListener(m, this));
+},
+receiveMessage: function ({name, data}) {
+switch (name) {
+case "SessionStore:restoreHistory":
+let reloadCallback = () => {
+// Inform SessionStore.jsm about the reload. It will send
+// restoreTabContent in response.
+sendAsyncMessage("SessionStore:reloadPendingTab", {epoch: data.epoch});
+};
+gContentRestore.restoreHistory(data.epoch, data.tabData, reloadCallback);
+// When restoreHistory finishes, we send a synchronous message to
+// SessionStore.jsm so that it can run SSTabRestoring. Users of
+// SSTabRestoring seem to get confused if chrome and content are out of
+// sync about the state of the restore (particularly regarding
+// docShell.currentURI). Using a synchronous message is the easiest way
+// to temporarily synchronize them.
+sendSyncMessage("SessionStore:restoreHistoryComplete", {epoch: data.epoch});
+break;
+case "SessionStore:restoreTabContent":
+let epoch = gContentRestore.getRestoreEpoch();
+let finishCallback = () => {
+// Tell SessionStore.jsm that it may want to restore some more tabs,
+// since it restores a max of MAX_CONCURRENT_TAB_RESTORES at a time.
+sendAsyncMessage("SessionStore:restoreTabContentComplete", {epoch: epoch});
+};
+// We need to pass the value of didStartLoad back to SessionStore.jsm.
+let didStartLoad = gContentRestore.restoreTabContent(finishCallback);
+sendAsyncMessage("SessionStore:restoreTabContentStarted", {epoch: epoch});
+if (!didStartLoad) {
+// Pretend that the load succeeded so that event handlers fire correctly.
+sendAsyncMessage("SessionStore:restoreTabContentComplete", {epoch: epoch});
+sendAsyncMessage("SessionStore:restoreDocumentComplete", {epoch: epoch});
+}
+break;
+case "SessionStore:resetRestore":
+gContentRestore.resetRestore();
+break;
+default:
+debug("received unknown message '" + name + "'");
+break;
+}
+}
+};
+/**
+* On initialization, this handler gets sent to the parent process as a CPOW.
+* The parent will use it only to flush pending data from the frame script
+* when needed, i.e. when closing a tab, closing a window, shutting down, etc.
+*
+* This will hopefully not be needed in the future once we have async APIs for
+* closing windows and tabs.
+*/
+let SyncHandler = {
+init: function () {
+// Send this object as a CPOW to chrome. In single-process mode,
+// the synchronous send ensures that the handler object is
+// available in SessionStore.jsm immediately upon loading
+// content-sessionStore.js.
+sendSyncMessage("SessionStore:setupSyncHandler", {}, {handler: this});
+},
+/**
+* This function is used to make the tab process flush all data that
+* hasn't been sent to the parent process, yet.
+*
+* @param id (int)
+*        A unique id that represents the last message received by the chrome
+*        process before flushing. We will use this to determine data that
+*        would be lost when data has been sent asynchronously shortly
+*        before flushing synchronously.
+*/
+flush: function (id) {
+MessageQueue.flush(id);
+},
+/**
+* DO NOT USE - DEBUGGING / TESTING ONLY
+*
+* This function is used to simulate certain situations where race conditions
+* can occur by sending data shortly before flushing synchronously.
+*/
+flushAsync: function () {
+MessageQueue.flushAsync();
+}
+};
+/**
+* Listens for changes to the session history. Whenever the user navigates
+* we will collect URLs and everything belonging to session history.
+*
+* Causes a SessionStore:update message to be sent that contains the current
+* session history.
+*
+* Example:
+*   {entries: [{url: "about:mozilla", ...}, ...], index: 1}
+*/
+let SessionHistoryListener = {
+init: function () {
+// The frame tree observer is needed to handle navigating away from
+// an about page. Currently nsISHistoryListener does not have
+// OnHistoryNewEntry() called for about pages because the history entry is
+// modified to point at the new page. Once Bug 981900 lands the frame tree
+// observer can be removed.
+gFrameTree.addObserver(this);
+// By adding the SHistoryListener immediately, we will unfortunately be
+// notified of every history entry as the tab is restored. We don't bother
+// waiting to add the listener later because these notifications are cheap.
+// We will likely only collect once since we are batching collection on
+// a delay.
+docShell.QueryInterface(Ci.nsIWebNavigation).sessionHistory.
+addSHistoryListener(this);
+// Collect data if we start with a non-empty shistory.
+if (!SessionHistory.isEmpty(docShell)) {
+this.collect();
+}
+},
+uninit: function () {
+let sessionHistory = docShell.QueryInterface(Ci.nsIWebNavigation).sessionHistory;
+if (sessionHistory) {
+sessionHistory.removeSHistoryListener(this);
+}
+},
+collect: function () {
+if (docShell) {
+MessageQueue.push("history", () => SessionHistory.collect(docShell));
+}
+},
+onFrameTreeCollected: function () {
+this.collect();
+},
+onFrameTreeReset: function () {
+this.collect();
+},
+OnHistoryNewEntry: function (newURI) {
+this.collect();
+},
+OnHistoryGoBack: function (backURI) {
+this.collect();
+return true;
+},
+OnHistoryGoForward: function (forwardURI) {
+this.collect();
+return true;
+},
+OnHistoryGotoIndex: function (index, gotoURI) {
+this.collect();
+return true;
+},
+OnHistoryPurge: function (numEntries) {
+this.collect();
+return true;
+},
+OnHistoryReload: function (reloadURI, reloadFlags) {
+this.collect();
+return true;
+},
+OnHistoryReplaceEntry: function (index) {
+this.collect();
+},
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsISHistoryListener,
+Ci.nsISupportsWeakReference
+])
+};
+/**
+* Listens for scroll position changes. Whenever the user scrolls the top-most
+* frame we update the scroll position and will restore it when requested.
+*
+* Causes a SessionStore:update message to be sent that contains the current
+* scroll positions as a tree of strings. If no frame of the whole frame tree
+* is scrolled this will return null so that we don't tack a property onto
+* the tabData object in the parent process.
+*
+* Example:
+*   {scroll: "100,100", children: [null, null, {scroll: "200,200"}]}
+*/
+let ScrollPositionListener = {
+init: function () {
+addEventListener("scroll", this);
+gFrameTree.addObserver(this);
+},
+handleEvent: function (event) {
+let frame = event.target && event.target.defaultView;
+// Don't collect scroll data for frames created at or after the load event
+// as SessionStore can't restore scroll data for those.
+if (frame && gFrameTree.contains(frame)) {
+MessageQueue.push("scroll", () => this.collect());
+}
+},
+onFrameTreeCollected: function () {
+MessageQueue.push("scroll", () => this.collect());
+},
+onFrameTreeReset: function () {
+MessageQueue.push("scroll", () => null);
+},
+collect: function () {
+return gFrameTree.map(ScrollPosition.collect);
+}
+};
+/**
+* Listens for changes to input elements. Whenever the value of an input
+* element changes we will re-collect data for the current frame tree and send
+* a message to the parent process.
+*
+* Causes a SessionStore:update message to be sent that contains the form data
+* for all reachable frames.
+*
+* Example:
+*   {
+*     formdata: {url: "http://mozilla.org/", id: {input_id: "input value"}},
+*     children: [
+*       null,
+*       {url: "http://sub.mozilla.org/", id: {input_id: "input value 2"}}
+*     ]
+*   }
+*/
+let FormDataListener = {
+init: function () {
+addEventListener("input", this, true);
+addEventListener("change", this, true);
+gFrameTree.addObserver(this);
+},
+handleEvent: function (event) {
+let frame = event.target &&
+event.target.ownerDocument &&
+event.target.ownerDocument.defaultView;
+// Don't collect form data for frames created at or after the load event
+// as SessionStore can't restore form data for those.
+if (frame && gFrameTree.contains(frame)) {
+MessageQueue.push("formdata", () => this.collect());
+}
+},
+onFrameTreeReset: function () {
+MessageQueue.push("formdata", () => null);
+},
+collect: function () {
+return gFrameTree.map(FormData.collect);
+}
+};
+/**
+* Listens for changes to the page style. Whenever a different page style is
+* selected or author styles are enabled/disabled we send a message with the
+* currently applied style to the chrome process.
+*
+* Causes a SessionStore:update message to be sent that contains the currently
+* selected pageStyle for all reachable frames.
+*
+* Example:
+*   {pageStyle: "Dusk", children: [null, {pageStyle: "Mozilla"}]}
+*/
+let PageStyleListener = {
+init: function () {
+Services.obs.addObserver(this, "author-style-disabled-changed", false);
+Services.obs.addObserver(this, "style-sheet-applicable-state-changed", false);
+gFrameTree.addObserver(this);
+},
+uninit: function () {
+Services.obs.removeObserver(this, "author-style-disabled-changed");
+Services.obs.removeObserver(this, "style-sheet-applicable-state-changed");
+},
+observe: function (subject, topic) {
+let frame = subject.defaultView;
+if (frame && gFrameTree.contains(frame)) {
+MessageQueue.push("pageStyle", () => this.collect());
+}
+},
+collect: function () {
+return PageStyle.collect(docShell, gFrameTree);
+},
+onFrameTreeCollected: function () {
+MessageQueue.push("pageStyle", () => this.collect());
+},
+onFrameTreeReset: function () {
+MessageQueue.push("pageStyle", () => null);
+}
+};
+/**
+* Listens for changes to docShell capabilities. Whenever a new load is started
+* we need to re-check the list of capabilities and send message when it has
+* changed.
+*
+* Causes a SessionStore:update message to be sent that contains the currently
+* disabled docShell capabilities (all nsIDocShell.allow* properties set to
+* false) as a string - i.e. capability names separate by commas.
+*/
+let DocShellCapabilitiesListener = {
+/**
+* This field is used to compare the last docShell capabilities to the ones
+* that have just been collected. If nothing changed we won't send a message.
+*/
+_latestCapabilities: "",
+init: function () {
+gFrameTree.addObserver(this);
+},
+/**
+* onFrameTreeReset() is called as soon as we start loading a page.
+*/
+onFrameTreeReset: function() {
+// The order of docShell capabilities cannot change while we're running
+// so calling join() without sorting before is totally sufficient.
+let caps = DocShellCapabilities.collect(docShell).join(",");
+// Send new data only when the capability list changes.
+if (caps != this._latestCapabilities) {
+this._latestCapabilities = caps;
+MessageQueue.push("disallow", () => caps || null);
+}
+}
+};
+/**
+* Listens for changes to the DOMSessionStorage. Whenever new keys are added,
+* existing ones removed or changed, or the storage is cleared we will send a
+* message to the parent process containing up-to-date sessionStorage data.
+*
+* Causes a SessionStore:update message to be sent that contains the current
+* DOMSessionStorage contents. The data is a nested object using host names
+* as keys and per-host DOMSessionStorage data as values.
+*/
+let SessionStorageListener = {
+init: function () {
+addEventListener("MozStorageChanged", this);
+Services.obs.addObserver(this, "browser:purge-domain-data", false);
+gFrameTree.addObserver(this);
+},
+uninit: function () {
+Services.obs.removeObserver(this, "browser:purge-domain-data");
+},
+handleEvent: function (event) {
+// Ignore events triggered by localStorage or globalStorage changes.
+if (gFrameTree.contains(event.target) && isSessionStorageEvent(event)) {
+this.collect();
+}
+},
+observe: function () {
+// Collect data on the next tick so that any other observer
+// that needs to purge data can do its work first.
+setTimeout(() => this.collect(), 0);
+},
+collect: function () {
+if (docShell) {
+MessageQueue.push("storage", () => SessionStorage.collect(docShell, gFrameTree));
+}
+},
+onFrameTreeCollected: function () {
+this.collect();
+},
+onFrameTreeReset: function () {
+this.collect();
+}
+};
+/**
+* Listen for changes to the privacy status of the tab.
+* By definition, tabs start in non-private mode.
+*
+* Causes a SessionStore:update message to be sent for
+* field "isPrivate". This message contains
+*  |true| if the tab is now private
+*  |null| if the tab is now public - the field is therefore
+*  not saved.
+*/
+let PrivacyListener = {
+init: function() {
+docShell.addWeakPrivacyTransitionObserver(this);
+// Check that value at startup as it might have
+// been set before the frame script was loaded.
+if (docShell.QueryInterface(Ci.nsILoadContext).usePrivateBrowsing) {
+MessageQueue.push("isPrivate", () => true);
+}
+},
+// Ci.nsIPrivacyTransitionObserver
+privateModeChanged: function(enabled) {
+MessageQueue.push("isPrivate", () => enabled || null);
+},
+QueryInterface: XPCOMUtils.generateQI([Ci.nsIPrivacyTransitionObserver,
+Ci.nsISupportsWeakReference])
+};
+/**
+* A message queue that takes collected data and will take care of sending it
+* to the chrome process. It allows flushing using synchronous messages and
+* takes care of any race conditions that might occur because of that. Changes
+* will be batched if they're pushed in quick succession to avoid a message
+* flood.
+*/
+let MessageQueue = {
+/**
+* A unique, monotonically increasing ID used for outgoing messages. This is
+* important to make it possible to reuse tabs and allow sync flushes before
+* data could be destroyed.
+*/
+_id: 1,
+/**
+* A map (string -> lazy fn) holding lazy closures of all queued data
+* collection routines. These functions will return data collected from the
+* docShell.
+*/
+_data: new Map(),
+/**
+* A map holding the |this._id| value for every type of data back when it
+* was pushed onto the queue. We will use those IDs to find the data to send
+* and flush.
+*/
+_lastUpdated: new Map(),
+/**
+* The delay (in ms) used to delay sending changes after data has been
+* invalidated.
+*/
+BATCH_DELAY_MS: 1000,
+/**
+* The current timeout ID, null if there is no queue data. We use timeouts
+* to damp a flood of data changes and send lots of changes as one batch.
+*/
+_timeout: null,
+/**
+* Pushes a given |value| onto the queue. The given |key| represents the type
+* of data that is stored and can override data that has been queued before
+* but has not been sent to the parent process, yet.
+*
+* @param key (string)
+*        A unique identifier specific to the type of data this is passed.
+* @param fn (function)
+*        A function that returns the value that will be sent to the parent
+*        process.
+*/
+push: function (key, fn) {
+this._data.set(key, createLazy(fn));
+this._lastUpdated.set(key, this._id);
+if (!this._timeout) {
+// Wait a little before sending the message to batch multiple changes.
+this._timeout = setTimeout(() => this.send(), this.BATCH_DELAY_MS);
+}
+},
+/**
+* Sends queued data to the chrome process.
+*
+* @param options (object)
+*        {id: 123} to override the update ID used to accumulate data to send.
+*        {sync: true} to send data to the parent process synchronously.
+*/
+send: function (options = {}) {
+// Looks like we have been called off a timeout after the tab has been
+// closed. The docShell is gone now and we can just return here as there
+// is nothing to do.
+if (!docShell) {
+return;
+}
+if (this._timeout) {
+clearTimeout(this._timeout);
+this._timeout = null;
+}
+let sync = options && options.sync;
+let startID = (options && options.id) || this._id;
+// We use sendRpcMessage in the sync case because we may have been called
+// through a CPOW. RPC messages are the only synchronous messages that the
+// child is allowed to send to the parent while it is handling a CPOW
+// request.
+let sendMessage = sync ? sendRpcMessage : sendAsyncMessage;
+let durationMs = Date.now();
+let data = {};
+for (let [key, id] of this._lastUpdated) {
+// There is no data for the given key anymore because
+// the parent process already marked it as received.
+if (!this._data.has(key)) {
+continue;
+}
+if (startID > id) {
+// If the |id| passed by the parent process is higher than the one
+// stored in |_lastUpdated| for the given key we know that the parent
+// received all necessary data and we can remove it from the map.
+this._data.delete(key);
+continue;
+}
+data[key] = this._data.get(key)();
+}
+durationMs = Date.now() - durationMs;
+let telemetry = {
+FX_SESSION_RESTORE_CONTENT_COLLECT_DATA_LONGEST_OP_MS: durationMs
+}
+// Send all data to the parent process.
+sendMessage("SessionStore:update", {
+id: this._id,
+data: data,
+telemetry: telemetry
+});
+// Increase our unique message ID.
+this._id++;
+},
+/**
+* This function is used to make the message queue flush all queue data that
+* hasn't been sent to the parent process, yet.
+*
+* @param id (int)
+*        A unique id that represents the latest message received by the
+*        chrome process. We can use this to determine which messages have not
+*        yet been received because they are still stuck in the event queue.
+*/
+flush: function (id) {
+// It's important to always send data, even if there is nothing to flush.
+// The update message will be received by the parent process that can then
+// update its last received update ID to ignore stale messages.
+this.send({id: id + 1, sync: true});
+this._data.clear();
+this._lastUpdated.clear();
+},
+/**
+* DO NOT USE - DEBUGGING / TESTING ONLY
+*
+* This function is used to simulate certain situations where race conditions
+* can occur by sending data shortly before flushing synchronously.
+*/
+flushAsync: function () {
+if (!Services.prefs.getBoolPref("browser.sessionstore.debug")) {
+throw new Error("flushAsync() must be used for testing, only.");
+}
+this.send();
+}
+};
+EventListener.init();
+MessageListener.init();
+FormDataListener.init();
+SyncHandler.init();
+PageStyleListener.init();
+SessionHistoryListener.init();
+SessionStorageListener.init();
+ScrollPositionListener.init();
+DocShellCapabilitiesListener.init();
+PrivacyListener.init();
+addEventListener("unload", () => {
+// Remove all registered nsIObservers.
+PageStyleListener.uninit();
+SessionStorageListener.uninit();
+SessionHistoryListener.uninit();
+// We don't need to take care of any gFrameTree observers as the gFrameTree
+// will die with the content script. The same goes for the privacy transition
+// observer that will die with the docShell when the tab is closed.
+});