diff options
Diffstat (limited to 'toolkit/modules/sessionstore/SessionHistory.sys.mjs')
| -rw-r--r-- | toolkit/modules/sessionstore/SessionHistory.sys.mjs | 663 |
1 files changed, 663 insertions, 0 deletions
diff --git a/toolkit/modules/sessionstore/SessionHistory.sys.mjs b/toolkit/modules/sessionstore/SessionHistory.sys.mjs new file mode 100644 index 0000000000..19f6210fba --- /dev/null +++ b/toolkit/modules/sessionstore/SessionHistory.sys.mjs @@ -0,0 +1,663 @@ +/* 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/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + E10SUtils: "resource://gre/modules/E10SUtils.sys.mjs", +}); + +/** + * The external API exported by this module. + */ +export var SessionHistory = Object.freeze({ + isEmpty(docShell) { + return SessionHistoryInternal.isEmpty(docShell); + }, + + collect(docShell, aFromIdx = -1) { + if (Services.appinfo.sessionHistoryInParent) { + throw new Error("Use SessionHistory.collectFromParent instead"); + } + return SessionHistoryInternal.collect(docShell, aFromIdx); + }, + + collectFromParent(uri, documentHasChildNodes, history, aFromIdx = -1) { + return SessionHistoryInternal.collectCommon( + uri, + documentHasChildNodes, + history, + aFromIdx + ); + }, + + collectNonWebControlledBlankLoadingSession(browsingContext) { + return SessionHistoryInternal.collectNonWebControlledBlankLoadingSession( + browsingContext + ); + }, + + restore(docShell, tabData) { + if (Services.appinfo.sessionHistoryInParent) { + throw new Error("Use SessionHistory.restoreFromParent instead"); + } + return SessionHistoryInternal.restore( + docShell.QueryInterface(Ci.nsIWebNavigation).sessionHistory + .legacySHistory, + tabData + ); + }, + + restoreFromParent(history, tabData) { + return SessionHistoryInternal.restore(history, tabData); + }, +}); + +/** + * The internal API for the SessionHistory module. + */ +var SessionHistoryInternal = { + /** + * Mapping from legacy docshellIDs to docshellUUIDs. + */ + _docshellUUIDMap: new Map(), + + /** + * Returns whether the given docShell's session history is empty. + * + * @param docShell + * The docShell that owns the session history. + */ + isEmpty(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. + * @param aFromIdx + * The starting local index to collect the history from. + * @return An object reprereseting a partial global history update. + */ + collect(docShell, aFromIdx = -1) { + let webNavigation = docShell.QueryInterface(Ci.nsIWebNavigation); + let uri = webNavigation.currentURI.displaySpec; + let body = webNavigation.document.body; + let history = webNavigation.sessionHistory; + return this.collectCommon( + uri, + body && body.hasChildNodes(), + history.legacySHistory, + aFromIdx + ); + }, + + collectCommon(uri, documentHasChildNodes, shistory, aFromIdx) { + let data = { + entries: [], + requestedIndex: shistory.requestedIndex + 1, + }; + + // We want to keep track how many entries we *could* have collected and + // how many we skipped, so we can sanitiy-check the current history index + // and also determine whether we need to get any fallback data or not. + let skippedCount = 0, + entryCount = 0; + + if (shistory && shistory.count > 0) { + let count = shistory.count; + for (; entryCount < count; entryCount++) { + let shEntry = shistory.getEntryAtIndex(entryCount); + if (entryCount <= aFromIdx) { + skippedCount++; + continue; + } + let entry = this.serializeEntry(shEntry); + data.entries.push(entry); + } + + // Ensure the index isn't out of bounds if an exception was thrown above. + data.index = Math.min(shistory.index + 1, entryCount); + } + + // 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, + // unless of course we just skipped all entries because aFromIdx was big enough. + if (!data.entries.length && (skippedCount != entryCount || aFromIdx < 0)) { + // 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" || documentHasChildNodes) { + data.entries.push({ + url: uri, + triggeringPrincipal_base64: lazy.E10SUtils.SERIALIZED_SYSTEMPRINCIPAL, + }); + data.index = 1; + } + } + + data.fromIdx = aFromIdx; + + return data; + }, + + collectNonWebControlledBlankLoadingSession(browsingContext) { + if ( + browsingContext.sessionHistory?.count === 0 && + browsingContext.nonWebControlledBlankURI && + browsingContext.mostRecentLoadingSessionHistoryEntry + ) { + return { + entries: [ + this.serializeEntry( + browsingContext.mostRecentLoadingSessionHistoryEntry + ), + ], + // Set 1 to the index, as the array of session entries is 1-based. + index: 1, + fromIdx: -1, + requestedIndex: browsingContext.sessionHistory.requestedIndex + 1, + }; + } + + return null; + }, + + /** + * Get an object that is a serialized representation of a History entry. + * + * @param shEntry + * nsISHEntry instance + * @return object + */ + serializeEntry(shEntry) { + let entry = { url: shEntry.URI.displaySpec, title: shEntry.title }; + + if (shEntry.isSubFrame) { + entry.subframe = true; + } + + entry.cacheKey = shEntry.cacheKey; + entry.ID = shEntry.ID; + entry.docshellUUID = shEntry.docshellID.toString(); + + // 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.referrerInfo) { + entry.referrerInfo = lazy.E10SUtils.serializeReferrerInfo( + shEntry.referrerInfo + ); + } + + if (shEntry.originalURI) { + entry.originalURI = shEntry.originalURI.spec; + } + + if (shEntry.resultPrincipalURI) { + entry.resultPrincipalURI = shEntry.resultPrincipalURI.spec; + + // For downgrade compatibility we store the loadReplace property as it + // would be stored before result principal URI introduction so that + // the old code can still create URL based principals for channels + // correctly. When resultPrincipalURI is non-null and not equal to + // channel's orignalURI in the new code, it's equal to setting + // LOAD_REPLACE in the old code. Note that we only do 'the best we can' + // here to derivate the 'old' loadReplace flag value. + entry.loadReplace = entry.resultPrincipalURI != entry.originalURI; + } else { + // We want to store the property to let the backward compatibility code, + // when reading the stored session, work. When this property is undefined + // that code will derive the result principal URI from the load replace + // flag. + entry.resultPrincipalURI = null; + } + + if (shEntry.loadReplace) { + // Storing under a new property name, since it has changed its meaning + // with the result principal URI introduction. + entry.loadReplace2 = shEntry.loadReplace; + } + + if (shEntry.isSrcdocEntry) { + entry.srcdocData = shEntry.srcdocData; + entry.isSrcdocEntry = shEntry.isSrcdocEntry; + } + + if (shEntry.baseURI) { + entry.baseURI = shEntry.baseURI.spec; + } + + if (shEntry.contentType) { + entry.contentType = shEntry.contentType; + } + + if (shEntry.scrollRestorationIsManual) { + entry.scrollRestorationIsManual = true; + } else { + let x = {}, + y = {}; + shEntry.getScrollPosition(x, y); + if (x.value !== 0 || y.value !== 0) { + entry.scroll = x.value + "," + y.value; + } + + let layoutHistoryState = shEntry.layoutHistoryState; + if (layoutHistoryState && layoutHistoryState.hasStates) { + let presStates = layoutHistoryState + .getKeys() + .map(key => this._getSerializablePresState(layoutHistoryState, key)) + .filter( + presState => + // Only keep presState entries that contain more than the key itself. + Object.getOwnPropertyNames(presState).length > 1 + ); + + if (presStates.length) { + entry.presState = presStates; + } + } + } + + // Collect triggeringPrincipal data for the current history entry. + if (shEntry.principalToInherit) { + entry.principalToInherit_base64 = lazy.E10SUtils.serializePrincipal( + shEntry.principalToInherit + ); + } + + if (shEntry.partitionedPrincipalToInherit) { + entry.partitionedPrincipalToInherit_base64 = + lazy.E10SUtils.serializePrincipal( + shEntry.partitionedPrincipalToInherit + ); + } + + entry.hasUserInteraction = shEntry.hasUserInteraction; + + if (shEntry.triggeringPrincipal) { + entry.triggeringPrincipal_base64 = lazy.E10SUtils.serializePrincipal( + shEntry.triggeringPrincipal + ); + } + + if (shEntry.csp) { + entry.csp = lazy.E10SUtils.serializeCSP(shEntry.csp); + } + + entry.docIdentifier = shEntry.bfcacheID; + + if (shEntry.stateData != null) { + let stateData = shEntry.stateData; + entry.structuredCloneState = stateData.getDataAsBase64(); + entry.structuredCloneVersion = stateData.formatVersion; + } + + if (shEntry.wireframe != null) { + entry.wireframe = shEntry.wireframe; + } + + if (shEntry.childCount > 0 && !shEntry.hasDynamicallyAddedChild()) { + let children = []; + for (let i = 0; i < shEntry.childCount; i++) { + let child = shEntry.GetChildAt(i); + + if (child) { + children.push(this.serializeEntry(child)); + } + } + + if (children.length) { + entry.children = children; + } + } + + entry.persist = shEntry.persist; + + return entry; + }, + + /** + * Get an object that is a serializable representation of a PresState. + * + * @param layoutHistoryState + * nsILayoutHistoryState instance + * @param stateKey + * The state key of the presState to be retrieved. + * @return object + */ + _getSerializablePresState(layoutHistoryState, stateKey) { + let presState = { stateKey }; + let x = {}, + y = {}, + scrollOriginDowngrade = {}, + res = {}; + + layoutHistoryState.getPresState(stateKey, x, y, scrollOriginDowngrade, res); + if (x.value !== 0 || y.value !== 0) { + presState.scroll = x.value + "," + y.value; + } + if (scrollOriginDowngrade.value === false) { + presState.scrollOriginDowngrade = scrollOriginDowngrade.value; + } + if (res.value != 1.0) { + presState.res = res.value; + } + + return presState; + }, + + /** + * Restores session history data for a given docShell. + * + * @param history + * The session history object. + * @param tabData + * The tabdata including all history entries. + * @return A reference to the docShell's nsISHistory interface. + */ + restore(history, tabData) { + if (history.count > 0) { + history.purgeHistory(history.count); + } + + let idMap = { used: {} }; + let docIdentMap = {}; + for (let i = 0; i < tabData.entries.length; i++) { + let entry = tabData.entries[i]; + // XXXzpao Wallpaper patch for bug 514751 + if (!entry.url) { + continue; + } + let persist = "persist" in entry ? entry.persist : true; + let shEntry = this.deserializeEntry(entry, idMap, docIdentMap, history); + + // To enable a smooth migration, we treat values of null/undefined as having + // user interaction (because we don't want to hide all session history that was + // added before we started recording user interaction). + // + // This attribute is only set on top-level SH history entries, so we set it + // outside of deserializeEntry since that is called recursively. + if (entry.hasUserInteraction == undefined) { + shEntry.hasUserInteraction = true; + } else { + shEntry.hasUserInteraction = entry.hasUserInteraction; + } + + history.addEntry(shEntry, persist); + } + + // Select the right history entry. + let index = tabData.index - 1; + if (index < history.count && history.index != index) { + history.index = index; + } + return history; + }, + + /** + * 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(entry, idMap, docIdentMap, shistory) { + var shEntry = shistory.createEntry(); + + shEntry.URI = Services.io.newURI(entry.url); + shEntry.title = entry.title || entry.url; + if (entry.subframe) { + shEntry.isSubFrame = entry.subframe || false; + } + shEntry.setLoadTypeAsHistory(); + if (entry.contentType) { + shEntry.contentType = entry.contentType; + } + // Referrer information is now stored as a referrerInfo property. We should + // also cope with the old format of passing `referrer` and `referrerPolicy` + // separately. + if (entry.referrerInfo) { + shEntry.referrerInfo = lazy.E10SUtils.deserializeReferrerInfo( + entry.referrerInfo + ); + } else if (entry.referrer) { + let ReferrerInfo = Components.Constructor( + "@mozilla.org/referrer-info;1", + "nsIReferrerInfo", + "init" + ); + shEntry.referrerInfo = new ReferrerInfo( + entry.referrerPolicy, + true, + Services.io.newURI(entry.referrer) + ); + } + + if (entry.originalURI) { + shEntry.originalURI = Services.io.newURI(entry.originalURI); + } + if (typeof entry.resultPrincipalURI === "undefined" && entry.loadReplace) { + // This is backward compatibility code for stored sessions saved prior to + // introduction of the resultPrincipalURI property. The equivalent of this + // property non-null value used to be the URL while the LOAD_REPLACE flag + // was set. + shEntry.resultPrincipalURI = shEntry.URI; + } else if (entry.resultPrincipalURI) { + shEntry.resultPrincipalURI = Services.io.newURI(entry.resultPrincipalURI); + } + if (entry.loadReplace2) { + shEntry.loadReplace = entry.loadReplace2; + } + if (entry.isSrcdocEntry) { + shEntry.srcdocData = entry.srcdocData; + } + if (entry.baseURI) { + shEntry.baseURI = Services.io.newURI(entry.baseURI); + } + + if (entry.cacheKey) { + shEntry.cacheKey = entry.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) { + // eslint-disable-next-line no-empty + for (id = Date.now(); id in idMap.used; id++) {} + idMap[entry.ID] = id; + idMap.used[id] = true; + } + shEntry.ID = id; + } + + // If we have the legacy docshellID on our entry, upgrade it to a + // docshellUUID by going through the mapping. + if (entry.docshellID) { + if (!this._docshellUUIDMap.has(entry.docshellID)) { + // Convert the nsID to a string so that the docshellUUID property + // is correctly stored as a string. + this._docshellUUIDMap.set( + entry.docshellID, + Services.uuid.generateUUID().toString() + ); + } + entry.docshellUUID = this._docshellUUIDMap.get(entry.docshellID); + delete entry.docshellID; + } + + if (entry.docshellUUID) { + shEntry.docshellID = Components.ID(entry.docshellUUID); + } + + if (entry.structuredCloneState && entry.structuredCloneVersion) { + var stateData = Cc[ + "@mozilla.org/docshell/structured-clone-container;1" + ].createInstance(Ci.nsIStructuredCloneContainer); + + stateData.initFromBase64( + entry.structuredCloneState, + entry.structuredCloneVersion + ); + shEntry.stateData = stateData; + } + + if (entry.scrollRestorationIsManual) { + shEntry.scrollRestorationIsManual = true; + } else { + if (entry.scroll) { + shEntry.setScrollPosition( + ...this._deserializeScrollPosition(entry.scroll) + ); + } + + if (entry.presState) { + let layoutHistoryState = shEntry.initLayoutHistoryState(); + + for (let presState of entry.presState) { + this._deserializePresState(layoutHistoryState, presState); + } + } + } + + 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, childDocIdents }; + docIdentMap[entry.docIdentifier] = matchingEntry; + } else { + shEntry.adoptBFCacheEntry(matchingEntry.shEntry); + childDocIdents = matchingEntry.childDocIdents; + } + } + + // Every load must have a triggeringPrincipal to load otherwise we prevent it, + // this code *must* always return a valid principal: + shEntry.triggeringPrincipal = lazy.E10SUtils.deserializePrincipal( + entry.triggeringPrincipal_base64, + () => { + // This callback fires when we failed to deserialize the principal (or we don't have one) + // and this ensures we always have a principal returned from this function. + // We must always have a triggering principal for a load to work. + // A null principal won't always work however is safe to use. + console.warn( + "Couldn't deserialize the triggeringPrincipal, falling back to NullPrincipal" + ); + return Services.scriptSecurityManager.createNullPrincipal({}); + } + ); + // As both partitionedPrincipal and principalToInherit are both not required to load + // it's ok to keep these undefined when we don't have a previously defined principal. + if (entry.partitionedPrincipalToInherit_base64) { + shEntry.partitionedPrincipalToInherit = + lazy.E10SUtils.deserializePrincipal( + entry.partitionedPrincipalToInherit_base64 + ); + } + if (entry.principalToInherit_base64) { + shEntry.principalToInherit = lazy.E10SUtils.deserializePrincipal( + entry.principalToInherit_base64 + ); + } + if (entry.csp) { + shEntry.csp = lazy.E10SUtils.deserializeCSP(entry.csp); + } + if (entry.wireframe) { + shEntry.wireframe = entry.wireframe; + } + + if (entry.children) { + 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, + shistory + ), + i + ); + } + } + + return shEntry; + }, + + /** + * Expands serialized PresState data and adds it to the given nsILayoutHistoryState. + * + * @param layoutHistoryState + * nsILayoutHistoryState instance + * @param presState + * Object containing serialized PresState data. + */ + _deserializePresState(layoutHistoryState, presState) { + let stateKey = presState.stateKey; + let scrollOriginDowngrade = + typeof presState.scrollOriginDowngrade == "boolean" + ? presState.scrollOriginDowngrade + : true; + let res = presState.res || 1.0; + + layoutHistoryState.addNewPresState( + stateKey, + ...this._deserializeScrollPosition(presState.scroll), + scrollOriginDowngrade, + res + ); + }, + + /** + * Expands serialized scroll position data into an array containing the x and y coordinates, + * defaulting to 0,0 if no scroll position was found. + * + * @param scroll + * Object containing serialized scroll position data. + * @return An array containing the scroll position's x and y coordinates. + */ + _deserializeScrollPosition(scroll = "0,0") { + return scroll.split(",").map(pos => parseInt(pos, 10) || 0); + }, +}; |