The Tor Browser: comparison browser/components/sessionstore/src/SessionHistory.jsm

--1:000000000000
+:28d3978eb8b8
+/* 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";
+this.EXPORTED_SYMBOLS = ["SessionHistory"];
+const Cu = Components.utils;
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Utils",
+"resource:///modules/sessionstore/Utils.jsm");
+function debug(msg) {
+Services.console.logStringMessage("SessionHistory: " + msg);
+}
+/**
+* The external API exported by this module.
+*/
+this.SessionHistory = Object.freeze({
+isEmpty: function (docShell) {
+return SessionHistoryInternal.isEmpty(docShell);
+},
+collect: function (docShell) {
+return SessionHistoryInternal.collect(docShell);
+},
+restore: function (docShell, tabData) {
+SessionHistoryInternal.restore(docShell, tabData);
+}
+});
+/**
+* The internal API for the SessionHistory module.
+*/
+let SessionHistoryInternal = {
+/**
+* Returns whether the given docShell's session history is empty.
+*
+* @param docShell
+*        The docShell that owns the session history.
+*/
+isEmpty: function (docShell) {
+let webNavigation = docShell.QueryInterface(Ci.nsIWebNavigation);
+let history = webNavigation.sessionHistory;
+if (!webNavigation.currentURI) {
+return true;
+}
+let uri = webNavigation.currentURI.spec;
+return uri == "about:blank" && history.count == 0;
+},
+/**
+* Collects session history data for a given docShell.
+*
+* @param docShell
+*        The docShell that owns the session history.
+*/
+collect: function (docShell) {
+let data = {entries: []};
+let isPinned = docShell.isAppTab;
+let webNavigation = docShell.QueryInterface(Ci.nsIWebNavigation);
+let history = webNavigation.sessionHistory;
+if (history && history.count > 0) {
+let oldest;
+let maxSerializeBack =
+Services.prefs.getIntPref("browser.sessionstore.max_serialize_back");
+if (maxSerializeBack >= 0) {
+oldest = Math.max(0, history.index - maxSerializeBack);
+} else { // History.getEntryAtIndex(0, ...) is the oldest.
+oldest = 0;
+}
+let newest;
+let maxSerializeFwd =
+Services.prefs.getIntPref("browser.sessionstore.max_serialize_forward");
+if (maxSerializeFwd >= 0) {
+newest = Math.min(history.count - 1, history.index + maxSerializeFwd);
+} else { // History.getEntryAtIndex(history.count - 1, ...) is the newest.
+newest = history.count - 1;
+}
+try {
+for (let i = oldest; i <= newest; i++) {
+let shEntry = history.getEntryAtIndex(i, false);
+let entry = this.serializeEntry(shEntry, isPinned);
+data.entries.push(entry);
+}
+} catch (ex) {
+// In some cases, getEntryAtIndex will throw. This seems to be due to
+// history.count being higher than it should be. By doing this in a
+// try-catch, we'll update history to where it breaks, print an error
+// message, and still save sessionstore.js.
+debug("SessionStore failed gathering complete history " +
+"for the focused window/tab. See bug 669196.");
+}
+// Set the one-based index of the currently active tab,
+// ensuring it isn't out of bounds if an exception was thrown above.
+data.index = Math.min(history.index - oldest + 1, data.entries.length);
+}
+// If either the session history isn't available yet or doesn't have any
+// valid entries, make sure we at least include the current page.
+if (data.entries.length == 0) {
+let uri = webNavigation.currentURI.spec;
+let body = webNavigation.document.body;
+// We landed here because the history is inaccessible or there are no
+// history entries. In that case we should at least record the docShell's
+// current URL as a single history entry. If the URL is not about:blank
+// or it's a blank tab that was modified (like a custom newtab page),
+// record it. For about:blank we explicitly want an empty array without
+// an 'index' property to denote that there are no history entries.
+if (uri != "about:blank" || (body && body.hasChildNodes())) {
+data.entries.push({ url: uri });
+data.index = 1;
+}
+}
+return data;
+},
+/**
+* Determines whether a given session history entry has been added dynamically.
+*
+* @param shEntry
+*        The session history entry.
+* @return bool
+*/
+isDynamic: function (shEntry) {
+// shEntry.isDynamicallyAdded() is true for dynamically added
+// <iframe> and <frameset>, but also for <html> (the root of the
+// document) so we use shEntry.parent to ensure that we're not looking
+// at the root of the document
+return shEntry.parent && shEntry.isDynamicallyAdded();
+},
+/**
+* Get an object that is a serialized representation of a History entry.
+*
+* @param shEntry
+*        nsISHEntry instance
+* @param isPinned
+*        The tab is pinned and should be treated differently for privacy.
+* @return object
+*/
+serializeEntry: function (shEntry, isPinned) {
+let entry = { url: shEntry.URI.spec };
+// Save some bytes and don't include the title property
+// if that's identical to the current entry's URL.
+if (shEntry.title && shEntry.title != entry.url) {
+entry.title = shEntry.title;
+}
+if (shEntry.isSubFrame) {
+entry.subframe = true;
+}
+let cacheKey = shEntry.cacheKey;
+if (cacheKey && cacheKey instanceof Ci.nsISupportsPRUint32 &&
+cacheKey.data != 0) {
+// XXXbz would be better to have cache keys implement
+// nsISerializable or something.
+entry.cacheKey = cacheKey.data;
+}
+entry.ID = shEntry.ID;
+entry.docshellID = shEntry.docshellID;
+// We will include the property only if it's truthy to save a couple of
+// bytes when the resulting object is stringified and saved to disk.
+if (shEntry.referrerURI)
+entry.referrer = shEntry.referrerURI.spec;
+if (shEntry.srcdocData)
+entry.srcdocData = shEntry.srcdocData;
+if (shEntry.isSrcdocEntry)
+entry.isSrcdocEntry = shEntry.isSrcdocEntry;
+if (shEntry.baseURI)
+entry.baseURI = shEntry.baseURI.spec;
+if (shEntry.contentType)
+entry.contentType = shEntry.contentType;
+let x = {}, y = {};
+shEntry.getScrollPosition(x, y);
+if (x.value != 0 || y.value != 0)
+entry.scroll = x.value + "," + y.value;
+// Collect owner data for the current history entry.
+try {
+let owner = this.serializeOwner(shEntry);
+if (owner) {
+entry.owner_b64 = owner;
+}
+} catch (ex) {
+// Not catching anything specific here, just possible errors
+// from writeCompoundObject() and the like.
+debug("Failed serializing owner data: " + ex);
+}
+entry.docIdentifier = shEntry.BFCacheEntry.ID;
+if (shEntry.stateData != null) {
+entry.structuredCloneState = shEntry.stateData.getDataAsBase64();
+entry.structuredCloneVersion = shEntry.stateData.formatVersion;
+}
+if (!(shEntry instanceof Ci.nsISHContainer)) {
+return entry;
+}
+if (shEntry.childCount > 0) {
+let children = [];
+for (let i = 0; i < shEntry.childCount; i++) {
+let child = shEntry.GetChildAt(i);
+if (child && !this.isDynamic(child)) {
+// Don't try to restore framesets containing wyciwyg URLs.
+// (cf. bug 424689 and bug 450595)
+if (child.URI.schemeIs("wyciwyg")) {
+children.length = 0;
+break;
+}
+children.push(this.serializeEntry(child, isPinned));
+}
+}
+if (children.length) {
+entry.children = children;
+}
+}
+return entry;
+},
+/**
+* Serialize owner data contained in the given session history entry.
+*
+* @param shEntry
+*        The session history entry.
+* @return The base64 encoded owner data.
+*/
+serializeOwner: function (shEntry) {
+if (!shEntry.owner) {
+return null;
+}
+let binaryStream = Cc["@mozilla.org/binaryoutputstream;1"].
+createInstance(Ci.nsIObjectOutputStream);
+let pipe = Cc["@mozilla.org/pipe;1"].createInstance(Ci.nsIPipe);
+pipe.init(false, false, 0, 0xffffffff, null);
+binaryStream.setOutputStream(pipe.outputStream);
+binaryStream.writeCompoundObject(shEntry.owner, Ci.nsISupports, true);
+binaryStream.close();
+// Now we want to read the data from the pipe's input end and encode it.
+let scriptableStream = Cc["@mozilla.org/binaryinputstream;1"].
+createInstance(Ci.nsIBinaryInputStream);
+scriptableStream.setInputStream(pipe.inputStream);
+let ownerBytes =
+scriptableStream.readByteArray(scriptableStream.available());
+// We can stop doing base64 encoding once our serialization into JSON
+// is guaranteed to handle all chars in strings, including embedded
+// nulls.
+return btoa(String.fromCharCode.apply(null, ownerBytes));
+},
+/**
+* Restores session history data for a given docShell.
+*
+* @param docShell
+*        The docShell that owns the session history.
+* @param tabData
+*        The tabdata including all history entries.
+*/
+restore: function (docShell, tabData) {
+let webNavigation = docShell.QueryInterface(Ci.nsIWebNavigation);
+let history = webNavigation.sessionHistory;
+if (history.count > 0) {
+history.PurgeHistory(history.count);
+}
+history.QueryInterface(Ci.nsISHistoryInternal);
+let idMap = { used: {} };
+let docIdentMap = {};
+for (let i = 0; i < tabData.entries.length; i++) {
+//XXXzpao Wallpaper patch for bug 514751
+if (!tabData.entries[i].url)
+continue;
+history.addEntry(this.deserializeEntry(tabData.entries[i],
+idMap, docIdentMap), true);
+}
+},
+/**
+* Expands serialized history data into a session-history-entry instance.
+*
+* @param entry
+*        Object containing serialized history data for a URL
+* @param idMap
+*        Hash for ensuring unique frame IDs
+* @param docIdentMap
+*        Hash to ensure reuse of BFCache entries
+* @returns nsISHEntry
+*/
+deserializeEntry: function (entry, idMap, docIdentMap) {
+var shEntry = Cc["@mozilla.org/browser/session-history-entry;1"].
+createInstance(Ci.nsISHEntry);
+shEntry.setURI(Utils.makeURI(entry.url));
+shEntry.setTitle(entry.title || entry.url);
+if (entry.subframe)
+shEntry.setIsSubFrame(entry.subframe || false);
+shEntry.loadType = Ci.nsIDocShellLoadInfo.loadHistory;
+if (entry.contentType)
+shEntry.contentType = entry.contentType;
+if (entry.referrer)
+shEntry.referrerURI = Utils.makeURI(entry.referrer);
+if (entry.isSrcdocEntry)
+shEntry.srcdocData = entry.srcdocData;
+if (entry.baseURI)
+shEntry.baseURI = Utils.makeURI(entry.baseURI);
+if (entry.cacheKey) {
+var cacheKey = Cc["@mozilla.org/supports-PRUint32;1"].
+createInstance(Ci.nsISupportsPRUint32);
+cacheKey.data = entry.cacheKey;
+shEntry.cacheKey = cacheKey;
+}
+if (entry.ID) {
+// get a new unique ID for this frame (since the one from the last
+// start might already be in use)
+var id = idMap[entry.ID] || 0;
+if (!id) {
+for (id = Date.now(); id in idMap.used; id++);
+idMap[entry.ID] = id;
+idMap.used[id] = true;
+}
+shEntry.ID = id;
+}
+if (entry.docshellID)
+shEntry.docshellID = entry.docshellID;
+if (entry.structuredCloneState && entry.structuredCloneVersion) {
+shEntry.stateData =
+Cc["@mozilla.org/docshell/structured-clone-container;1"].
+createInstance(Ci.nsIStructuredCloneContainer);
+shEntry.stateData.initFromBase64(entry.structuredCloneState,
+entry.structuredCloneVersion);
+}
+if (entry.scroll) {
+var scrollPos = (entry.scroll || "0,0").split(",");
+scrollPos = [parseInt(scrollPos[0]) || 0, parseInt(scrollPos[1]) || 0];
+shEntry.setScrollPosition(scrollPos[0], scrollPos[1]);
+}
+let childDocIdents = {};
+if (entry.docIdentifier) {
+// If we have a serialized document identifier, try to find an SHEntry
+// which matches that doc identifier and adopt that SHEntry's
+// BFCacheEntry.  If we don't find a match, insert shEntry as the match
+// for the document identifier.
+let matchingEntry = docIdentMap[entry.docIdentifier];
+if (!matchingEntry) {
+matchingEntry = {shEntry: shEntry, childDocIdents: childDocIdents};
+docIdentMap[entry.docIdentifier] = matchingEntry;
+}
+else {
+shEntry.adoptBFCacheEntry(matchingEntry.shEntry);
+childDocIdents = matchingEntry.childDocIdents;
+}
+}
+if (entry.owner_b64) {
+var ownerInput = Cc["@mozilla.org/io/string-input-stream;1"].
+createInstance(Ci.nsIStringInputStream);
+var binaryData = atob(entry.owner_b64);
+ownerInput.setData(binaryData, binaryData.length);
+var binaryStream = Cc["@mozilla.org/binaryinputstream;1"].
+createInstance(Ci.nsIObjectInputStream);
+binaryStream.setInputStream(ownerInput);
+try { // Catch possible deserialization exceptions
+shEntry.owner = binaryStream.readObject(true);
+} catch (ex) { debug(ex); }
+}
+if (entry.children && shEntry instanceof Ci.nsISHContainer) {
+for (var i = 0; i < entry.children.length; i++) {
+//XXXzpao Wallpaper patch for bug 514751
+if (!entry.children[i].url)
+continue;
+// We're getting sessionrestore.js files with a cycle in the
+// doc-identifier graph, likely due to bug 698656.  (That is, we have
+// an entry where doc identifier A is an ancestor of doc identifier B,
+// and another entry where doc identifier B is an ancestor of A.)
+//
+// If we were to respect these doc identifiers, we'd create a cycle in
+// the SHEntries themselves, which causes the docshell to loop forever
+// when it looks for the root SHEntry.
+//
+// So as a hack to fix this, we restrict the scope of a doc identifier
+// to be a node's siblings and cousins, and pass childDocIdents, not
+// aDocIdents, to _deserializeHistoryEntry.  That is, we say that two
+// SHEntries with the same doc identifier have the same document iff
+// they have the same parent or their parents have the same document.
+shEntry.AddChild(this.deserializeEntry(entry.children[i], idMap,
+childDocIdents), i);
+}
+}
+return shEntry;
+},
+};

The Tor Browser / file comparison

comparison: browser/components/sessionstore/src/SessionHistory.jsm

browser/components/sessionstore/src/SessionHistory.jsm