diff options
Diffstat (limited to 'browser/components/sessionstore/SessionStore.sys.mjs')
| -rw-r--r-- | browser/components/sessionstore/SessionStore.sys.mjs | 6861 |
1 files changed, 6861 insertions, 0 deletions
diff --git a/browser/components/sessionstore/SessionStore.sys.mjs b/browser/components/sessionstore/SessionStore.sys.mjs new file mode 100644 index 0000000000..36d2bb4ecd --- /dev/null +++ b/browser/components/sessionstore/SessionStore.sys.mjs @@ -0,0 +1,6861 @@ +/* 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/. */ + +// Current version of the format used by Session Restore. +const FORMAT_VERSION = 1; + +const TAB_CUSTOM_VALUES = new WeakMap(); +const TAB_LAZY_STATES = new WeakMap(); +const TAB_STATE_NEEDS_RESTORE = 1; +const TAB_STATE_RESTORING = 2; +const TAB_STATE_FOR_BROWSER = new WeakMap(); +const WINDOW_RESTORE_IDS = new WeakMap(); +const WINDOW_RESTORE_ZINDICES = new WeakMap(); +const WINDOW_SHOWING_PROMISES = new Map(); +const WINDOW_FLUSHING_PROMISES = new Map(); + +// A new window has just been restored. At this stage, tabs are generally +// not restored. +const NOTIFY_SINGLE_WINDOW_RESTORED = "sessionstore-single-window-restored"; +const NOTIFY_WINDOWS_RESTORED = "sessionstore-windows-restored"; +const NOTIFY_BROWSER_STATE_RESTORED = "sessionstore-browser-state-restored"; +const NOTIFY_LAST_SESSION_CLEARED = "sessionstore-last-session-cleared"; +const NOTIFY_RESTORING_ON_STARTUP = "sessionstore-restoring-on-startup"; +const NOTIFY_INITIATING_MANUAL_RESTORE = + "sessionstore-initiating-manual-restore"; +const NOTIFY_CLOSED_OBJECTS_CHANGED = "sessionstore-closed-objects-changed"; + +const NOTIFY_TAB_RESTORED = "sessionstore-debug-tab-restored"; // WARNING: debug-only +const NOTIFY_DOMWINDOWCLOSED_HANDLED = + "sessionstore-debug-domwindowclosed-handled"; // WARNING: debug-only + +const NOTIFY_BROWSER_SHUTDOWN_FLUSH = "sessionstore-browser-shutdown-flush"; + +// Maximum number of tabs to restore simultaneously. Previously controlled by +// the browser.sessionstore.max_concurrent_tabs pref. +const MAX_CONCURRENT_TAB_RESTORES = 3; + +// Amount (in CSS px) by which we allow window edges to be off-screen +// when restoring a window, before we override the saved position to +// pull the window back within the available screen area. +const SCREEN_EDGE_SLOP = 8; + +// global notifications observed +const OBSERVING = [ + "browser-window-before-show", + "domwindowclosed", + "quit-application-granted", + "browser-lastwindow-close-granted", + "quit-application", + "browser:purge-session-history", + "browser:purge-session-history-for-domain", + "idle-daily", + "clear-origin-attributes-data", + "browsing-context-did-set-embedder", + "browsing-context-discarded", + "browser-shutdown-tabstate-updated", +]; + +// XUL Window properties to (re)store +// Restored in restoreDimensions() +const WINDOW_ATTRIBUTES = ["width", "height", "screenX", "screenY", "sizemode"]; + +const CHROME_FLAGS_MAP = [ + [Ci.nsIWebBrowserChrome.CHROME_TITLEBAR, "titlebar"], + [Ci.nsIWebBrowserChrome.CHROME_WINDOW_CLOSE, "close"], + [Ci.nsIWebBrowserChrome.CHROME_TOOLBAR, "toolbar"], + [Ci.nsIWebBrowserChrome.CHROME_LOCATIONBAR, "location"], + [Ci.nsIWebBrowserChrome.CHROME_PERSONAL_TOOLBAR, "personalbar"], + [Ci.nsIWebBrowserChrome.CHROME_STATUSBAR, "status"], + [Ci.nsIWebBrowserChrome.CHROME_MENUBAR, "menubar"], + [Ci.nsIWebBrowserChrome.CHROME_WINDOW_RESIZE, "resizable"], + [Ci.nsIWebBrowserChrome.CHROME_WINDOW_MIN, "minimizable"], + [Ci.nsIWebBrowserChrome.CHROME_SCROLLBARS, "", "scrollbars=0"], + [Ci.nsIWebBrowserChrome.CHROME_PRIVATE_WINDOW, "private"], + [Ci.nsIWebBrowserChrome.CHROME_NON_PRIVATE_WINDOW, "non-private"], + // Do not inherit remoteness and fissionness from the previous session. + //[Ci.nsIWebBrowserChrome.CHROME_REMOTE_WINDOW, "remote", "non-remote"], + //[Ci.nsIWebBrowserChrome.CHROME_FISSION_WINDOW, "fission", "non-fission"], + [Ci.nsIWebBrowserChrome.CHROME_WINDOW_POPUP, "popup"], + [ + Ci.nsIWebBrowserChrome.CHROME_WINDOW_POPUP | + Ci.nsIWebBrowserChrome.CHROME_TITLEBAR, + "", + "titlebar=0", + ], + [ + Ci.nsIWebBrowserChrome.CHROME_WINDOW_POPUP | + Ci.nsIWebBrowserChrome.CHROME_WINDOW_CLOSE, + "", + "close=0", + ], + [Ci.nsIWebBrowserChrome.CHROME_WINDOW_LOWERED, "alwayslowered"], + [Ci.nsIWebBrowserChrome.CHROME_WINDOW_RAISED, "alwaysraised"], + // "chrome" and "suppressanimation" are always set. + //[Ci.nsIWebBrowserChrome.CHROME_SUPPRESS_ANIMATION, "suppressanimation"], + [Ci.nsIWebBrowserChrome.CHROME_ALWAYS_ON_TOP, "alwaysontop"], + //[Ci.nsIWebBrowserChrome.CHROME_OPENAS_CHROME, "chrome", "chrome=0"], + [Ci.nsIWebBrowserChrome.CHROME_EXTRA, "extrachrome"], + [Ci.nsIWebBrowserChrome.CHROME_CENTER_SCREEN, "centerscreen"], + [Ci.nsIWebBrowserChrome.CHROME_DEPENDENT, "dependent"], + [Ci.nsIWebBrowserChrome.CHROME_MODAL, "modal"], + [Ci.nsIWebBrowserChrome.CHROME_OPENAS_DIALOG, "dialog", "dialog=0"], +]; + +// Hideable window features to (re)store +// Restored in restoreWindowFeatures() +const WINDOW_HIDEABLE_FEATURES = [ + "menubar", + "toolbar", + "locationbar", + "personalbar", + "statusbar", + "scrollbars", +]; + +const WINDOW_OPEN_FEATURES_MAP = { + locationbar: "location", + statusbar: "status", +}; + +// Messages that will be received via the Frame Message Manager. +const MESSAGES = [ + // The content script sends us data that has been invalidated and needs to + // be saved to disk. + "SessionStore:update", + + // The restoreHistory code has run. This is a good time to run SSTabRestoring. + "SessionStore:restoreHistoryComplete", + + // The load for the restoring tab has begun. We update the URL bar at this + // time; if we did it before, the load would overwrite it. + "SessionStore:restoreTabContentStarted", + + // All network loads for a restoring tab are done, so we should + // consider restoring another tab in the queue. The document has + // been restored, and forms have been filled. We trigger + // SSTabRestored at this time. + "SessionStore:restoreTabContentComplete", + + // The content script encountered an error. + "SessionStore:error", +]; + +// The list of messages we accept from <xul:browser>s that have no tab +// assigned, or whose windows have gone away. Those are for example the +// ones that preload about:newtab pages, or from browsers where the window +// has just been closed. +const NOTAB_MESSAGES = new Set([ + // For a description see above. + "SessionStore:update", + + // For a description see above. + "SessionStore:error", +]); + +// The list of messages we accept without an "epoch" parameter. +// See getCurrentEpoch() and friends to find out what an "epoch" is. +const NOEPOCH_MESSAGES = new Set([ + // For a description see above. + "SessionStore:error", +]); + +// The list of messages we want to receive even during the short period after a +// frame has been removed from the DOM and before its frame script has finished +// unloading. +const CLOSED_MESSAGES = new Set([ + // For a description see above. + "SessionStore:update", + + // For a description see above. + "SessionStore:error", +]); + +// These are tab events that we listen to. +const TAB_EVENTS = [ + "TabOpen", + "TabBrowserInserted", + "TabClose", + "TabSelect", + "TabShow", + "TabHide", + "TabPinned", + "TabUnpinned", +]; + +const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"; + +/** + * When calling restoreTabContent, we can supply a reason why + * the content is being restored. These are those reasons. + */ +const RESTORE_TAB_CONTENT_REASON = { + /** + * SET_STATE: + * We're restoring this tab's content because we're setting + * state inside this browser tab, probably because the user + * has asked us to restore a tab (or window, or entire session). + */ + SET_STATE: 0, + /** + * NAVIGATE_AND_RESTORE: + * We're restoring this tab's content because a navigation caused + * us to do a remoteness-flip. + */ + NAVIGATE_AND_RESTORE: 1, +}; + +// 'browser.startup.page' preference value to resume the previous session. +const BROWSER_STARTUP_RESUME_SESSION = 3; + +// Used by SessionHistoryListener. +const kNoIndex = Number.MAX_SAFE_INTEGER; +const kLastIndex = Number.MAX_SAFE_INTEGER - 1; + +import { PrivateBrowsingUtils } from "resource://gre/modules/PrivateBrowsingUtils.sys.mjs"; + +import { TelemetryTimestamps } from "resource://gre/modules/TelemetryTimestamps.sys.mjs"; +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; +import { GlobalState } from "resource:///modules/sessionstore/GlobalState.sys.mjs"; + +const lazy = {}; + +XPCOMUtils.defineLazyServiceGetters(lazy, { + gScreenManager: ["@mozilla.org/gfx/screenmanager;1", "nsIScreenManager"], +}); + +ChromeUtils.defineESModuleGetters(lazy, { + AsyncShutdown: "resource://gre/modules/AsyncShutdown.sys.mjs", + DevToolsShim: "chrome://devtools-startup/content/DevToolsShim.sys.mjs", + E10SUtils: "resource://gre/modules/E10SUtils.sys.mjs", + PrivacyFilter: "resource://gre/modules/sessionstore/PrivacyFilter.sys.mjs", + PromiseUtils: "resource://gre/modules/PromiseUtils.sys.mjs", + RunState: "resource:///modules/sessionstore/RunState.sys.mjs", + SessionCookies: "resource:///modules/sessionstore/SessionCookies.sys.mjs", + SessionFile: "resource:///modules/sessionstore/SessionFile.sys.mjs", + SessionHistory: "resource://gre/modules/sessionstore/SessionHistory.sys.mjs", + SessionSaver: "resource:///modules/sessionstore/SessionSaver.sys.mjs", + SessionStartup: "resource:///modules/sessionstore/SessionStartup.sys.mjs", + TabAttributes: "resource:///modules/sessionstore/TabAttributes.sys.mjs", + TabState: "resource:///modules/sessionstore/TabState.sys.mjs", + TabStateCache: "resource:///modules/sessionstore/TabStateCache.sys.mjs", + TabStateFlusher: "resource:///modules/sessionstore/TabStateFlusher.sys.mjs", + setTimeout: "resource://gre/modules/Timer.sys.mjs", +}); + +XPCOMUtils.defineLazyModuleGetters(lazy, { + BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.jsm", + HomePage: "resource:///modules/HomePage.jsm", + TabCrashHandler: "resource:///modules/ContentCrashHandlers.jsm", +}); + +/** + * |true| if we are in debug mode, |false| otherwise. + * Debug mode is controlled by preference browser.sessionstore.debug + */ +var gDebuggingEnabled = false; + +/** + * A global value to tell that fingerprinting resistance is enabled or not. + * If it's enabled, the session restore won't restore the window's size and + * size mode. + * This value is controlled by preference privacy.resistFingerprinting. + */ +var gResistFingerprintingEnabled = false; + +export var SessionStore = { + get promiseInitialized() { + return SessionStoreInternal.promiseInitialized; + }, + + get promiseAllWindowsRestored() { + return SessionStoreInternal.promiseAllWindowsRestored; + }, + + get canRestoreLastSession() { + return SessionStoreInternal.canRestoreLastSession; + }, + + set canRestoreLastSession(val) { + SessionStoreInternal.canRestoreLastSession = val; + }, + + get lastClosedObjectType() { + return SessionStoreInternal.lastClosedObjectType; + }, + + get willAutoRestore() { + return SessionStoreInternal.willAutoRestore; + }, + + init: function ss_init() { + SessionStoreInternal.init(); + }, + + getBrowserState: function ss_getBrowserState() { + return SessionStoreInternal.getBrowserState(); + }, + + setBrowserState: function ss_setBrowserState(aState) { + SessionStoreInternal.setBrowserState(aState); + }, + + getWindowState: function ss_getWindowState(aWindow) { + return SessionStoreInternal.getWindowState(aWindow); + }, + + setWindowState: function ss_setWindowState(aWindow, aState, aOverwrite) { + SessionStoreInternal.setWindowState(aWindow, aState, aOverwrite); + }, + + getTabState: function ss_getTabState(aTab) { + return SessionStoreInternal.getTabState(aTab); + }, + + setTabState: function ss_setTabState(aTab, aState) { + SessionStoreInternal.setTabState(aTab, aState); + }, + + // Return whether a tab is restoring. + isTabRestoring(aTab) { + return TAB_STATE_FOR_BROWSER.has(aTab.linkedBrowser); + }, + + getInternalObjectState(obj) { + return SessionStoreInternal.getInternalObjectState(obj); + }, + + duplicateTab: function ss_duplicateTab( + aWindow, + aTab, + aDelta = 0, + aRestoreImmediately = true, + aOptions = {} + ) { + return SessionStoreInternal.duplicateTab( + aWindow, + aTab, + aDelta, + aRestoreImmediately, + aOptions + ); + }, + + getLastClosedTabCount(aWindow) { + return SessionStoreInternal.getLastClosedTabCount(aWindow); + }, + + resetLastClosedTabCount(aWindow) { + SessionStoreInternal.resetLastClosedTabCount(aWindow); + }, + + getClosedTabCount: function ss_getClosedTabCount(aWindow) { + return SessionStoreInternal.getClosedTabCount(aWindow); + }, + + getClosedTabData: function ss_getClosedTabData(aWindow) { + return SessionStoreInternal.getClosedTabData(aWindow); + }, + + undoCloseTab: function ss_undoCloseTab(aWindow, aIndex) { + return SessionStoreInternal.undoCloseTab(aWindow, aIndex); + }, + + forgetClosedTab: function ss_forgetClosedTab(aWindow, aIndex) { + return SessionStoreInternal.forgetClosedTab(aWindow, aIndex); + }, + + getClosedWindowCount: function ss_getClosedWindowCount() { + return SessionStoreInternal.getClosedWindowCount(); + }, + + getClosedWindowData: function ss_getClosedWindowData() { + return SessionStoreInternal.getClosedWindowData(); + }, + + maybeDontRestoreTabs(aWindow) { + SessionStoreInternal.maybeDontRestoreTabs(aWindow); + }, + + undoCloseWindow: function ss_undoCloseWindow(aIndex) { + return SessionStoreInternal.undoCloseWindow(aIndex); + }, + + forgetClosedWindow: function ss_forgetClosedWindow(aIndex) { + return SessionStoreInternal.forgetClosedWindow(aIndex); + }, + + getCustomWindowValue(aWindow, aKey) { + return SessionStoreInternal.getCustomWindowValue(aWindow, aKey); + }, + + setCustomWindowValue(aWindow, aKey, aStringValue) { + SessionStoreInternal.setCustomWindowValue(aWindow, aKey, aStringValue); + }, + + deleteCustomWindowValue(aWindow, aKey) { + SessionStoreInternal.deleteCustomWindowValue(aWindow, aKey); + }, + + getCustomTabValue(aTab, aKey) { + return SessionStoreInternal.getCustomTabValue(aTab, aKey); + }, + + setCustomTabValue(aTab, aKey, aStringValue) { + SessionStoreInternal.setCustomTabValue(aTab, aKey, aStringValue); + }, + + deleteCustomTabValue(aTab, aKey) { + SessionStoreInternal.deleteCustomTabValue(aTab, aKey); + }, + + getLazyTabValue(aTab, aKey) { + return SessionStoreInternal.getLazyTabValue(aTab, aKey); + }, + + getCustomGlobalValue(aKey) { + return SessionStoreInternal.getCustomGlobalValue(aKey); + }, + + setCustomGlobalValue(aKey, aStringValue) { + SessionStoreInternal.setCustomGlobalValue(aKey, aStringValue); + }, + + deleteCustomGlobalValue(aKey) { + SessionStoreInternal.deleteCustomGlobalValue(aKey); + }, + + persistTabAttribute: function ss_persistTabAttribute(aName) { + SessionStoreInternal.persistTabAttribute(aName); + }, + + restoreLastSession: function ss_restoreLastSession() { + SessionStoreInternal.restoreLastSession(); + }, + + speculativeConnectOnTabHover(tab) { + SessionStoreInternal.speculativeConnectOnTabHover(tab); + }, + + getCurrentState(aUpdateAll) { + return SessionStoreInternal.getCurrentState(aUpdateAll); + }, + + reviveCrashedTab(aTab) { + return SessionStoreInternal.reviveCrashedTab(aTab); + }, + + reviveAllCrashedTabs() { + return SessionStoreInternal.reviveAllCrashedTabs(); + }, + + updateSessionStoreFromTablistener( + aBrowser, + aBrowsingContext, + aPermanentKey, + aData + ) { + return SessionStoreInternal.updateSessionStoreFromTablistener( + aBrowser, + aBrowsingContext, + aPermanentKey, + aData + ); + }, + + getSessionHistory(tab, updatedCallback) { + return SessionStoreInternal.getSessionHistory(tab, updatedCallback); + }, + + undoCloseById(aClosedId, aIncludePrivate) { + return SessionStoreInternal.undoCloseById(aClosedId, aIncludePrivate); + }, + + resetBrowserToLazyState(tab) { + return SessionStoreInternal.resetBrowserToLazyState(tab); + }, + + maybeExitCrashedState(browser) { + SessionStoreInternal.maybeExitCrashedState(browser); + }, + + isBrowserInCrashedSet(browser) { + return SessionStoreInternal.isBrowserInCrashedSet(browser); + }, + + // this is used for testing purposes + resetNextClosedId() { + SessionStoreInternal._nextClosedId = 0; + }, + + /** + * Ensures that session store has registered and started tracking a given window. + * @param window + * Window reference + */ + ensureInitialized(window) { + if (SessionStoreInternal._sessionInitialized && !window.__SSi) { + /* + We need to check that __SSi is not defined on the window so that if + onLoad function is in the middle of executing we don't enter the function + again and try to redeclare the ContentSessionStore script. + */ + SessionStoreInternal.onLoad(window); + } + }, + + getCurrentEpoch(browser) { + return SessionStoreInternal.getCurrentEpoch(browser.permanentKey); + }, + + /** + * Determines whether the passed version number is compatible with + * the current version number of the SessionStore. + * + * @param version The format and version of the file, as an array, e.g. + * ["sessionrestore", 1] + */ + isFormatVersionCompatible(version) { + if (!version) { + return false; + } + if (!Array.isArray(version)) { + // Improper format. + return false; + } + if (version[0] != "sessionrestore") { + // Not a Session Restore file. + return false; + } + let number = Number.parseFloat(version[1]); + if (Number.isNaN(number)) { + return false; + } + return number <= FORMAT_VERSION; + }, + + /** + * Filters out not worth-saving tabs from a given browser state object. + * + * @param aState (object) + * The browser state for which we remove worth-saving tabs. + * The given object will be modified. + */ + keepOnlyWorthSavingTabs(aState) { + let closedWindowShouldRestore = null; + for (let i = aState.windows.length - 1; i >= 0; i--) { + let win = aState.windows[i]; + for (let j = win.tabs.length - 1; j >= 0; j--) { + let tab = win.tabs[j]; + if (!SessionStoreInternal._shouldSaveTab(tab)) { + win.tabs.splice(j, 1); + if (win.selected > j) { + win.selected--; + } + } + } + + // If it's the last window (and no closedWindow that will restore), keep the window state with no tabs. + if ( + !win.tabs.length && + (aState.windows.length > 1 || + closedWindowShouldRestore || + (closedWindowShouldRestore == null && + (closedWindowShouldRestore = aState._closedWindows.some( + w => w._shouldRestore + )))) + ) { + aState.windows.splice(i, 1); + if (aState.selectedWindow > i) { + aState.selectedWindow--; + } + } + } + }, + + /** + * Prepares to change the remoteness of the given browser, by ensuring that + * the local instance of session history is up-to-date. + */ + async prepareToChangeRemoteness(aTab) { + await SessionStoreInternal.prepareToChangeRemoteness(aTab); + }, + + finishTabRemotenessChange(aTab, aSwitchId) { + SessionStoreInternal.finishTabRemotenessChange(aTab, aSwitchId); + }, +}; + +// Freeze the SessionStore object. We don't want anyone to modify it. +Object.freeze(SessionStore); + +var SessionStoreInternal = { + QueryInterface: ChromeUtils.generateQI([ + "nsIObserver", + "nsISupportsWeakReference", + ]), + + _globalState: new GlobalState(), + + // A counter to be used to generate a unique ID for each closed tab or window. + _nextClosedId: 0, + + // During the initial restore and setBrowserState calls tracks the number of + // windows yet to be restored + _restoreCount: -1, + + // For each <browser> element, records the SHistoryListener. + _browserSHistoryListener: new WeakMap(), + + // Tracks the various listeners that are used throughout the restore. + _restoreListeners: new WeakMap(), + + // Records the promise created in _restoreHistory, which is used to track + // the completion of the first phase of the restore. + _tabStateRestorePromises: new WeakMap(), + + // The history data needed to be restored in the parent. + _tabStateToRestore: new WeakMap(), + + // For each <browser> element, records the current epoch. + _browserEpochs: new WeakMap(), + + // Any browsers that fires the oop-browser-crashed event gets stored in + // here - that way we know which browsers to ignore messages from (until + // they get restored). + _crashedBrowsers: new WeakSet(), + + // A map (xul:browser -> FrameLoader) that maps a browser to the last + // associated frameLoader we heard about. + _lastKnownFrameLoader: new WeakMap(), + + // A map (xul:browser -> object) that maps a browser associated with a + // recently closed tab to all its necessary state information we need to + // properly handle final update message. + _closedTabs: new WeakMap(), + + // A map (xul:browser -> object) that maps a browser associated with a + // recently closed tab due to a window closure to the tab state information + // that is being stored in _closedWindows for that tab. + _closedWindowTabs: new WeakMap(), + + // A set of window data that has the potential to be saved in the _closedWindows + // array for the session. We will remove window data from this set whenever + // forgetClosedWindow is called for the window, or when session history is + // purged, so that we don't accidentally save that data after the flush has + // completed. Closed tabs use a more complicated mechanism for this particular + // problem. When forgetClosedTab is called, the browser is removed from the + // _closedTabs map, so its data is not recorded. In the purge history case, + // the closedTabs array per window is overwritten so that once the flush is + // complete, the tab would only ever add itself to an array that SessionStore + // no longer cares about. Bug 1230636 has been filed to make the tab case + // work more like the window case, which is more explicit, and easier to + // reason about. + _saveableClosedWindowData: new WeakSet(), + + // whether a setBrowserState call is in progress + _browserSetState: false, + + // time in milliseconds when the session was started (saved across sessions), + // defaults to now if no session was restored or timestamp doesn't exist + _sessionStartTime: Date.now(), + + // states for all currently opened windows + _windows: {}, + + // counter for creating unique window IDs + _nextWindowID: 0, + + // states for all recently closed windows + _closedWindows: [], + + // collection of session states yet to be restored + _statesToRestore: {}, + + // counts the number of crashes since the last clean start + _recentCrashes: 0, + + // whether the last window was closed and should be restored + _restoreLastWindow: false, + + // number of tabs currently restoring + _tabsRestoringCount: 0, + + _log: null, + + // When starting Firefox with a single private window, this is the place + // where we keep the session we actually wanted to restore in case the user + // decides to later open a non-private window as well. + _deferredInitialState: null, + + // Keeps track of whether a notification needs to be sent that closed objects have changed. + _closedObjectsChanged: false, + + // A promise resolved once initialization is complete + _deferredInitialized: (function() { + let deferred = {}; + + deferred.promise = new Promise((resolve, reject) => { + deferred.resolve = resolve; + deferred.reject = reject; + }); + + return deferred; + })(), + + // Whether session has been initialized + _sessionInitialized: false, + + // A promise resolved once all windows are restored. + _deferredAllWindowsRestored: (function() { + let deferred = {}; + + deferred.promise = new Promise((resolve, reject) => { + deferred.resolve = resolve; + deferred.reject = reject; + }); + + return deferred; + })(), + + get promiseAllWindowsRestored() { + return this._deferredAllWindowsRestored.promise; + }, + + // Promise that is resolved when we're ready to initialize + // and restore the session. + _promiseReadyForInitialization: null, + + // Keep busy state counters per window. + _windowBusyStates: new WeakMap(), + + /** + * A promise fulfilled once initialization is complete. + */ + get promiseInitialized() { + return this._deferredInitialized.promise; + }, + + get canRestoreLastSession() { + return LastSession.canRestore; + }, + + set canRestoreLastSession(val) { + // Cheat a bit; only allow false. + if (!val) { + LastSession.clear(); + } + }, + + /** + * Returns a string describing the last closed object, either "tab" or "window". + * + * This was added to support the sessions.restore WebExtensions API. + */ + get lastClosedObjectType() { + if (this._closedWindows.length) { + // Since there are closed windows, we need to check if there's a closed tab + // in one of the currently open windows that was closed after the + // last-closed window. + let tabTimestamps = []; + for (let window of Services.wm.getEnumerator("navigator:browser")) { + let windowState = this._windows[window.__SSi]; + if (windowState && windowState._closedTabs[0]) { + tabTimestamps.push(windowState._closedTabs[0].closedAt); + } + } + if ( + !tabTimestamps.length || + tabTimestamps.sort((a, b) => b - a)[0] < this._closedWindows[0].closedAt + ) { + return "window"; + } + } + return "tab"; + }, + + /** + * Returns a boolean that determines whether the session will be automatically + * restored upon the _next_ startup or a restart. + */ + get willAutoRestore() { + return ( + !PrivateBrowsingUtils.permanentPrivateBrowsing && + (Services.prefs.getBoolPref("browser.sessionstore.resume_session_once") || + Services.prefs.getIntPref("browser.startup.page") == + BROWSER_STARTUP_RESUME_SESSION) + ); + }, + + /** + * Initialize the sessionstore service. + */ + init() { + if (this._initialized) { + throw new Error("SessionStore.init() must only be called once!"); + } + + TelemetryTimestamps.add("sessionRestoreInitialized"); + OBSERVING.forEach(function(aTopic) { + Services.obs.addObserver(this, aTopic, true); + }, this); + + this._initPrefs(); + this._initialized = true; + + Services.telemetry + .getHistogramById("FX_SESSION_RESTORE_PRIVACY_LEVEL") + .add(Services.prefs.getIntPref("browser.sessionstore.privacy_level")); + }, + + /** + * Initialize the session using the state provided by SessionStartup + */ + initSession() { + TelemetryStopwatch.start("FX_SESSION_RESTORE_STARTUP_INIT_SESSION_MS"); + let state; + let ss = lazy.SessionStartup; + + if (ss.willRestore() || ss.sessionType == ss.DEFER_SESSION) { + state = ss.state; + } + + if (state) { + try { + // If we're doing a DEFERRED session, then we want to pull pinned tabs + // out so they can be restored. + if (ss.sessionType == ss.DEFER_SESSION) { + let [iniState, remainingState] = this._prepDataForDeferredRestore( + state + ); + // If we have a iniState with windows, that means that we have windows + // with app tabs to restore. + if (iniState.windows.length) { + // Move cookies over from the remaining state so that they're + // restored right away, and pinned tabs will load correctly. + iniState.cookies = remainingState.cookies; + delete remainingState.cookies; + state = iniState; + } else { + state = null; + } + + if (remainingState.windows.length) { + LastSession.setState(remainingState); + } + Services.telemetry.keyedScalarAdd( + "browser.engagement.sessionrestore_interstitial", + "deferred_restore", + 1 + ); + } else { + // Get the last deferred session in case the user still wants to + // restore it + LastSession.setState(state.lastSessionState); + + let restoreAsCrashed = ss.willRestoreAsCrashed(); + if (restoreAsCrashed) { + this._recentCrashes = + ((state.session && state.session.recentCrashes) || 0) + 1; + + // _needsRestorePage will record sessionrestore_interstitial, + // including the specific reason we decided we needed to show + // about:sessionrestore, if that's what we do. + if (this._needsRestorePage(state, this._recentCrashes)) { + // replace the crashed session with a restore-page-only session + let url = "about:sessionrestore"; + let formdata = { id: { sessionData: state }, url }; + let entry = { + url, + triggeringPrincipal_base64: + lazy.E10SUtils.SERIALIZED_SYSTEMPRINCIPAL, + }; + state = { windows: [{ tabs: [{ entries: [entry], formdata }] }] }; + } else if ( + this._hasSingleTabWithURL(state.windows, "about:welcomeback") + ) { + Services.telemetry.keyedScalarAdd( + "browser.engagement.sessionrestore_interstitial", + "shown_only_about_welcomeback", + 1 + ); + // On a single about:welcomeback URL that crashed, replace about:welcomeback + // with about:sessionrestore, to make clear to the user that we crashed. + state.windows[0].tabs[0].entries[0].url = "about:sessionrestore"; + state.windows[0].tabs[0].entries[0].triggeringPrincipal_base64 = + lazy.E10SUtils.SERIALIZED_SYSTEMPRINCIPAL; + } else { + restoreAsCrashed = false; + } + } + + // If we didn't use about:sessionrestore, record that: + if (!restoreAsCrashed) { + Services.telemetry.keyedScalarAdd( + "browser.engagement.sessionrestore_interstitial", + "autorestore", + 1 + ); + + this._removeExplicitlyClosedTabs(state); + } + + // Update the session start time using the restored session state. + this._updateSessionStartTime(state); + + // Make sure that at least the first window doesn't have anything hidden. + delete state.windows[0].hidden; + // Since nothing is hidden in the first window, it cannot be a popup. + delete state.windows[0].isPopup; + // We don't want to minimize and then open a window at startup. + if (state.windows[0].sizemode == "minimized") { + state.windows[0].sizemode = "normal"; + } + + // clear any lastSessionWindowID attributes since those don't matter + // during normal restore + state.windows.forEach(function(aWindow) { + delete aWindow.__lastSessionWindowID; + }); + } + + // clear _maybeDontRestoreTabs because we have restored (or not) + // windows and so they don't matter + state?.windows?.forEach(win => delete win._maybeDontRestoreTabs); + state?._closedWindows?.forEach(win => delete win._maybeDontRestoreTabs); + } catch (ex) { + this._log.error("The session file is invalid: " + ex); + } + } + + // at this point, we've as good as resumed the session, so we can + // clear the resume_session_once flag, if it's set + if ( + !lazy.RunState.isQuitting && + this._prefBranch.getBoolPref("sessionstore.resume_session_once") + ) { + this._prefBranch.setBoolPref("sessionstore.resume_session_once", false); + } + + TelemetryStopwatch.finish("FX_SESSION_RESTORE_STARTUP_INIT_SESSION_MS"); + return state; + }, + + /** + * When initializing session, if we are restoring the last session at startup, + * close open tabs or close windows marked _maybeDontRestoreTabs (if they were closed + * by closing remaining tabs). + * See bug 490136 + */ + _removeExplicitlyClosedTabs(state) { + // Don't restore tabs that has been explicitly closed + for (let i = 0; i < state.windows.length; ) { + const winData = state.windows[i]; + if (winData._maybeDontRestoreTabs) { + if (state.windows.length == 1) { + // it's the last window, we just want to close tabs + let j = 0; + // reset close group (we don't want to append tabs to existing group close). + winData._lastClosedTabGroupCount = -1; + while (winData.tabs.length) { + const tabState = winData.tabs.pop(); + + // Ensure the index is in bounds. + let activeIndex = (tabState.index || tabState.entries.length) - 1; + activeIndex = Math.min(activeIndex, tabState.entries.length - 1); + activeIndex = Math.max(activeIndex, 0); + + let title = ""; + if (activeIndex in tabState.entries) { + title = + tabState.entries[activeIndex].title || + tabState.entries[activeIndex].url; + } + + const tabData = { + state: tabState, + title, + image: tabState.image, + pos: j++, + closedAt: Date.now(), + closedInGroup: true, + }; + if (this._shouldSaveTabState(tabState)) { + this.saveClosedTabData(winData, winData._closedTabs, tabData); + } + } + } else { + // We can remove the window since it doesn't have any + // tabs that we should restore and it's not the only window + if (winData.tabs.some(this._shouldSaveTabState)) { + winData.closedAt = Date.now(); + state._closedWindows.unshift(winData); + } + state.windows.splice(i, 1); + continue; // we don't want to increment the index + } + } + i++; + } + }, + + _initPrefs() { + this._prefBranch = Services.prefs.getBranch("browser."); + + gDebuggingEnabled = this._prefBranch.getBoolPref("sessionstore.debug"); + + Services.prefs.addObserver("browser.sessionstore.debug", () => { + gDebuggingEnabled = this._prefBranch.getBoolPref("sessionstore.debug"); + }); + + this._log = console.createInstance({ + prefix: "SessionStore", + maxLogLevel: gDebuggingEnabled ? "Debug" : "Warn", + }); + + this._max_tabs_undo = this._prefBranch.getIntPref( + "sessionstore.max_tabs_undo" + ); + this._prefBranch.addObserver("sessionstore.max_tabs_undo", this, true); + + this._max_windows_undo = this._prefBranch.getIntPref( + "sessionstore.max_windows_undo" + ); + this._prefBranch.addObserver("sessionstore.max_windows_undo", this, true); + + this._restore_on_demand = this._prefBranch.getBoolPref( + "sessionstore.restore_on_demand" + ); + this._prefBranch.addObserver("sessionstore.restore_on_demand", this, true); + + gResistFingerprintingEnabled = Services.prefs.getBoolPref( + "privacy.resistFingerprinting" + ); + Services.prefs.addObserver("privacy.resistFingerprinting", this); + + this._shistoryInParent = Services.appinfo.sessionHistoryInParent; + }, + + /** + * Called on application shutdown, after notifications: + * quit-application-granted, quit-application + */ + _uninit: function ssi_uninit() { + if (!this._initialized) { + throw new Error("SessionStore is not initialized."); + } + + // Prepare to close the session file and write the last state. + lazy.RunState.setClosing(); + + // save all data for session resuming + if (this._sessionInitialized) { + lazy.SessionSaver.run(); + } + + // clear out priority queue in case it's still holding refs + TabRestoreQueue.reset(); + + // Make sure to cancel pending saves. + lazy.SessionSaver.cancel(); + }, + + /** + * Handle notifications + */ + observe: function ssi_observe(aSubject, aTopic, aData) { + switch (aTopic) { + case "browser-window-before-show": // catch new windows + this.onBeforeBrowserWindowShown(aSubject); + break; + case "domwindowclosed": // catch closed windows + this.onClose(aSubject).then(() => { + this._notifyOfClosedObjectsChange(); + }); + if (gDebuggingEnabled) { + Services.obs.notifyObservers(null, NOTIFY_DOMWINDOWCLOSED_HANDLED); + } + break; + case "quit-application-granted": + let syncShutdown = aData == "syncShutdown"; + this.onQuitApplicationGranted(syncShutdown); + break; + case "browser-lastwindow-close-granted": + this.onLastWindowCloseGranted(); + break; + case "quit-application": + this.onQuitApplication(aData); + break; + case "browser:purge-session-history": // catch sanitization + this.onPurgeSessionHistory(); + this._notifyOfClosedObjectsChange(); + break; + case "browser:purge-session-history-for-domain": + this.onPurgeDomainData(aData); + this._notifyOfClosedObjectsChange(); + break; + case "nsPref:changed": // catch pref changes + this.onPrefChange(aData); + this._notifyOfClosedObjectsChange(); + break; + case "idle-daily": + this.onIdleDaily(); + this._notifyOfClosedObjectsChange(); + break; + case "clear-origin-attributes-data": + let userContextId = 0; + try { + userContextId = JSON.parse(aData).userContextId; + } catch (e) {} + if (userContextId) { + this._forgetTabsWithUserContextId(userContextId); + } + break; + case "browsing-context-did-set-embedder": + if (Services.appinfo.sessionHistoryInParent) { + if ( + aSubject && + aSubject === aSubject.top && + aSubject.isContent && + aSubject.embedderElement && + aSubject.embedderElement.permanentKey + ) { + let permanentKey = aSubject.embedderElement.permanentKey; + this._browserSHistoryListener.get(permanentKey)?.unregister(); + this.getOrCreateSHistoryListener(permanentKey, aSubject, true); + } + } + break; + case "browsing-context-discarded": + if (Services.appinfo.sessionHistoryInParent) { + let permanentKey = aSubject?.embedderElement?.permanentKey; + if (permanentKey) { + this._browserSHistoryListener.get(permanentKey)?.unregister(); + } + } + break; + case "browser-shutdown-tabstate-updated": + if (Services.appinfo.sessionHistoryInParent) { + // Non-SHIP code calls this when the frame script is unloaded. + this.onFinalTabStateUpdateComplete(aSubject); + } + this._notifyOfClosedObjectsChange(); + break; + } + }, + + getOrCreateSHistoryListener( + permanentKey, + browsingContext, + collectImmediately = false + ) { + class SHistoryListener { + constructor() { + this.QueryInterface = ChromeUtils.generateQI([ + "nsISHistoryListener", + "nsISupportsWeakReference", + ]); + + this._browserId = browsingContext.browserId; + this._fromIndex = kNoIndex; + } + + unregister() { + let bc = BrowsingContext.getCurrentTopByBrowserId(this._browserId); + bc?.sessionHistory?.removeSHistoryListener(this); + SessionStoreInternal._browserSHistoryListener.delete(permanentKey); + } + + collect( + permanentKey, // eslint-disable-line no-shadow + browsingContext, // eslint-disable-line no-shadow + { collectFull = true, writeToCache = false } + ) { + // Don't bother doing anything if we haven't seen any navigations. + if (!collectFull && this._fromIndex === kNoIndex) { + return null; + } + + TelemetryStopwatch.start( + "FX_SESSION_RESTORE_COLLECT_SESSION_HISTORY_MS" + ); + + let fromIndex = collectFull ? -1 : this._fromIndex; + this._fromIndex = kNoIndex; + + let historychange = lazy.SessionHistory.collectFromParent( + browsingContext.currentURI?.spec, + true, // Bug 1704574 + browsingContext.sessionHistory, + fromIndex + ); + + if (writeToCache) { + let win = + browsingContext.embedderElement?.ownerGlobal || + browsingContext.currentWindowGlobal?.browsingContext?.window; + + SessionStoreInternal.onTabStateUpdate(permanentKey, win, { + data: { historychange }, + }); + } + + TelemetryStopwatch.finish( + "FX_SESSION_RESTORE_COLLECT_SESSION_HISTORY_MS" + ); + + return historychange; + } + + collectFrom(index) { + if (this._fromIndex <= index) { + // If we already know that we need to update history from index N we + // can ignore any changes that happened with an element with index + // larger than N. + // + // Note: initially we use kNoIndex which is MAX_SAFE_INTEGER which + // means we don't ignore anything here, and in case of navigation in + // the history back and forth cases we use kLastIndex which ignores + // only the subsequent navigations, but not any new elements added. + return; + } + + let bc = BrowsingContext.getCurrentTopByBrowserId(this._browserId); + if (bc?.embedderElement?.frameLoader) { + this._fromIndex = index; + + // Queue a tab state update on the |browser.sessionstore.interval| + // timer. We'll call this.collect() when we receive the update. + bc.embedderElement.frameLoader.requestSHistoryUpdate(); + } + } + + OnHistoryNewEntry(newURI, oldIndex) { + // We use oldIndex - 1 to collect the current entry as well. This makes + // sure to collect any changes that were made to the entry while the + // document was active. + this.collectFrom(oldIndex == -1 ? oldIndex : oldIndex - 1); + } + OnHistoryGotoIndex() { + this.collectFrom(kLastIndex); + } + OnHistoryPurge() { + this.collectFrom(-1); + } + OnHistoryReload() { + this.collectFrom(-1); + return true; + } + OnHistoryReplaceEntry() { + this.collectFrom(-1); + } + } + + if (!Services.appinfo.sessionHistoryInParent) { + throw new Error("This function should only be used with SHIP"); + } + + if (!permanentKey || browsingContext !== browsingContext.top) { + return null; + } + + let sessionHistory = browsingContext.sessionHistory; + if (!sessionHistory) { + return null; + } + + let listener = this._browserSHistoryListener.get(permanentKey); + if (listener) { + return listener; + } + + listener = new SHistoryListener(); + sessionHistory.addSHistoryListener(listener); + this._browserSHistoryListener.set(permanentKey, listener); + + let isAboutBlank = browsingContext.currentURI?.spec === "about:blank"; + + if (collectImmediately && (!isAboutBlank || sessionHistory.count !== 0)) { + listener.collect(permanentKey, browsingContext, { writeToCache: true }); + } + + return listener; + }, + + onTabStateUpdate(permanentKey, win, update) { + // Ignore messages from <browser> elements that have crashed + // and not yet been revived. + if (this._crashedBrowsers.has(permanentKey)) { + return; + } + + lazy.TabState.update(permanentKey, update); + this.saveStateDelayed(win); + + // Handle any updates sent by the child after the tab was closed. This + // might be the final update as sent by the "unload" handler but also + // any async update message that was sent before the child unloaded. + let closedTab = this._closedTabs.get(permanentKey); + if (closedTab) { + // Update the closed tab's state. This will be reflected in its + // window's list of closed tabs as that refers to the same object. + lazy.TabState.copyFromCache(permanentKey, closedTab.tabData.state); + } + }, + + onFinalTabStateUpdateComplete(browser) { + let permanentKey = browser.permanentKey; + if ( + this._closedTabs.has(permanentKey) && + !this._crashedBrowsers.has(permanentKey) + ) { + let { winData, closedTabs, tabData } = this._closedTabs.get(permanentKey); + + // We expect no further updates. + this._closedTabs.delete(permanentKey); + + // The tab state no longer needs this reference. + delete tabData.permanentKey; + + // Determine whether the tab state is worth saving. + let shouldSave = this._shouldSaveTabState(tabData.state); + let index = closedTabs.indexOf(tabData); + + if (shouldSave && index == -1) { + // If the tab state is worth saving and we didn't push it onto + // the list of closed tabs when it was closed (because we deemed + // the state not worth saving) then add it to the window's list + // of closed tabs now. + this.saveClosedTabData(winData, closedTabs, tabData); + } else if (!shouldSave && index > -1) { + // Remove from the list of closed tabs. The update messages sent + // after the tab was closed changed enough state so that we no + // longer consider its data interesting enough to keep around. + this.removeClosedTabData(winData, closedTabs, index); + } + } + + // If this the final message we need to resolve all pending flush + // requests for the given browser as they might have been sent too + // late and will never respond. If they have been sent shortly after + // switching a browser's remoteness there isn't too much data to skip. + lazy.TabStateFlusher.resolveAll(browser); + + this._browserSHistoryListener.get(permanentKey)?.unregister(); + this._restoreListeners.get(permanentKey)?.unregister(); + + Services.obs.notifyObservers(browser, NOTIFY_BROWSER_SHUTDOWN_FLUSH); + }, + + updateSessionStoreFromTablistener( + browser, + browsingContext, + permanentKey, + update + ) { + permanentKey = browser?.permanentKey ?? permanentKey; + if (!permanentKey) { + return; + } + + // Ignore sessionStore update from previous epochs + if (!this.isCurrentEpoch(permanentKey, update.epoch)) { + return; + } + + if (browsingContext.isReplaced) { + return; + } + + if (Services.appinfo.sessionHistoryInParent) { + let listener = this.getOrCreateSHistoryListener( + permanentKey, + browsingContext + ); + + if (listener) { + let historychange = listener.collect(permanentKey, browsingContext, { + collectFull: !!update.sHistoryNeeded, + writeToCache: false, + }); + + if (historychange) { + update.data.historychange = historychange; + } + } + } + + let win = + browser?.ownerGlobal ?? + browsingContext.currentWindowGlobal?.browsingContext?.window; + + this.onTabStateUpdate(permanentKey, win, update); + }, + + /** + * This method handles incoming messages sent by the session store content + * script via the Frame Message Manager or Parent Process Message Manager, + * and thus enables communication with OOP tabs. + */ + receiveMessage(aMessage) { + // If we got here, that means we're dealing with a frame message + // manager message, so the target will be a <xul:browser>. + var browser = aMessage.target; + let win = browser.ownerGlobal; + let tab = win ? win.gBrowser.getTabForBrowser(browser) : null; + + // Ensure we receive only specific messages from <xul:browser>s that + // have no tab or window assigned, e.g. the ones that preload + // about:newtab pages, or windows that have closed. + if (!tab && !NOTAB_MESSAGES.has(aMessage.name)) { + throw new Error( + `received unexpected message '${aMessage.name}' ` + + `from a browser that has no tab or window` + ); + } + + let data = aMessage.data || {}; + let hasEpoch = data.hasOwnProperty("epoch"); + + // Most messages sent by frame scripts require to pass an epoch. + if (!hasEpoch && !NOEPOCH_MESSAGES.has(aMessage.name)) { + throw new Error(`received message '${aMessage.name}' without an epoch`); + } + + // Ignore messages from previous epochs. + if (hasEpoch && !this.isCurrentEpoch(browser.permanentKey, data.epoch)) { + return; + } + + switch (aMessage.name) { + case "SessionStore:update": + // |browser.frameLoader| might be empty if the browser was already + // destroyed and its tab removed. In that case we still have the last + // frameLoader we know about to compare. + let frameLoader = + browser.frameLoader || + this._lastKnownFrameLoader.get(browser.permanentKey); + + // If the message isn't targeting the latest frameLoader discard it. + if (frameLoader != aMessage.targetFrameLoader) { + return; + } + + this.onTabStateUpdate(browser.permanentKey, browser.ownerGlobal, data); + + // SHIP code will call this when it receives "browser-shutdown-tabstate-updated" + if (data.isFinal) { + if (!Services.appinfo.sessionHistoryInParent) { + this.onFinalTabStateUpdateComplete(browser); + } + } else if (data.flushID) { + // This is an update kicked off by an async flush request. Notify the + // TabStateFlusher so that it can finish the request and notify its + // consumer that's waiting for the flush to be done. + lazy.TabStateFlusher.resolve(browser, data.flushID); + } + + break; + case "SessionStore:restoreHistoryComplete": + this._restoreHistoryComplete(browser, data); + break; + case "SessionStore:restoreTabContentStarted": + this._restoreTabContentStarted(browser, data); + break; + case "SessionStore:restoreTabContentComplete": + this._restoreTabContentComplete(browser, data); + break; + case "SessionStore:error": + lazy.TabStateFlusher.resolveAll( + browser, + false, + "Received error from the content process" + ); + break; + default: + throw new Error(`received unknown message '${aMessage.name}'`); + } + }, + + /* ........ Window Event Handlers .............. */ + + /** + * Implement EventListener for handling various window and tab events + */ + handleEvent: function ssi_handleEvent(aEvent) { + let win = aEvent.currentTarget.ownerGlobal; + let target = aEvent.originalTarget; + switch (aEvent.type) { + case "TabOpen": + this.onTabAdd(win); + break; + case "TabBrowserInserted": + this.onTabBrowserInserted(win, target); + break; + case "TabClose": + // `adoptedBy` will be set if the tab was closed because it is being + // moved to a new window. + if (aEvent.detail.adoptedBy) { + this.onMoveToNewWindow( + target.linkedBrowser, + aEvent.detail.adoptedBy.linkedBrowser + ); + } else { + this.onTabClose(win, target); + } + this.onTabRemove(win, target); + this._notifyOfClosedObjectsChange(); + break; + case "TabSelect": + this.onTabSelect(win); + break; + case "TabShow": + this.onTabShow(win, target); + break; + case "TabHide": + this.onTabHide(win, target); + break; + case "TabPinned": + case "TabUnpinned": + case "SwapDocShells": + this.saveStateDelayed(win); + break; + case "oop-browser-crashed": + case "oop-browser-buildid-mismatch": + if (aEvent.isTopFrame) { + this.onBrowserCrashed(target); + } + break; + case "XULFrameLoaderCreated": + if ( + target.namespaceURI == XUL_NS && + target.localName == "browser" && + target.frameLoader && + target.permanentKey + ) { + this._lastKnownFrameLoader.set( + target.permanentKey, + target.frameLoader + ); + this.resetEpoch(target.permanentKey, target.frameLoader); + } + break; + default: + throw new Error(`unhandled event ${aEvent.type}?`); + } + this._clearRestoringWindows(); + }, + + /** + * Generate a unique window identifier + * @return string + * A unique string to identify a window + */ + _generateWindowID: function ssi_generateWindowID() { + return "window" + this._nextWindowID++; + }, + + /** + * Registers and tracks a given window. + * + * @param aWindow + * Window reference + */ + onLoad(aWindow) { + // return if window has already been initialized + if (aWindow && aWindow.__SSi && this._windows[aWindow.__SSi]) { + return; + } + + // ignore windows opened while shutting down + if (lazy.RunState.isQuitting) { + return; + } + + // Assign the window a unique identifier we can use to reference + // internal data about the window. + aWindow.__SSi = this._generateWindowID(); + + let mm = aWindow.getGroupMessageManager("browsers"); + MESSAGES.forEach(msg => { + let listenWhenClosed = CLOSED_MESSAGES.has(msg); + mm.addMessageListener(msg, this, listenWhenClosed); + }); + + // Load the frame script after registering listeners. + if (!Services.appinfo.sessionHistoryInParent) { + mm.loadFrameScript( + "chrome://browser/content/content-sessionStore.js", + true, + true + ); + } + + // and create its data object + this._windows[aWindow.__SSi] = { + tabs: [], + selected: 0, + _closedTabs: [], + _lastClosedTabGroupCount: -1, + busy: false, + chromeFlags: aWindow.docShell.treeOwner + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIAppWindow).chromeFlags, + }; + + if (PrivateBrowsingUtils.isWindowPrivate(aWindow)) { + this._windows[aWindow.__SSi].isPrivate = true; + } + if (!this._isWindowLoaded(aWindow)) { + this._windows[aWindow.__SSi]._restoring = true; + } + if (!aWindow.toolbar.visible) { + this._windows[aWindow.__SSi].isPopup = true; + } + + let tabbrowser = aWindow.gBrowser; + + // add tab change listeners to all already existing tabs + for (let i = 0; i < tabbrowser.tabs.length; i++) { + this.onTabBrowserInserted(aWindow, tabbrowser.tabs[i]); + } + // notification of tab add/remove/selection/show/hide + TAB_EVENTS.forEach(function(aEvent) { + tabbrowser.tabContainer.addEventListener(aEvent, this, true); + }, this); + + // Keep track of a browser's latest frameLoader. + aWindow.gBrowser.addEventListener("XULFrameLoaderCreated", this); + }, + + /** + * Initializes a given window. + * + * Windows are registered as soon as they are created but we need to wait for + * the session file to load, and the initial window's delayed startup to + * finish before initializing a window, i.e. restoring data into it. + * + * @param aWindow + * Window reference + * @param aInitialState + * The initial state to be loaded after startup (optional) + */ + initializeWindow(aWindow, aInitialState = null) { + let isPrivateWindow = PrivateBrowsingUtils.isWindowPrivate(aWindow); + + // perform additional initialization when the first window is loading + if (lazy.RunState.isStopped) { + lazy.RunState.setRunning(); + + // restore a crashed session resp. resume the last session if requested + if (aInitialState) { + // Don't write to disk right after startup. Set the last time we wrote + // to disk to NOW() to enforce a full interval before the next write. + lazy.SessionSaver.updateLastSaveTime(); + + if (isPrivateWindow) { + // We're starting with a single private window. Save the state we + // actually wanted to restore so that we can do it later in case + // the user opens another, non-private window. + this._deferredInitialState = lazy.SessionStartup.state; + + // Nothing to restore now, notify observers things are complete. + Services.obs.notifyObservers(null, NOTIFY_WINDOWS_RESTORED); + Services.obs.notifyObservers( + null, + "sessionstore-one-or-no-tab-restored" + ); + this._deferredAllWindowsRestored.resolve(); + } else { + TelemetryTimestamps.add("sessionRestoreRestoring"); + this._restoreCount = aInitialState.windows + ? aInitialState.windows.length + : 0; + + // global data must be restored before restoreWindow is called so that + // it happens before observers are notified + this._globalState.setFromState(aInitialState); + + // Restore session cookies before loading any tabs. + lazy.SessionCookies.restore(aInitialState.cookies || []); + + let overwrite = this._isCmdLineEmpty(aWindow, aInitialState); + let options = { firstWindow: true, overwriteTabs: overwrite }; + this.restoreWindows(aWindow, aInitialState, options); + } + } else { + // Nothing to restore, notify observers things are complete. + Services.obs.notifyObservers(null, NOTIFY_WINDOWS_RESTORED); + Services.obs.notifyObservers( + null, + "sessionstore-one-or-no-tab-restored" + ); + this._deferredAllWindowsRestored.resolve(); + } + // this window was opened by _openWindowWithState + } else if (!this._isWindowLoaded(aWindow)) { + // We want to restore windows after all windows have opened (since bug + // 1034036), so bail out here. + return; + // The user opened another, non-private window after starting up with + // a single private one. Let's restore the session we actually wanted to + // restore at startup. + } else if ( + this._deferredInitialState && + !isPrivateWindow && + aWindow.toolbar.visible + ) { + // global data must be restored before restoreWindow is called so that + // it happens before observers are notified + this._globalState.setFromState(this._deferredInitialState); + + this._restoreCount = this._deferredInitialState.windows + ? this._deferredInitialState.windows.length + : 0; + this.restoreWindows(aWindow, this._deferredInitialState, { + firstWindow: true, + }); + this._deferredInitialState = null; + } else if ( + this._restoreLastWindow && + aWindow.toolbar.visible && + this._closedWindows.length && + !isPrivateWindow + ) { + // default to the most-recently closed window + // don't use popup windows + let closedWindowState = null; + let closedWindowIndex; + for (let i = 0; i < this._closedWindows.length; i++) { + // Take the first non-popup, point our object at it, and break out. + if (!this._closedWindows[i].isPopup) { + closedWindowState = this._closedWindows[i]; + closedWindowIndex = i; + break; + } + } + + if (closedWindowState) { + let newWindowState; + if ( + AppConstants.platform == "macosx" || + !lazy.SessionStartup.willRestore() + ) { + // We want to split the window up into pinned tabs and unpinned tabs. + // Pinned tabs should be restored. If there are any remaining tabs, + // they should be added back to _closedWindows. + // We'll cheat a little bit and reuse _prepDataForDeferredRestore + // even though it wasn't built exactly for this. + let [ + appTabsState, + normalTabsState, + ] = this._prepDataForDeferredRestore({ + windows: [closedWindowState], + }); + + // These are our pinned tabs, which we should restore + if (appTabsState.windows.length) { + newWindowState = appTabsState.windows[0]; + delete newWindowState.__lastSessionWindowID; + } + + // In case there were no unpinned tabs, remove the window from _closedWindows + if (!normalTabsState.windows.length) { + this._removeClosedWindow(closedWindowIndex); + // Or update _closedWindows with the modified state + } else { + delete normalTabsState.windows[0].__lastSessionWindowID; + this._closedWindows[closedWindowIndex] = normalTabsState.windows[0]; + } + } else { + // If we're just restoring the window, make sure it gets removed from + // _closedWindows. + this._removeClosedWindow(closedWindowIndex); + newWindowState = closedWindowState; + delete newWindowState.hidden; + } + + if (newWindowState) { + // Ensure that the window state isn't hidden + this._restoreCount = 1; + let state = { windows: [newWindowState] }; + let options = { overwriteTabs: this._isCmdLineEmpty(aWindow, state) }; + this.restoreWindow(aWindow, newWindowState, options); + } + } + // we actually restored the session just now. + this._prefBranch.setBoolPref("sessionstore.resume_session_once", false); + } + if (this._restoreLastWindow && aWindow.toolbar.visible) { + // always reset (if not a popup window) + // we don't want to restore a window directly after, for example, + // undoCloseWindow was executed. + this._restoreLastWindow = false; + } + }, + + /** + * Called right before a new browser window is shown. + * @param aWindow + * Window reference + */ + onBeforeBrowserWindowShown(aWindow) { + // Register the window. + this.onLoad(aWindow); + + // Some are waiting for this window to be shown, which is now, so let's resolve + // the deferred operation. + let deferred = WINDOW_SHOWING_PROMISES.get(aWindow); + if (deferred) { + deferred.resolve(aWindow); + WINDOW_SHOWING_PROMISES.delete(aWindow); + } + + // Just call initializeWindow() directly if we're initialized already. + if (this._sessionInitialized) { + this.initializeWindow(aWindow); + return; + } + + // The very first window that is opened creates a promise that is then + // re-used by all subsequent windows. The promise will be used to tell + // when we're ready for initialization. + if (!this._promiseReadyForInitialization) { + // Wait for the given window's delayed startup to be finished. + let promise = new Promise(resolve => { + Services.obs.addObserver(function obs(subject, topic) { + if (aWindow == subject) { + Services.obs.removeObserver(obs, topic); + resolve(); + } + }, "browser-delayed-startup-finished"); + }); + + // We are ready for initialization as soon as the session file has been + // read from disk and the initial window's delayed startup has finished. + this._promiseReadyForInitialization = Promise.all([ + promise, + lazy.SessionStartup.onceInitialized, + ]); + } + + // We can't call this.onLoad since initialization + // hasn't completed, so we'll wait until it is done. + // Even if additional windows are opened and wait + // for initialization as well, the first opened + // window should execute first, and this.onLoad + // will be called with the initialState. + this._promiseReadyForInitialization + .then(() => { + if (aWindow.closed) { + return; + } + + if (this._sessionInitialized) { + this.initializeWindow(aWindow); + } else { + let initialState = this.initSession(); + this._sessionInitialized = true; + + if (initialState) { + Services.obs.notifyObservers(null, NOTIFY_RESTORING_ON_STARTUP); + } + TelemetryStopwatch.start( + "FX_SESSION_RESTORE_STARTUP_ONLOAD_INITIAL_WINDOW_MS" + ); + this.initializeWindow(aWindow, initialState); + TelemetryStopwatch.finish( + "FX_SESSION_RESTORE_STARTUP_ONLOAD_INITIAL_WINDOW_MS" + ); + + // Let everyone know we're done. + this._deferredInitialized.resolve(); + } + }) + .catch(console.error); + }, + + /** + * On window close... + * - remove event listeners from tabs + * - save all window data + * @param aWindow + * Window reference + * + * @returns a Promise + */ + onClose: function ssi_onClose(aWindow) { + let completionPromise = Promise.resolve(); + // this window was about to be restored - conserve its original data, if any + let isFullyLoaded = this._isWindowLoaded(aWindow); + if (!isFullyLoaded) { + if (!aWindow.__SSi) { + aWindow.__SSi = this._generateWindowID(); + } + + let restoreID = WINDOW_RESTORE_IDS.get(aWindow); + this._windows[aWindow.__SSi] = this._statesToRestore[ + restoreID + ].windows[0]; + delete this._statesToRestore[restoreID]; + WINDOW_RESTORE_IDS.delete(aWindow); + } + + // ignore windows not tracked by SessionStore + if (!aWindow.__SSi || !this._windows[aWindow.__SSi]) { + return completionPromise; + } + + // notify that the session store will stop tracking this window so that + // extensions can store any data about this window in session store before + // that's not possible anymore + let event = aWindow.document.createEvent("Events"); + event.initEvent("SSWindowClosing", true, false); + aWindow.dispatchEvent(event); + + if (this.windowToFocus && this.windowToFocus == aWindow) { + delete this.windowToFocus; + } + + var tabbrowser = aWindow.gBrowser; + + let browsers = Array.from(tabbrowser.browsers); + + TAB_EVENTS.forEach(function(aEvent) { + tabbrowser.tabContainer.removeEventListener(aEvent, this, true); + }, this); + + aWindow.gBrowser.removeEventListener("XULFrameLoaderCreated", this); + + let winData = this._windows[aWindow.__SSi]; + + // Collect window data only when *not* closed during shutdown. + if (lazy.RunState.isRunning) { + // Grab the most recent window data. The tab data will be updated + // once we finish flushing all of the messages from the tabs. + let tabMap = this._collectWindowData(aWindow); + + for (let [tab, tabData] of tabMap) { + let permanentKey = tab.linkedBrowser.permanentKey; + this._closedWindowTabs.set(permanentKey, tabData); + } + + if (isFullyLoaded && !winData.title) { + winData.title = + tabbrowser.selectedBrowser.contentTitle || + tabbrowser.selectedTab.label; + } + + if (AppConstants.platform != "macosx") { + // Until we decide otherwise elsewhere, this window is part of a series + // of closing windows to quit. + winData._shouldRestore = true; + } + + // Store the window's close date to figure out when each individual tab + // was closed. This timestamp should allow re-arranging data based on how + // recently something was closed. + winData.closedAt = Date.now(); + + // we don't want to save the busy state + delete winData.busy; + + // When closing windows one after the other until Firefox quits, we + // will move those closed in series back to the "open windows" bucket + // before writing to disk. If however there is only a single window + // with tabs we deem not worth saving then we might end up with a + // random closed or even a pop-up window re-opened. To prevent that + // we explicitly allow saving an "empty" window state. + let isLastWindow = this.isLastRestorableWindow(); + + // clear this window from the list, since it has definitely been closed. + delete this._windows[aWindow.__SSi]; + + // This window has the potential to be saved in the _closedWindows + // array (maybeSaveClosedWindows gets the final call on that). + this._saveableClosedWindowData.add(winData); + + // Now we have to figure out if this window is worth saving in the _closedWindows + // Object. + // + // We're about to flush the tabs from this window, but it's possible that we + // might never hear back from the content process(es) in time before the user + // chooses to restore the closed window. So we do the following: + // + // 1) Use the tab state cache to determine synchronously if the window is + // worth stashing in _closedWindows. + // 2) Flush the window. + // 3) When the flush is complete, revisit our decision to store the window + // in _closedWindows, and add/remove as necessary. + if (!winData.isPrivate) { + // Remove any open private tabs the window may contain. + lazy.PrivacyFilter.filterPrivateTabs(winData); + this.maybeSaveClosedWindow(winData, isLastWindow); + } + + completionPromise = lazy.TabStateFlusher.flushWindow(aWindow).then(() => { + // At this point, aWindow is closed! You should probably not try to + // access any DOM elements from aWindow within this callback unless + // you're holding on to them in the closure. + + WINDOW_FLUSHING_PROMISES.delete(aWindow); + + for (let browser of browsers) { + if (this._closedWindowTabs.has(browser.permanentKey)) { + let tabData = this._closedWindowTabs.get(browser.permanentKey); + lazy.TabState.copyFromCache(browser.permanentKey, tabData); + this._closedWindowTabs.delete(browser.permanentKey); + } + } + + // Save non-private windows if they have at + // least one saveable tab or are the last window. + if (!winData.isPrivate) { + // It's possible that a tab switched its privacy state at some point + // before our flush, so we need to filter again. + lazy.PrivacyFilter.filterPrivateTabs(winData); + this.maybeSaveClosedWindow(winData, isLastWindow); + } + + // Update the tabs data now that we've got the most + // recent information. + this.cleanUpWindow(aWindow, winData, browsers); + + // save the state without this window to disk + this.saveStateDelayed(); + }); + + // Here we might override a flush already in flight, but that's fine + // because `completionPromise` will always resolve after the old flush + // resolves. + WINDOW_FLUSHING_PROMISES.set(aWindow, completionPromise); + } else { + this.cleanUpWindow(aWindow, winData, browsers); + } + + for (let i = 0; i < tabbrowser.tabs.length; i++) { + this.onTabRemove(aWindow, tabbrowser.tabs[i], true); + } + + return completionPromise; + }, + + /** + * Clean up the message listeners on a window that has finally + * gone away. Call this once you're sure you don't want to hear + * from any of this windows tabs from here forward. + * + * @param aWindow + * The browser window we're cleaning up. + * @param winData + * The data for the window that we should hold in the + * DyingWindowCache in case anybody is still holding a + * reference to it. + */ + cleanUpWindow(aWindow, winData, browsers) { + // Any leftover TabStateFlusher Promises need to be resolved now, + // since we're about to remove the message listeners. + for (let browser of browsers) { + lazy.TabStateFlusher.resolveAll(browser); + } + + // Cache the window state until it is completely gone. + DyingWindowCache.set(aWindow, winData); + + let mm = aWindow.getGroupMessageManager("browsers"); + MESSAGES.forEach(msg => mm.removeMessageListener(msg, this)); + + this._saveableClosedWindowData.delete(winData); + delete aWindow.__SSi; + }, + + /** + * Decides whether or not a closed window should be put into the + * _closedWindows Object. This might be called multiple times per + * window, and will do the right thing of moving the window data + * in or out of _closedWindows if the winData indicates that our + * need for saving it has changed. + * + * @param winData + * The data for the closed window that we might save. + * @param isLastWindow + * Whether or not the window being closed is the last + * browser window. Callers of this function should pass + * in the value of SessionStoreInternal.atLastWindow for + * this argument, and pass in the same value if they happen + * to call this method again asynchronously (for example, after + * a window flush). + */ + maybeSaveClosedWindow(winData, isLastWindow) { + // Make sure SessionStore is still running, and make sure that we + // haven't chosen to forget this window. + if ( + lazy.RunState.isRunning && + this._saveableClosedWindowData.has(winData) + ) { + // Determine whether the window has any tabs worth saving. + let hasSaveableTabs = winData.tabs.some(this._shouldSaveTabState); + + // Note that we might already have this window stored in + // _closedWindows from a previous call to this function. + let winIndex = this._closedWindows.indexOf(winData); + let alreadyStored = winIndex != -1; + let shouldStore = hasSaveableTabs || isLastWindow; + + if (shouldStore && !alreadyStored) { + let index = this._closedWindows.findIndex(win => { + return win.closedAt < winData.closedAt; + }); + + // If we found no tab closed before our + // tab then just append it to the list. + if (index == -1) { + index = this._closedWindows.length; + } + + // About to save the closed window, add a unique ID. + winData.closedId = this._nextClosedId++; + + // Insert tabData at the right position. + this._closedWindows.splice(index, 0, winData); + this._capClosedWindows(); + this._closedObjectsChanged = true; + // The first time we close a window, ensure it can be restored from the + // hidden window. + if ( + AppConstants.platform == "macosx" && + this._closedWindows.length == 1 + ) { + // Fake a popupshowing event so shortcuts work: + let window = Services.appShell.hiddenDOMWindow; + let historyMenu = window.document.getElementById("history-menu"); + let evt = new window.CustomEvent("popupshowing", { bubbles: true }); + historyMenu.menupopup.dispatchEvent(evt); + } + } else if (!shouldStore && alreadyStored) { + this._removeClosedWindow(winIndex); + } + } + }, + + /** + * On quit application granted + */ + onQuitApplicationGranted: function ssi_onQuitApplicationGranted( + syncShutdown = false + ) { + // Collect an initial snapshot of window data before we do the flush. + let index = 0; + for (let window of this._orderedBrowserWindows) { + this._collectWindowData(window); + this._windows[window.__SSi].zIndex = ++index; + } + + // Now add an AsyncShutdown blocker that'll spin the event loop + // until the windows have all been flushed. + + // This progress object will track the state of async window flushing + // and will help us debug things that go wrong with our AsyncShutdown + // blocker. + let progress = { total: -1, current: -1 }; + + // We're going down! Switch state so that we treat closing windows and + // tabs correctly. + lazy.RunState.setQuitting(); + + if (!syncShutdown) { + // We've got some time to shut down, so let's do this properly that there + // will be a complete session available upon next startup. + // To prevent a blocker from taking longer than the DELAY_CRASH_MS limit + // (which will cause a crash) of AsyncShutdown whilst flushing all windows, + // we resolve the Promise blocker once: + // 1. the flush duration exceeds 10 seconds before DELAY_CRASH_MS, or + // 2. 'oop-frameloader-crashed', or + // 3. 'ipc:content-shutdown' is observed. + lazy.AsyncShutdown.quitApplicationGranted.addBlocker( + "SessionStore: flushing all windows", + () => { + // Set up the list of promises that will signal a complete sessionstore + // shutdown: either all data is saved, or we crashed or the message IPC + // channel went away in the meantime. + let promises = [this.flushAllWindowsAsync(progress)]; + + const observeTopic = topic => { + let deferred = lazy.PromiseUtils.defer(); + const observer = subject => { + // Skip abort on ipc:content-shutdown if not abnormal/crashed + subject.QueryInterface(Ci.nsIPropertyBag2); + if ( + !(topic == "ipc:content-shutdown" && !subject.get("abnormal")) + ) { + deferred.resolve(); + } + }; + const cleanup = () => { + try { + Services.obs.removeObserver(observer, topic); + } catch (ex) { + Cu.reportError( + "SessionStore: exception whilst flushing all windows: " + ex + ); + } + }; + Services.obs.addObserver(observer, topic); + deferred.promise.then(cleanup, cleanup); + return deferred; + }; + + // Build a list of deferred executions that require cleanup once the + // Promise race is won. + // Ensure that the timer fires earlier than the AsyncShutdown crash timer. + let waitTimeMaxMs = Math.max( + 0, + lazy.AsyncShutdown.DELAY_CRASH_MS - 10000 + ); + let defers = [ + this.looseTimer(waitTimeMaxMs), + + // FIXME: We should not be aborting *all* flushes when a single + // content process crashes here. + observeTopic("oop-frameloader-crashed"), + observeTopic("ipc:content-shutdown"), + ]; + // Add these monitors to the list of Promises to start the race. + promises.push(...defers.map(deferred => deferred.promise)); + + return Promise.race(promises).then(() => { + // When a Promise won the race, make sure we clean up the running + // monitors. + defers.forEach(deferred => deferred.reject()); + }); + }, + () => progress + ); + } else { + // We have to shut down NOW, which means we only get to save whatever + // we already had cached. + } + }, + + /** + * An async Task that iterates all open browser windows and flushes + * any outstanding messages from their tabs. This will also close + * all of the currently open windows while we wait for the flushes + * to complete. + * + * @param progress (Object) + * Optional progress object that will be updated as async + * window flushing progresses. flushAllWindowsSync will + * write to the following properties: + * + * total (int): + * The total number of windows to be flushed. + * current (int): + * The current window that we're waiting for a flush on. + * + * @return Promise + */ + async flushAllWindowsAsync(progress = {}) { + let windowPromises = new Map(WINDOW_FLUSHING_PROMISES); + WINDOW_FLUSHING_PROMISES.clear(); + + // We collect flush promises and close each window immediately so that + // the user can't start changing any window state while we're waiting + // for the flushes to finish. + for (let window of this._browserWindows) { + windowPromises.set(window, lazy.TabStateFlusher.flushWindow(window)); + + // We have to wait for these messages to come up from + // each window and each browser. In the meantime, hide + // the windows to improve perceived shutdown speed. + let baseWin = window.docShell.treeOwner.QueryInterface(Ci.nsIBaseWindow); + baseWin.visibility = false; + } + + progress.total = windowPromises.size; + progress.current = 0; + + // We'll iterate through the Promise array, yielding each one, so as to + // provide useful progress information to AsyncShutdown. + for (let [win, promise] of windowPromises) { + await promise; + + // We may have already stopped tracking this window in onClose, which is + // fine as we would've collected window data there as well. + if (win.__SSi && this._windows[win.__SSi]) { + this._collectWindowData(win); + } + + progress.current++; + } + + // We must cache this because _getTopWindow will always + // return null by the time quit-application occurs. + var activeWindow = this._getTopWindow(); + if (activeWindow) { + this.activeWindowSSiCache = activeWindow.__SSi || ""; + } + DirtyWindows.clear(); + }, + + /** + * On last browser window close + */ + onLastWindowCloseGranted: function ssi_onLastWindowCloseGranted() { + // last browser window is quitting. + // remember to restore the last window when another browser window is opened + // do not account for pref(resume_session_once) at this point, as it might be + // set by another observer getting this notice after us + this._restoreLastWindow = true; + }, + + /** + * On quitting application + * @param aData + * String type of quitting + */ + onQuitApplication: function ssi_onQuitApplication(aData) { + if (aData == "restart" || aData == "os-restart") { + if (!PrivateBrowsingUtils.permanentPrivateBrowsing) { + if ( + aData == "os-restart" && + !this._prefBranch.getBoolPref("sessionstore.resume_session_once") + ) { + this._prefBranch.setBoolPref( + "sessionstore.resuming_after_os_restart", + true + ); + } + this._prefBranch.setBoolPref("sessionstore.resume_session_once", true); + } + + // The browser:purge-session-history notification fires after the + // quit-application notification so unregister the + // browser:purge-session-history notification to prevent clearing + // session data on disk on a restart. It is also unnecessary to + // perform any other sanitization processing on a restart as the + // browser is about to exit anyway. + Services.obs.removeObserver(this, "browser:purge-session-history"); + } + + if (aData != "restart") { + // Throw away the previous session on shutdown without notification + LastSession.clear(true); + } + + this._uninit(); + }, + + /** + * On purge of session history + */ + onPurgeSessionHistory: function ssi_onPurgeSessionHistory() { + lazy.SessionFile.wipe(); + // If the browser is shutting down, simply return after clearing the + // session data on disk as this notification fires after the + // quit-application notification so the browser is about to exit. + if (lazy.RunState.isQuitting) { + return; + } + LastSession.clear(); + + let openWindows = {}; + // Collect open windows. + for (let window of this._browserWindows) { + openWindows[window.__SSi] = true; + } + + // also clear all data about closed tabs and windows + for (let ix in this._windows) { + if (ix in openWindows) { + if (this._windows[ix]._closedTabs.length) { + this._windows[ix]._closedTabs = []; + this._closedObjectsChanged = true; + } + } else { + delete this._windows[ix]; + } + } + // also clear all data about closed windows + if (this._closedWindows.length) { + this._closedWindows = []; + this._closedObjectsChanged = true; + } + // give the tabbrowsers a chance to clear their histories first + var win = this._getTopWindow(); + if (win) { + win.setTimeout(() => lazy.SessionSaver.run(), 0); + } else if (lazy.RunState.isRunning) { + lazy.SessionSaver.run(); + } + + this._clearRestoringWindows(); + this._saveableClosedWindowData = new WeakSet(); + }, + + /** + * On purge of domain data + * @param {string} aDomain + * The domain we want to purge data for + */ + onPurgeDomainData: function ssi_onPurgeDomainData(aDomain) { + // does a session history entry contain a url for the given domain? + function containsDomain(aEntry) { + let host; + try { + host = Services.io.newURI(aEntry.url).host; + } catch (e) { + // The given URL probably doesn't have a host. + } + if (host && Services.eTLD.hasRootDomain(host, aDomain)) { + return true; + } + return aEntry.children && aEntry.children.some(containsDomain, this); + } + // remove all closed tabs containing a reference to the given domain + for (let ix in this._windows) { + let closedTabs = this._windows[ix]._closedTabs; + for (let i = closedTabs.length - 1; i >= 0; i--) { + if (closedTabs[i].state.entries.some(containsDomain, this)) { + closedTabs.splice(i, 1); + this._closedObjectsChanged = true; + } + } + } + // remove all open & closed tabs containing a reference to the given + // domain in closed windows + for (let ix = this._closedWindows.length - 1; ix >= 0; ix--) { + let closedTabs = this._closedWindows[ix]._closedTabs; + let openTabs = this._closedWindows[ix].tabs; + let openTabCount = openTabs.length; + for (let i = closedTabs.length - 1; i >= 0; i--) { + if (closedTabs[i].state.entries.some(containsDomain, this)) { + closedTabs.splice(i, 1); + } + } + for (let j = openTabs.length - 1; j >= 0; j--) { + if (openTabs[j].entries.some(containsDomain, this)) { + openTabs.splice(j, 1); + if (this._closedWindows[ix].selected > j) { + this._closedWindows[ix].selected--; + } + } + } + if (!openTabs.length) { + this._closedWindows.splice(ix, 1); + } else if (openTabs.length != openTabCount) { + // Adjust the window's title if we removed an open tab + let selectedTab = openTabs[this._closedWindows[ix].selected - 1]; + // some duplication from restoreHistory - make sure we get the correct title + let activeIndex = (selectedTab.index || selectedTab.entries.length) - 1; + if (activeIndex >= selectedTab.entries.length) { + activeIndex = selectedTab.entries.length - 1; + } + this._closedWindows[ix].title = selectedTab.entries[activeIndex].title; + } + } + + if (lazy.RunState.isRunning) { + lazy.SessionSaver.run(); + } + + this._clearRestoringWindows(); + }, + + /** + * On preference change + * @param aData + * String preference changed + */ + onPrefChange: function ssi_onPrefChange(aData) { + switch (aData) { + // if the user decreases the max number of closed tabs they want + // preserved update our internal states to match that max + case "sessionstore.max_tabs_undo": + this._max_tabs_undo = this._prefBranch.getIntPref( + "sessionstore.max_tabs_undo" + ); + for (let ix in this._windows) { + if (this._windows[ix]._closedTabs.length > this._max_tabs_undo) { + this._windows[ix]._closedTabs.splice( + this._max_tabs_undo, + this._windows[ix]._closedTabs.length + ); + this._closedObjectsChanged = true; + } + } + break; + case "sessionstore.max_windows_undo": + this._max_windows_undo = this._prefBranch.getIntPref( + "sessionstore.max_windows_undo" + ); + this._capClosedWindows(); + break; + case "privacy.resistFingerprinting": + gResistFingerprintingEnabled = Services.prefs.getBoolPref( + "privacy.resistFingerprinting" + ); + break; + case "sessionstore.restore_on_demand": + this._restore_on_demand = this._prefBranch.getBoolPref( + "sessionstore.restore_on_demand" + ); + break; + } + }, + + /** + * save state when new tab is added + * @param aWindow + * Window reference + */ + onTabAdd: function ssi_onTabAdd(aWindow) { + this.saveStateDelayed(aWindow); + }, + + /** + * set up listeners for a new tab + * @param aWindow + * Window reference + * @param aTab + * Tab reference + */ + onTabBrowserInserted: function ssi_onTabBrowserInserted(aWindow, aTab) { + let browser = aTab.linkedBrowser; + browser.addEventListener("SwapDocShells", this); + browser.addEventListener("oop-browser-crashed", this); + browser.addEventListener("oop-browser-buildid-mismatch", this); + + if (browser.frameLoader) { + this._lastKnownFrameLoader.set(browser.permanentKey, browser.frameLoader); + } + + // Only restore if browser has been lazy. + if ( + TAB_LAZY_STATES.has(aTab) && + !TAB_STATE_FOR_BROWSER.has(browser) && + lazy.TabStateCache.get(browser.permanentKey) + ) { + let tabState = lazy.TabState.clone(aTab, TAB_CUSTOM_VALUES.get(aTab)); + this.restoreTab(aTab, tabState); + } + + // The browser has been inserted now, so lazy data is no longer relevant. + TAB_LAZY_STATES.delete(aTab); + }, + + /** + * remove listeners for a tab + * @param aWindow + * Window reference + * @param aTab + * Tab reference + * @param aNoNotification + * bool Do not save state if we're updating an existing tab + */ + onTabRemove: function ssi_onTabRemove(aWindow, aTab, aNoNotification) { + this.cleanUpRemovedBrowser(aTab); + + if (!aNoNotification) { + this.saveStateDelayed(aWindow); + } + }, + + /** + * When a tab closes, collect its properties + * @param aWindow + * Window reference + * @param aTab + * Tab reference + */ + onTabClose: function ssi_onTabClose(aWindow, aTab) { + // notify the tabbrowser that the tab state will be retrieved for the last time + // (so that extension authors can easily set data on soon-to-be-closed tabs) + var event = aWindow.document.createEvent("Events"); + event.initEvent("SSTabClosing", true, false); + aTab.dispatchEvent(event); + + // don't update our internal state if we don't have to + if (this._max_tabs_undo == 0) { + return; + } + + // Get the latest data for this tab (generally, from the cache) + let tabState = lazy.TabState.collect(aTab, TAB_CUSTOM_VALUES.get(aTab)); + + // Store closed-tab data for undo. + this.maybeSaveClosedTab(aWindow, aTab, tabState); + }, + + /** + * Flush and copy tab state when moving a tab to a new window. + * @param aFromBrowser + * Browser reference. + * @param aToBrowser + * Browser reference. + */ + onMoveToNewWindow(aFromBrowser, aToBrowser) { + lazy.TabStateFlusher.flush(aFromBrowser).then(() => { + let tabState = lazy.TabStateCache.get(aFromBrowser.permanentKey); + lazy.TabStateCache.update(aToBrowser.permanentKey, tabState); + }); + }, + + /** + * Save a closed tab if needed. + * @param aWindow + * Window reference. + * @param aTab + * Tab reference. + * @param tabState + * Tab state. + */ + maybeSaveClosedTab(aWindow, aTab, tabState) { + // Don't save private tabs + let isPrivateWindow = PrivateBrowsingUtils.isWindowPrivate(aWindow); + if (!isPrivateWindow && tabState.isPrivate) { + return; + } + if (aTab == aWindow.FirefoxViewHandler.tab) { + return; + } + + let permanentKey = aTab.linkedBrowser.permanentKey; + + let tabData = { + permanentKey, + state: tabState, + title: aTab.label, + image: aWindow.gBrowser.getIcon(aTab), + pos: aTab._tPos, + closedAt: Date.now(), + closedInGroup: aTab._closedInGroup, + }; + + let winData = this._windows[aWindow.__SSi]; + let closedTabs = winData._closedTabs; + + // Determine whether the tab contains any information worth saving. Note + // that there might be pending state changes queued in the child that + // didn't reach the parent yet. If a tab is emptied before closing then we + // might still remove it from the list of closed tabs later. + if (this._shouldSaveTabState(tabState)) { + // Save the tab state, for now. We might push a valid tab out + // of the list but those cases should be extremely rare and + // do probably never occur when using the browser normally. + // (Tests or add-ons might do weird things though.) + this.saveClosedTabData(winData, closedTabs, tabData); + } + + // Remember the closed tab to properly handle any last updates included in + // the final "update" message sent by the frame script's unload handler. + this._closedTabs.set(permanentKey, { winData, closedTabs, tabData }); + }, + + /** + * Remove listeners which were added when browser was inserted and reset restoring state. + * Also re-instate lazy data and basically revert tab to its lazy browser state. + * @param aTab + * Tab reference + */ + resetBrowserToLazyState(aTab) { + const gBrowser = aTab.ownerGlobal.gBrowser; + let browser = aTab.linkedBrowser; + // Browser is already lazy so don't do anything. + if (!browser.isConnected) { + return; + } + + this.cleanUpRemovedBrowser(aTab); + + aTab.setAttribute("pending", "true"); + + this._lastKnownFrameLoader.delete(browser.permanentKey); + this._crashedBrowsers.delete(browser.permanentKey); + aTab.removeAttribute("crashed"); + gBrowser.tabContainer.updateTabIndicatorAttr(aTab); + + let { userTypedValue = null, userTypedClear = 0 } = browser; + let hasStartedLoad = browser.didStartLoadSinceLastUserTyping(); + + let cacheState = lazy.TabStateCache.get(browser.permanentKey); + + // Cache the browser userTypedValue either if there is no cache state + // at all (e.g. if it was already discarded before we got to cache its state) + // or it may have been created but not including a userTypedValue (e.g. + // for a private tab we will cache `isPrivate: true` as soon as the tab + // is opened). + // + // But only if: + // + // - if there is no cache state yet (which is unfortunately required + // for tabs discarded immediately after creation by extensions, see + // Bug 1422588). + // + // - or the user typed value was already being loaded (otherwise the lazy + // tab will not be restored with the expected url once activated again, + // see Bug 1724205). + let shouldUpdateCacheState = + userTypedValue && + (!cacheState || (hasStartedLoad && !cacheState.userTypedValue)); + + if (shouldUpdateCacheState) { + // Discard was likely called before state can be cached. Update + // the persistent tab state cache with browser information so a + // restore will be successful. This information is necessary for + // restoreTabContent in ContentRestore.sys.mjs to work properly. + lazy.TabStateCache.update(browser.permanentKey, { + userTypedValue, + userTypedClear: 1, + }); + } + + TAB_LAZY_STATES.set(aTab, { + url: browser.currentURI.spec, + title: aTab.label, + userTypedValue, + userTypedClear, + }); + }, + + /** + * Check if we are dealing with a crashed browser. If so, then the corresponding + * crashed tab was revived by navigating to a different page. Remove the browser + * from the list of crashed browsers to stop ignoring its messages. + * @param aBrowser + * Browser reference + */ + maybeExitCrashedState(aBrowser) { + let uri = aBrowser.documentURI; + if (uri?.spec?.startsWith("about:tabcrashed")) { + this._crashedBrowsers.delete(aBrowser.permanentKey); + } + }, + + /** + * A debugging-only function to check if a browser is in _crashedBrowsers. + * @param aBrowser + * Browser reference + */ + isBrowserInCrashedSet(aBrowser) { + if (gDebuggingEnabled) { + return this._crashedBrowsers.has(aBrowser.permanentKey); + } + throw new Error( + "SessionStore.isBrowserInCrashedSet() should only be called in debug mode!" + ); + }, + + /** + * When a tab is removed or suspended, remove listeners and reset restoring state. + * @param aBrowser + * Browser reference + */ + cleanUpRemovedBrowser(aTab) { + let browser = aTab.linkedBrowser; + + browser.removeEventListener("SwapDocShells", this); + browser.removeEventListener("oop-browser-crashed", this); + browser.removeEventListener("oop-browser-buildid-mismatch", this); + + // If this tab was in the middle of restoring or still needs to be restored, + // we need to reset that state. If the tab was restoring, we will attempt to + // restore the next tab. + let previousState = TAB_STATE_FOR_BROWSER.get(browser); + if (previousState) { + this._resetTabRestoringState(aTab); + if (previousState == TAB_STATE_RESTORING) { + this.restoreNextTab(); + } + } + }, + + /** + * Insert a given |tabData| object into the list of |closedTabs|. We will + * determine the right insertion point based on the .closedAt properties of + * all tabs already in the list. The list will be truncated to contain a + * maximum of |this._max_tabs_undo| entries. + * + * @param winData (object) + * The data of the window. + * @param tabData (object) + * The tabData to be inserted. + * @param closedTabs (array) + * The list of closed tabs for a window. + */ + saveClosedTabData(winData, closedTabs, tabData) { + // Find the index of the first tab in the list + // of closed tabs that was closed before our tab. + let index = closedTabs.findIndex(tab => { + return tab.closedAt < tabData.closedAt; + }); + + // If we found no tab closed before our + // tab then just append it to the list. + if (index == -1) { + index = closedTabs.length; + } + + // About to save the closed tab, add a unique ID. + tabData.closedId = this._nextClosedId++; + + // Insert tabData at the right position. + closedTabs.splice(index, 0, tabData); + this._closedObjectsChanged = true; + + if (tabData.closedInGroup) { + if (winData._lastClosedTabGroupCount < this._max_tabs_undo) { + if (winData._lastClosedTabGroupCount < 0) { + winData._lastClosedTabGroupCount = 1; + } else { + winData._lastClosedTabGroupCount++; + } + } + } else { + winData._lastClosedTabGroupCount = -1; + } + + // Truncate the list of closed tabs, if needed. + if (closedTabs.length > this._max_tabs_undo) { + closedTabs.splice(this._max_tabs_undo, closedTabs.length); + } + }, + + /** + * Remove the closed tab data at |index| from the list of |closedTabs|. If + * the tab's final message is still pending we will simply discard it when + * it arrives so that the tab doesn't reappear in the list. + * + * @param winData (object) + * The data of the window. + * @param index (uint) + * The index of the tab to remove. + * @param closedTabs (array) + * The list of closed tabs for a window. + */ + removeClosedTabData(winData, closedTabs, index) { + // Remove the given index from the list. + let [closedTab] = closedTabs.splice(index, 1); + this._closedObjectsChanged = true; + + // If the tab is part of the last closed group, + // we need to deduct the tab from the count. + if (index < winData._lastClosedTabGroupCount) { + winData._lastClosedTabGroupCount--; + } + + // If the closed tab's state still has a .permanentKey property then we + // haven't seen its final update message yet. Remove it from the map of + // closed tabs so that we will simply discard its last messages and will + // not add it back to the list of closed tabs again. + if (closedTab.permanentKey) { + this._closedTabs.delete(closedTab.permanentKey); + this._closedWindowTabs.delete(closedTab.permanentKey); + delete closedTab.permanentKey; + } + + return closedTab; + }, + + /** + * When a tab is selected, save session data + * @param aWindow + * Window reference + */ + onTabSelect: function ssi_onTabSelect(aWindow) { + if (lazy.RunState.isRunning) { + this._windows[aWindow.__SSi].selected = + aWindow.gBrowser.tabContainer.selectedIndex; + + let tab = aWindow.gBrowser.selectedTab; + let browser = tab.linkedBrowser; + + if (TAB_STATE_FOR_BROWSER.get(browser) == TAB_STATE_NEEDS_RESTORE) { + // If BROWSER_STATE is still available for the browser and it is + // If __SS_restoreState is still on the browser and it is + // TAB_STATE_NEEDS_RESTORE, then we haven't restored this tab yet. + // + // It's possible that this tab was recently revived, and that + // we've deferred showing the tab crashed page for it (if the + // tab crashed in the background). If so, we need to re-enter + // the crashed state, since we'll be showing the tab crashed + // page. + if (lazy.TabCrashHandler.willShowCrashedTab(browser)) { + this.enterCrashedState(browser); + } else { + this.restoreTabContent(tab); + } + } + } + }, + + onTabShow: function ssi_onTabShow(aWindow, aTab) { + // If the tab hasn't been restored yet, move it into the right bucket + if ( + TAB_STATE_FOR_BROWSER.get(aTab.linkedBrowser) == TAB_STATE_NEEDS_RESTORE + ) { + TabRestoreQueue.hiddenToVisible(aTab); + + // let's kick off tab restoration again to ensure this tab gets restored + // with "restore_hidden_tabs" == false (now that it has become visible) + this.restoreNextTab(); + } + + // Default delay of 2 seconds gives enough time to catch multiple TabShow + // events. This used to be due to changing groups in 'tab groups'. We + // might be able to get rid of this now? + this.saveStateDelayed(aWindow); + }, + + onTabHide: function ssi_onTabHide(aWindow, aTab) { + // If the tab hasn't been restored yet, move it into the right bucket + if ( + TAB_STATE_FOR_BROWSER.get(aTab.linkedBrowser) == TAB_STATE_NEEDS_RESTORE + ) { + TabRestoreQueue.visibleToHidden(aTab); + } + + // Default delay of 2 seconds gives enough time to catch multiple TabHide + // events. This used to be due to changing groups in 'tab groups'. We + // might be able to get rid of this now? + this.saveStateDelayed(aWindow); + }, + + /** + * Handler for the event that is fired when a <xul:browser> crashes. + * + * @param aWindow + * The window that the crashed browser belongs to. + * @param aBrowser + * The <xul:browser> that is now in the crashed state. + */ + onBrowserCrashed(aBrowser) { + this.enterCrashedState(aBrowser); + // The browser crashed so we might never receive flush responses. + // Resolve all pending flush requests for the crashed browser. + lazy.TabStateFlusher.resolveAll(aBrowser); + }, + + /** + * Called when a browser is showing or is about to show the tab + * crashed page. This method causes SessionStore to ignore the + * tab until it's restored. + * + * @param browser + * The <xul:browser> that is about to show the crashed page. + */ + enterCrashedState(browser) { + this._crashedBrowsers.add(browser.permanentKey); + + let win = browser.ownerGlobal; + + // If we hadn't yet restored, or were still in the midst of + // restoring this browser at the time of the crash, we need + // to reset its state so that we can try to restore it again + // when the user revives the tab from the crash. + if (TAB_STATE_FOR_BROWSER.has(browser)) { + let tab = win.gBrowser.getTabForBrowser(browser); + if (tab) { + this._resetLocalTabRestoringState(tab); + } + } + }, + + // Clean up data that has been closed a long time ago. + // Do not reschedule a save. This will wait for the next regular + // save. + onIdleDaily() { + // Remove old closed windows + this._cleanupOldData([this._closedWindows]); + + // Remove closed tabs of closed windows + this._cleanupOldData( + this._closedWindows.map(winData => winData._closedTabs) + ); + + // Remove closed tabs of open windows + this._cleanupOldData( + Object.keys(this._windows).map(key => this._windows[key]._closedTabs) + ); + + this._notifyOfClosedObjectsChange(); + }, + + // Remove "old" data from an array + _cleanupOldData(targets) { + const TIME_TO_LIVE = this._prefBranch.getIntPref( + "sessionstore.cleanup.forget_closed_after" + ); + const now = Date.now(); + + for (let array of targets) { + for (let i = array.length - 1; i >= 0; --i) { + let data = array[i]; + // Make sure that we have a timestamp to tell us when the target + // has been closed. If we don't have a timestamp, default to a + // safe timestamp: just now. + data.closedAt = data.closedAt || now; + if (now - data.closedAt > TIME_TO_LIVE) { + array.splice(i, 1); + this._closedObjectsChanged = true; + } + } + } + }, + + /* ........ nsISessionStore API .............. */ + + getBrowserState: function ssi_getBrowserState() { + let state = this.getCurrentState(); + + // Don't include the last session state in getBrowserState(). + delete state.lastSessionState; + + // Don't include any deferred initial state. + delete state.deferredInitialState; + + return JSON.stringify(state); + }, + + setBrowserState: function ssi_setBrowserState(aState) { + this._handleClosedWindows(); + + try { + var state = JSON.parse(aState); + } catch (ex) { + /* invalid state object - don't restore anything */ + } + if (!state) { + throw Components.Exception( + "Invalid state string: not JSON", + Cr.NS_ERROR_INVALID_ARG + ); + } + if (!state.windows) { + throw Components.Exception("No windows", Cr.NS_ERROR_INVALID_ARG); + } + + this._browserSetState = true; + + // Make sure the priority queue is emptied out + this._resetRestoringState(); + + var window = this._getTopWindow(); + if (!window) { + this._restoreCount = 1; + this._openWindowWithState(state); + return; + } + + // close all other browser windows + for (let otherWin of this._browserWindows) { + if (otherWin != window) { + otherWin.close(); + this.onClose(otherWin); + } + } + + // make sure closed window data isn't kept + if (this._closedWindows.length) { + this._closedWindows = []; + this._closedObjectsChanged = true; + } + + // determine how many windows are meant to be restored + this._restoreCount = state.windows ? state.windows.length : 0; + + // global data must be restored before restoreWindow is called so that + // it happens before observers are notified + this._globalState.setFromState(state); + + // Restore session cookies. + lazy.SessionCookies.restore(state.cookies || []); + + // restore to the given state + this.restoreWindows(window, state, { overwriteTabs: true }); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + }, + + getWindowState: function ssi_getWindowState(aWindow) { + if ("__SSi" in aWindow) { + return Cu.cloneInto(this._getWindowState(aWindow), {}); + } + + if (DyingWindowCache.has(aWindow)) { + let data = DyingWindowCache.get(aWindow); + return Cu.cloneInto({ windows: [data] }, {}); + } + + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + }, + + setWindowState: function ssi_setWindowState(aWindow, aState, aOverwrite) { + if (!aWindow.__SSi) { + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + + this.restoreWindows(aWindow, aState, { overwriteTabs: aOverwrite }); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + }, + + getTabState: function ssi_getTabState(aTab) { + if (!aTab || !aTab.ownerGlobal) { + throw Components.Exception("Need a valid tab", Cr.NS_ERROR_INVALID_ARG); + } + if (!aTab.ownerGlobal.__SSi) { + throw Components.Exception( + "Default view is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + + let tabState = lazy.TabState.collect(aTab, TAB_CUSTOM_VALUES.get(aTab)); + + return JSON.stringify(tabState); + }, + + setTabState(aTab, aState) { + // Remove the tab state from the cache. + // Note that we cannot simply replace the contents of the cache + // as |aState| can be an incomplete state that will be completed + // by |restoreTabs|. + let tabState = aState; + if (typeof tabState == "string") { + tabState = JSON.parse(aState); + } + if (!tabState) { + throw Components.Exception( + "Invalid state string: not JSON", + Cr.NS_ERROR_INVALID_ARG + ); + } + if (typeof tabState != "object") { + throw Components.Exception("Not an object", Cr.NS_ERROR_INVALID_ARG); + } + if (!("entries" in tabState)) { + throw Components.Exception( + "Invalid state object: no entries", + Cr.NS_ERROR_INVALID_ARG + ); + } + + let window = aTab.ownerGlobal; + if (!window || !("__SSi" in window)) { + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + + if (TAB_STATE_FOR_BROWSER.has(aTab.linkedBrowser)) { + this._resetTabRestoringState(aTab); + } + + this.restoreTab(aTab, tabState); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + }, + + getInternalObjectState(obj) { + if (obj.__SSi) { + return this._windows[obj.__SSi]; + } + return obj.loadURI + ? TAB_STATE_FOR_BROWSER.get(obj) + : TAB_CUSTOM_VALUES.get(obj); + }, + + duplicateTab: function ssi_duplicateTab( + aWindow, + aTab, + aDelta = 0, + aRestoreImmediately = true, + { inBackground, index } = {} + ) { + if (!aTab || !aTab.ownerGlobal) { + throw Components.Exception("Need a valid tab", Cr.NS_ERROR_INVALID_ARG); + } + if (!aTab.ownerGlobal.__SSi) { + throw Components.Exception( + "Default view is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + if (!aWindow.gBrowser) { + throw Components.Exception( + "Invalid window object: no gBrowser", + Cr.NS_ERROR_INVALID_ARG + ); + } + + // Create a new tab. + let userContextId = aTab.getAttribute("usercontextid"); + + let tabOptions = { + userContextId, + index, + ...(aTab == aWindow.gBrowser.selectedTab + ? { relatedToCurrent: true, ownerTab: aTab } + : {}), + skipLoad: true, + preferredRemoteType: aTab.linkedBrowser.remoteType, + }; + let newTab = aWindow.gBrowser.addTrustedTab(null, tabOptions); + + // Start the throbber to pretend we're doing something while actually + // waiting for data from the frame script. This throbber is disabled + // if the URI is a local about: URI. + let uriObj = aTab.linkedBrowser.currentURI; + if (!uriObj || (uriObj && !uriObj.schemeIs("about"))) { + newTab.setAttribute("busy", "true"); + } + + // Hack to ensure that the about:home, about:newtab, and about:welcome + // favicon is loaded instantaneously, to avoid flickering and improve + // perceived performance. + aWindow.gBrowser.setDefaultIcon(newTab, uriObj); + + // Collect state before flushing. + let tabState = lazy.TabState.collect(aTab, TAB_CUSTOM_VALUES.get(aTab)); + + // Flush to get the latest tab state to duplicate. + let browser = aTab.linkedBrowser; + lazy.TabStateFlusher.flush(browser).then(() => { + // The new tab might have been closed in the meantime. + if (newTab.closing || !newTab.linkedBrowser) { + return; + } + + let window = newTab.ownerGlobal; + + // The tab or its window might be gone. + if (!window || !window.__SSi) { + return; + } + + // Update state with flushed data. We can't use TabState.clone() here as + // the tab to duplicate may have already been closed. In that case we + // only have access to the <xul:browser>. + let options = { includePrivateData: true }; + lazy.TabState.copyFromCache(browser.permanentKey, tabState, options); + + tabState.index += aDelta; + tabState.index = Math.max( + 1, + Math.min(tabState.index, tabState.entries.length) + ); + tabState.pinned = false; + + if (inBackground === false) { + aWindow.gBrowser.selectedTab = newTab; + } + + // Restore the state into the new tab. + this.restoreTab(newTab, tabState, { + restoreImmediately: aRestoreImmediately, + }); + }); + + return newTab; + }, + + getLastClosedTabCount(aWindow) { + if ("__SSi" in aWindow) { + return Math.min( + Math.max(this._windows[aWindow.__SSi]._lastClosedTabGroupCount, 1), + this.getClosedTabCount(aWindow) + ); + } + + throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG); + }, + + resetLastClosedTabCount(aWindow) { + if ("__SSi" in aWindow) { + this._windows[aWindow.__SSi]._lastClosedTabGroupCount = -1; + } else { + throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG); + } + }, + + getClosedTabCount: function ssi_getClosedTabCount(aWindow) { + if ("__SSi" in aWindow) { + return this._windows[aWindow.__SSi]._closedTabs.length; + } + + if (!DyingWindowCache.has(aWindow)) { + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + + return DyingWindowCache.get(aWindow)._closedTabs.length; + }, + + getClosedTabData: function ssi_getClosedTabData(aWindow) { + if ("__SSi" in aWindow) { + return Cu.cloneInto(this._windows[aWindow.__SSi]._closedTabs, {}); + } + + if (!DyingWindowCache.has(aWindow)) { + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + + let data = DyingWindowCache.get(aWindow); + return Cu.cloneInto(data._closedTabs, {}); + }, + + undoCloseTab: function ssi_undoCloseTab(aWindow, aIndex) { + if (!aWindow.__SSi) { + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + + let winData = this._windows[aWindow.__SSi]; + + // default to the most-recently closed tab + aIndex = aIndex || 0; + if (!(aIndex in winData._closedTabs)) { + throw Components.Exception( + "Invalid index: not in the closed tabs", + Cr.NS_ERROR_INVALID_ARG + ); + } + + // fetch the data of closed tab, while removing it from the array + let { state, pos } = this.removeClosedTabData( + winData, + winData._closedTabs, + aIndex + ); + + // Predict the remote type to use for the load to avoid unnecessary process + // switches. + let preferredRemoteType = lazy.E10SUtils.DEFAULT_REMOTE_TYPE; + if (state.entries?.length) { + let activeIndex = (state.index || state.entries.length) - 1; + activeIndex = Math.min(activeIndex, state.entries.length - 1); + activeIndex = Math.max(activeIndex, 0); + + preferredRemoteType = lazy.E10SUtils.getRemoteTypeForURI( + state.entries[activeIndex].url, + aWindow.gMultiProcessBrowser, + aWindow.gFissionBrowser, + lazy.E10SUtils.DEFAULT_REMOTE_TYPE, + null, + lazy.E10SUtils.predictOriginAttributes({ + window: aWindow, + userContextId: state.userContextId, + }) + ); + } + + // create a new tab + let tabbrowser = aWindow.gBrowser; + let tab = (tabbrowser.selectedTab = tabbrowser.addTrustedTab(null, { + index: pos, + pinned: state.pinned, + userContextId: state.userContextId, + skipLoad: true, + preferredRemoteType, + })); + + // restore tab content + this.restoreTab(tab, state); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + + return tab; + }, + + forgetClosedTab: function ssi_forgetClosedTab(aWindow, aIndex) { + if (!aWindow.__SSi) { + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + + let winData = this._windows[aWindow.__SSi]; + + // default to the most-recently closed tab + aIndex = aIndex || 0; + if (!(aIndex in winData._closedTabs)) { + throw Components.Exception( + "Invalid index: not in the closed tabs", + Cr.NS_ERROR_INVALID_ARG + ); + } + + // remove closed tab from the array + this.removeClosedTabData(winData, winData._closedTabs, aIndex); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + }, + + getClosedWindowCount: function ssi_getClosedWindowCount() { + return this._closedWindows.length; + }, + + getClosedWindowData: function ssi_getClosedWindowData() { + return Cu.cloneInto(this._closedWindows, {}); + }, + + maybeDontRestoreTabs(aWindow) { + // Don't restore the tabs if we restore the session at startup + this._windows[aWindow.__SSi]._maybeDontRestoreTabs = true; + }, + + isLastRestorableWindow() { + return ( + Object.values(this._windows).filter(winData => !winData.isPrivate) + .length == 1 && + !this._closedWindows.some(win => win._shouldRestore || false) + ); + }, + + undoCloseWindow: function ssi_undoCloseWindow(aIndex) { + if (!(aIndex in this._closedWindows)) { + throw Components.Exception( + "Invalid index: not in the closed windows", + Cr.NS_ERROR_INVALID_ARG + ); + } + // reopen the window + let state = { windows: this._removeClosedWindow(aIndex) }; + delete state.windows[0].closedAt; // Window is now open. + + let window = this._openWindowWithState(state); + this.windowToFocus = window; + WINDOW_SHOWING_PROMISES.get(window).promise.then(win => + this.restoreWindows(win, state, { overwriteTabs: true }) + ); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + + return window; + }, + + forgetClosedWindow: function ssi_forgetClosedWindow(aIndex) { + // default to the most-recently closed window + aIndex = aIndex || 0; + if (!(aIndex in this._closedWindows)) { + throw Components.Exception( + "Invalid index: not in the closed windows", + Cr.NS_ERROR_INVALID_ARG + ); + } + + // remove closed window from the array + let winData = this._closedWindows[aIndex]; + this._removeClosedWindow(aIndex); + this._saveableClosedWindowData.delete(winData); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + }, + + getCustomWindowValue(aWindow, aKey) { + if ("__SSi" in aWindow) { + let data = this._windows[aWindow.__SSi].extData || {}; + return data[aKey] || ""; + } + + if (DyingWindowCache.has(aWindow)) { + let data = DyingWindowCache.get(aWindow).extData || {}; + return data[aKey] || ""; + } + + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + }, + + setCustomWindowValue(aWindow, aKey, aStringValue) { + if (typeof aStringValue != "string") { + throw new TypeError("setCustomWindowValue only accepts string values"); + } + + if (!("__SSi" in aWindow)) { + throw Components.Exception( + "Window is not tracked", + Cr.NS_ERROR_INVALID_ARG + ); + } + if (!this._windows[aWindow.__SSi].extData) { + this._windows[aWindow.__SSi].extData = {}; + } + this._windows[aWindow.__SSi].extData[aKey] = aStringValue; + this.saveStateDelayed(aWindow); + }, + + deleteCustomWindowValue(aWindow, aKey) { + if ( + aWindow.__SSi && + this._windows[aWindow.__SSi].extData && + this._windows[aWindow.__SSi].extData[aKey] + ) { + delete this._windows[aWindow.__SSi].extData[aKey]; + } + this.saveStateDelayed(aWindow); + }, + + getCustomTabValue(aTab, aKey) { + return (TAB_CUSTOM_VALUES.get(aTab) || {})[aKey] || ""; + }, + + setCustomTabValue(aTab, aKey, aStringValue) { + if (typeof aStringValue != "string") { + throw new TypeError("setCustomTabValue only accepts string values"); + } + + // If the tab hasn't been restored, then set the data there, otherwise we + // could lose newly added data. + if (!TAB_CUSTOM_VALUES.has(aTab)) { + TAB_CUSTOM_VALUES.set(aTab, {}); + } + + TAB_CUSTOM_VALUES.get(aTab)[aKey] = aStringValue; + this.saveStateDelayed(aTab.ownerGlobal); + }, + + deleteCustomTabValue(aTab, aKey) { + let state = TAB_CUSTOM_VALUES.get(aTab); + if (state && aKey in state) { + delete state[aKey]; + this.saveStateDelayed(aTab.ownerGlobal); + } + }, + + /** + * Retrieves data specific to lazy-browser tabs. If tab is not lazy, + * will return undefined. + * + * @param aTab (xul:tab) + * The tabbrowser-tab the data is for. + * @param aKey (string) + * The key which maps to the desired data. + */ + getLazyTabValue(aTab, aKey) { + return (TAB_LAZY_STATES.get(aTab) || {})[aKey]; + }, + + getCustomGlobalValue(aKey) { + return this._globalState.get(aKey); + }, + + setCustomGlobalValue(aKey, aStringValue) { + if (typeof aStringValue != "string") { + throw new TypeError("setCustomGlobalValue only accepts string values"); + } + + this._globalState.set(aKey, aStringValue); + this.saveStateDelayed(); + }, + + deleteCustomGlobalValue(aKey) { + this._globalState.delete(aKey); + this.saveStateDelayed(); + }, + + persistTabAttribute: function ssi_persistTabAttribute(aName) { + if (lazy.TabAttributes.persist(aName)) { + this.saveStateDelayed(); + } + }, + + /** + * Undoes the closing of a tab or window which corresponds + * to the closedId passed in. + * + * @param aClosedId + * The closedId of the tab or window + * @param aIncludePrivate + * Whether to restore private tabs or windows + * + * @returns a tab or window object + */ + undoCloseById(aClosedId, aIncludePrivate = true) { + // Check for a window first. + for (let i = 0, l = this._closedWindows.length; i < l; i++) { + if (this._closedWindows[i].closedId == aClosedId) { + return this.undoCloseWindow(i); + } + } + + // Check for a tab. + for (let window of Services.wm.getEnumerator("navigator:browser")) { + if (!aIncludePrivate && PrivateBrowsingUtils.isWindowPrivate(window)) { + continue; + } + let windowState = this._windows[window.__SSi]; + if (windowState) { + for (let j = 0, l = windowState._closedTabs.length; j < l; j++) { + if (windowState._closedTabs[j].closedId == aClosedId) { + return this.undoCloseTab(window, j); + } + } + } + } + + // Neither a tab nor a window was found, return undefined and let the caller decide what to do about it. + return undefined; + }, + + /** + * Updates the label and icon for a <xul:tab> using the data from + * tabData. + * + * @param tab + * The <xul:tab> to update. + * @param tabData (optional) + * The tabData to use to update the tab. If the argument is + * not supplied, the data will be retrieved from the cache. + */ + updateTabLabelAndIcon(tab, tabData = null) { + if (tab.hasAttribute("customizemode")) { + return; + } + + let browser = tab.linkedBrowser; + let win = browser.ownerGlobal; + + if (!tabData) { + tabData = lazy.TabState.collect(tab, TAB_CUSTOM_VALUES.get(tab)); + if (!tabData) { + throw new Error("tabData not found for given tab"); + } + } + + let activePageData = tabData.entries[tabData.index - 1] || null; + + // If the page has a title, set it. + if (activePageData) { + if (activePageData.title && activePageData.title != activePageData.url) { + win.gBrowser.setInitialTabTitle(tab, activePageData.title, { + isContentTitle: true, + }); + } else { + win.gBrowser.setInitialTabTitle(tab, activePageData.url); + } + } + + // Restore the tab icon. + if ("image" in tabData) { + // We know that about:blank is safe to load in any remote type. Since + // SessionStore is triggered with about:blank, there must be a process + // flip. We will ignore the first about:blank load to prevent resetting the + // favicon that we have set earlier to avoid flickering and improve + // perceived performance. + if ( + !activePageData || + (activePageData && activePageData.url != "about:blank") + ) { + win.gBrowser.setIcon( + tab, + tabData.image, + undefined, + tabData.iconLoadingPrincipal + ); + } + lazy.TabStateCache.update(browser.permanentKey, { + image: null, + iconLoadingPrincipal: null, + }); + } + }, + + // This method deletes all the closedTabs matching userContextId. + _forgetTabsWithUserContextId(userContextId) { + for (let window of Services.wm.getEnumerator("navigator:browser")) { + let windowState = this._windows[window.__SSi]; + if (windowState) { + // In order to remove the tabs in the correct order, we store the + // indexes, into an array, then we revert the array and remove closed + // data from the last one going backward. + let indexes = []; + windowState._closedTabs.forEach((closedTab, index) => { + if (closedTab.state.userContextId == userContextId) { + indexes.push(index); + } + }); + + for (let index of indexes.reverse()) { + this.removeClosedTabData(windowState, windowState._closedTabs, index); + } + } + } + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + }, + + /** + * Restores the session state stored in LastSession. This will attempt + * to merge data into the current session. If a window was opened at startup + * with pinned tab(s), then the remaining data from the previous session for + * that window will be opened into that window. Otherwise new windows will + * be opened. + */ + restoreLastSession: function ssi_restoreLastSession() { + // Use the public getter since it also checks PB mode + if (!this.canRestoreLastSession) { + throw Components.Exception("Last session can not be restored"); + } + + Services.obs.notifyObservers(null, NOTIFY_INITIATING_MANUAL_RESTORE); + + // First collect each window with its id... + let windows = {}; + for (let window of this._browserWindows) { + if (window.__SS_lastSessionWindowID) { + windows[window.__SS_lastSessionWindowID] = window; + } + } + + let lastSessionState = LastSession.getState(); + + // This shouldn't ever be the case... + if (!lastSessionState.windows.length) { + throw Components.Exception( + "lastSessionState has no windows", + Cr.NS_ERROR_UNEXPECTED + ); + } + + // We're technically doing a restore, so set things up so we send the + // notification when we're done. We want to send "sessionstore-browser-state-restored". + this._restoreCount = lastSessionState.windows.length; + this._browserSetState = true; + + // We want to re-use the last opened window instead of opening a new one in + // the case where it's "empty" and not associated with a window in the session. + // We will do more processing via _prepWindowToRestoreInto if we need to use + // the lastWindow. + let lastWindow = this._getTopWindow(); + let canUseLastWindow = lastWindow && !lastWindow.__SS_lastSessionWindowID; + + // global data must be restored before restoreWindow is called so that + // it happens before observers are notified + this._globalState.setFromState(lastSessionState); + + let openWindows = []; + let windowsToOpen = []; + + // Restore session cookies. + lazy.SessionCookies.restore(lastSessionState.cookies || []); + + // Restore into windows or open new ones as needed. + for (let i = 0; i < lastSessionState.windows.length; i++) { + let winState = lastSessionState.windows[i]; + let lastSessionWindowID = winState.__lastSessionWindowID; + // delete lastSessionWindowID so we don't add that to the window again + delete winState.__lastSessionWindowID; + + // See if we can use an open window. First try one that is associated with + // the state we're trying to restore and then fallback to the last selected + // window. + let windowToUse = windows[lastSessionWindowID]; + if (!windowToUse && canUseLastWindow) { + windowToUse = lastWindow; + canUseLastWindow = false; + } + + let [canUseWindow, canOverwriteTabs] = this._prepWindowToRestoreInto( + windowToUse + ); + + // If there's a window already open that we can restore into, use that + if (canUseWindow) { + // Since we're not overwriting existing tabs, we want to merge _closedTabs, + // putting existing ones first. Then make sure we're respecting the max pref. + if (winState._closedTabs && winState._closedTabs.length) { + let curWinState = this._windows[windowToUse.__SSi]; + curWinState._closedTabs = curWinState._closedTabs.concat( + winState._closedTabs + ); + curWinState._closedTabs.splice( + this._max_tabs_undo, + curWinState._closedTabs.length + ); + } + + // XXXzpao This is going to merge extData together (taking what was in + // winState over what is in the window already. + // We don't restore window right away, just store its data. + // Later, these windows will be restored with newly opened windows. + this._updateWindowRestoreState(windowToUse, { + windows: [winState], + options: { overwriteTabs: canOverwriteTabs }, + }); + openWindows.push(windowToUse); + } else { + windowsToOpen.push(winState); + } + } + + // Actually restore windows in reversed z-order. + this._openWindows({ windows: windowsToOpen }).then(openedWindows => + this._restoreWindowsInReversedZOrder(openWindows.concat(openedWindows)) + ); + + // Merge closed windows from this session with ones from last session + if (lastSessionState._closedWindows) { + this._closedWindows = this._closedWindows.concat( + lastSessionState._closedWindows + ); + this._capClosedWindows(); + this._closedObjectsChanged = true; + } + + lazy.DevToolsShim.restoreDevToolsSession(lastSessionState); + + // Set data that persists between sessions + this._recentCrashes = + (lastSessionState.session && lastSessionState.session.recentCrashes) || 0; + + // Update the session start time using the restored session state. + this._updateSessionStartTime(lastSessionState); + + LastSession.clear(); + + // Notify of changes to closed objects. + this._notifyOfClosedObjectsChange(); + }, + + /** + * Revive a crashed tab and restore its state from before it crashed. + * + * @param aTab + * A <xul:tab> linked to a crashed browser. This is a no-op if the + * browser hasn't actually crashed, or is not associated with a tab. + * This function will also throw if the browser happens to be remote. + */ + reviveCrashedTab(aTab) { + if (!aTab) { + throw new Error( + "SessionStore.reviveCrashedTab expected a tab, but got null." + ); + } + + const gBrowser = aTab.ownerGlobal.gBrowser; + let browser = aTab.linkedBrowser; + if (!this._crashedBrowsers.has(browser.permanentKey)) { + return; + } + + // Sanity check - the browser to be revived should not be remote + // at this point. + if (browser.isRemoteBrowser) { + throw new Error( + "SessionStore.reviveCrashedTab: " + + "Somehow a crashed browser is still remote." + ); + } + + // We put the browser at about:blank in case the user is + // restoring tabs on demand. This way, the user won't see + // a flash of the about:tabcrashed page after selecting + // the revived tab. + aTab.removeAttribute("crashed"); + gBrowser.tabContainer.updateTabIndicatorAttr(aTab); + + browser.loadURI("about:blank", { + triggeringPrincipal: Services.scriptSecurityManager.createNullPrincipal({ + userContextId: aTab.userContextId, + }), + remoteTypeOverride: lazy.E10SUtils.NOT_REMOTE, + }); + + let data = lazy.TabState.collect(aTab, TAB_CUSTOM_VALUES.get(aTab)); + this.restoreTab(aTab, data, { + forceOnDemand: true, + }); + }, + + /** + * Revive all crashed tabs and reset the crashed tabs count to 0. + */ + reviveAllCrashedTabs() { + for (let window of Services.wm.getEnumerator("navigator:browser")) { + for (let tab of window.gBrowser.tabs) { + this.reviveCrashedTab(tab); + } + } + }, + + /** + * Retrieves the latest session history information for a tab. The cached data + * is returned immediately, but a callback may be provided that supplies + * up-to-date data when or if it is available. The callback is passed a single + * argument with data in the same format as the return value. + * + * @param tab tab to retrieve the session history for + * @param updatedCallback function to call with updated data as the single argument + * @returns a object containing 'index' specifying the current index, and an + * array 'entries' containing an object for each history item. + */ + getSessionHistory(tab, updatedCallback) { + if (updatedCallback) { + lazy.TabStateFlusher.flush(tab.linkedBrowser).then(() => { + let sessionHistory = this.getSessionHistory(tab); + if (sessionHistory) { + updatedCallback(sessionHistory); + } + }); + } + + // Don't continue if the tab was closed before TabStateFlusher.flush resolves. + if (tab.linkedBrowser) { + let tabState = lazy.TabState.collect(tab, TAB_CUSTOM_VALUES.get(tab)); + return { index: tabState.index - 1, entries: tabState.entries }; + } + return null; + }, + + /** + * See if aWindow is usable for use when restoring a previous session via + * restoreLastSession. If usable, prepare it for use. + * + * @param aWindow + * the window to inspect & prepare + * @returns [canUseWindow, canOverwriteTabs] + * canUseWindow: can the window be used to restore into + * canOverwriteTabs: all of the current tabs are home pages and we + * can overwrite them + */ + _prepWindowToRestoreInto: function ssi_prepWindowToRestoreInto(aWindow) { + if (!aWindow) { + return [false, false]; + } + + // We might be able to overwrite the existing tabs instead of just adding + // the previous session's tabs to the end. This will be set if possible. + let canOverwriteTabs = false; + + // Look at the open tabs in comparison to home pages. If all the tabs are + // home pages then we'll end up overwriting all of them. Otherwise we'll + // just close the tabs that match home pages. Tabs with the about:blank + // URI will always be overwritten. + let homePages = ["about:blank"]; + let removableTabs = []; + let tabbrowser = aWindow.gBrowser; + let startupPref = this._prefBranch.getIntPref("startup.page"); + if (startupPref == 1) { + homePages = homePages.concat(lazy.HomePage.get(aWindow).split("|")); + } + + for (let i = tabbrowser._numPinnedTabs; i < tabbrowser.tabs.length; i++) { + let tab = tabbrowser.tabs[i]; + if (homePages.includes(tab.linkedBrowser.currentURI.spec)) { + removableTabs.push(tab); + } + } + + if ( + tabbrowser.tabs.length > tabbrowser.visibleTabs.length && + tabbrowser.visibleTabs.length === removableTabs.length + ) { + // If all the visible tabs are also removable and the selected tab is hidden or removeable, we will later remove + // all "removable" tabs causing the browser to automatically close because the only tab left is hidden. + // To prevent the browser from automatically closing, we will leave one other visible tab open. + removableTabs.shift(); + } + + if (tabbrowser.tabs.length == removableTabs.length) { + canOverwriteTabs = true; + } else { + // If we're not overwriting all of the tabs, then close the home tabs. + for (let i = removableTabs.length - 1; i >= 0; i--) { + tabbrowser.removeTab(removableTabs.pop(), { animate: false }); + } + } + + return [true, canOverwriteTabs]; + }, + + /* ........ Saving Functionality .............. */ + + /** + * Store window dimensions, visibility, sidebar + * @param aWindow + * Window reference + */ + _updateWindowFeatures: function ssi_updateWindowFeatures(aWindow) { + var winData = this._windows[aWindow.__SSi]; + + WINDOW_ATTRIBUTES.forEach(function(aAttr) { + winData[aAttr] = this._getWindowDimension(aWindow, aAttr); + }, this); + + if (winData.sizemode != "minimized") { + winData.sizemodeBeforeMinimized = winData.sizemode; + } + + var hidden = WINDOW_HIDEABLE_FEATURES.filter(function(aItem) { + return aWindow[aItem] && !aWindow[aItem].visible; + }); + if (hidden.length) { + winData.hidden = hidden.join(","); + } else if (winData.hidden) { + delete winData.hidden; + } + + let sidebarBox = aWindow.document.getElementById("sidebar-box"); + let sidebar = sidebarBox.getAttribute("sidebarcommand"); + if (sidebar && sidebarBox.getAttribute("checked") == "true") { + winData.sidebar = sidebar; + } else if (winData.sidebar) { + delete winData.sidebar; + } + let workspaceID = aWindow.getWorkspaceID(); + if (workspaceID) { + winData.workspaceID = workspaceID; + } + }, + + /** + * gather session data as object + * @param aUpdateAll + * Bool update all windows + * @returns object + */ + getCurrentState(aUpdateAll) { + this._handleClosedWindows().then(() => { + this._notifyOfClosedObjectsChange(); + }); + + var activeWindow = this._getTopWindow(); + + TelemetryStopwatch.start("FX_SESSION_RESTORE_COLLECT_ALL_WINDOWS_DATA_MS"); + if (lazy.RunState.isRunning) { + // update the data for all windows with activities since the last save operation. + let index = 0; + for (let window of this._orderedBrowserWindows) { + if (!this._isWindowLoaded(window)) { + // window data is still in _statesToRestore + continue; + } + if (aUpdateAll || DirtyWindows.has(window) || window == activeWindow) { + this._collectWindowData(window); + } else { + // always update the window features (whose change alone never triggers a save operation) + this._updateWindowFeatures(window); + } + this._windows[window.__SSi].zIndex = ++index; + } + DirtyWindows.clear(); + } + TelemetryStopwatch.finish("FX_SESSION_RESTORE_COLLECT_ALL_WINDOWS_DATA_MS"); + + // An array that at the end will hold all current window data. + var total = []; + // The ids of all windows contained in 'total' in the same order. + var ids = []; + // The number of window that are _not_ popups. + var nonPopupCount = 0; + var ix; + + // collect the data for all windows + for (ix in this._windows) { + if (this._windows[ix]._restoring) { + // window data is still in _statesToRestore + continue; + } + total.push(this._windows[ix]); + ids.push(ix); + if (!this._windows[ix].isPopup) { + nonPopupCount++; + } + } + + // collect the data for all windows yet to be restored + for (ix in this._statesToRestore) { + for (let winData of this._statesToRestore[ix].windows) { + total.push(winData); + if (!winData.isPopup) { + nonPopupCount++; + } + } + } + + // shallow copy this._closedWindows to preserve current state + let lastClosedWindowsCopy = this._closedWindows.slice(); + + if (AppConstants.platform != "macosx") { + // If no non-popup browser window remains open, return the state of the last + // closed window(s). We only want to do this when we're actually "ending" + // the session. + // XXXzpao We should do this for _restoreLastWindow == true, but that has + // its own check for popups. c.f. bug 597619 + if ( + nonPopupCount == 0 && + !!lastClosedWindowsCopy.length && + lazy.RunState.isQuitting + ) { + // prepend the last non-popup browser window, so that if the user loads more tabs + // at startup we don't accidentally add them to a popup window + do { + total.unshift(lastClosedWindowsCopy.shift()); + } while (total[0].isPopup && lastClosedWindowsCopy.length); + } + } + + if (activeWindow) { + this.activeWindowSSiCache = activeWindow.__SSi || ""; + } + ix = ids.indexOf(this.activeWindowSSiCache); + // We don't want to restore focus to a minimized window or a window which had all its + // tabs stripped out (doesn't exist). + if (ix != -1 && total[ix] && total[ix].sizemode == "minimized") { + ix = -1; + } + + let session = { + lastUpdate: Date.now(), + startTime: this._sessionStartTime, + recentCrashes: this._recentCrashes, + }; + + let state = { + version: ["sessionrestore", FORMAT_VERSION], + windows: total, + selectedWindow: ix + 1, + _closedWindows: lastClosedWindowsCopy, + session, + global: this._globalState.getState(), + }; + + // Collect and store session cookies. + state.cookies = lazy.SessionCookies.collect(); + + lazy.DevToolsShim.saveDevToolsSession(state); + + // Persist the last session if we deferred restoring it + if (LastSession.canRestore) { + state.lastSessionState = LastSession.getState(); + } + + // If we were called by the SessionSaver and started with only a private + // window we want to pass the deferred initial state to not lose the + // previous session. + if (this._deferredInitialState) { + state.deferredInitialState = this._deferredInitialState; + } + + return state; + }, + + /** + * serialize session data for a window + * @param aWindow + * Window reference + * @returns string + */ + _getWindowState: function ssi_getWindowState(aWindow) { + if (!this._isWindowLoaded(aWindow)) { + return this._statesToRestore[WINDOW_RESTORE_IDS.get(aWindow)]; + } + + if (lazy.RunState.isRunning) { + this._collectWindowData(aWindow); + } + + return { windows: [this._windows[aWindow.__SSi]] }; + }, + + /** + * Gathers data about a window and its tabs, and updates its + * entry in this._windows. + * + * @param aWindow + * Window references. + * @returns a Map mapping the browser tabs from aWindow to the tab + * entry that was put into the window data in this._windows. + */ + _collectWindowData: function ssi_collectWindowData(aWindow) { + let tabMap = new Map(); + + if (!this._isWindowLoaded(aWindow)) { + return tabMap; + } + + let tabbrowser = aWindow.gBrowser; + let tabs = tabbrowser.tabs; + let winData = this._windows[aWindow.__SSi]; + let tabsData = (winData.tabs = []); + + // update the internal state data for this window + for (let tab of tabs) { + if (tab == aWindow.FirefoxViewHandler.tab) { + continue; + } + let tabData = lazy.TabState.collect(tab, TAB_CUSTOM_VALUES.get(tab)); + tabMap.set(tab, tabData); + tabsData.push(tabData); + } + + let selectedIndex = tabbrowser.tabbox.selectedIndex + 1; + // We don't store the Firefox View tab in Session Store, so if it was the last selected "tab" when + // a window is closed, point to the first item in the tab strip instead (it will never be the Firefox View tab, + // since it's only inserted into the tab strip after it's selected). + if (aWindow.FirefoxViewHandler.tab?.selected) { + selectedIndex = 1; + winData.title = tabbrowser.tabs[0].label; + } + winData.selected = selectedIndex; + + this._updateWindowFeatures(aWindow); + + // Make sure we keep __SS_lastSessionWindowID around for cases like entering + // or leaving PB mode. + if (aWindow.__SS_lastSessionWindowID) { + this._windows[aWindow.__SSi].__lastSessionWindowID = + aWindow.__SS_lastSessionWindowID; + } + + DirtyWindows.remove(aWindow); + return tabMap; + }, + + /* ........ Restoring Functionality .............. */ + + /** + * Open windows with data + * + * @param root + * Windows data + * @returns a promise resolved when all windows have been opened + */ + _openWindows(root) { + let windowsOpened = []; + for (let winData of root.windows) { + if (!winData || !winData.tabs || !winData.tabs[0]) { + continue; + } + windowsOpened.push(this._openWindowWithState({ windows: [winData] })); + } + let windowOpenedPromises = []; + for (const openedWindow of windowsOpened) { + let deferred = WINDOW_SHOWING_PROMISES.get(openedWindow); + windowOpenedPromises.push(deferred.promise); + } + return Promise.all(windowOpenedPromises); + }, + + /** reset closedId's from previous sessions to ensure these IDs are unique + * @param tabData + * an array of data to be restored + * @returns the updated tabData array + */ + _resetClosedIds(tabData) { + for (let entry of tabData) { + entry.closedId = this._nextClosedId++; + } + return tabData; + }, + /** + * restore features to a single window + * @param aWindow + * Window reference to the window to use for restoration + * @param winData + * JS object + * @param aOptions + * {overwriteTabs: true} to overwrite existing tabs w/ new ones + * {firstWindow: true} if this is the first non-private window we're + * restoring in this session, that might open an + * external link as well + */ + restoreWindow: function ssi_restoreWindow(aWindow, winData, aOptions = {}) { + let overwriteTabs = aOptions && aOptions.overwriteTabs; + let firstWindow = aOptions && aOptions.firstWindow; + + // initialize window if necessary + if (aWindow && (!aWindow.__SSi || !this._windows[aWindow.__SSi])) { + this.onLoad(aWindow); + } + + TelemetryStopwatch.start("FX_SESSION_RESTORE_RESTORE_WINDOW_MS"); + + // We're not returning from this before we end up calling restoreTabs + // for this window, so make sure we send the SSWindowStateBusy event. + this._sendWindowRestoringNotification(aWindow); + this._setWindowStateBusy(aWindow); + + if (winData.workspaceID) { + aWindow.moveToWorkspace(winData.workspaceID); + } + + if (!winData.tabs) { + winData.tabs = []; + // don't restore a single blank tab when we've had an external + // URL passed in for loading at startup (cf. bug 357419) + } else if ( + firstWindow && + !overwriteTabs && + winData.tabs.length == 1 && + (!winData.tabs[0].entries || !winData.tabs[0].entries.length) + ) { + winData.tabs = []; + } + + // See SessionStoreInternal.restoreTabs for a description of what + // selectTab represents. + let selectTab = 0; + if (overwriteTabs) { + selectTab = parseInt(winData.selected || 1, 10); + selectTab = Math.max(selectTab, 1); + selectTab = Math.min(selectTab, winData.tabs.length); + } + + let tabbrowser = aWindow.gBrowser; + + // disable smooth scrolling while adding, moving, removing and selecting tabs + let arrowScrollbox = tabbrowser.tabContainer.arrowScrollbox; + let smoothScroll = arrowScrollbox.smoothScroll; + arrowScrollbox.smoothScroll = false; + + // We need to keep track of the initially open tabs so that they + // can be moved to the end of the restored tabs. + let initialTabs; + if (!overwriteTabs && firstWindow) { + initialTabs = Array.from(tabbrowser.tabs); + } + + // Get rid of tabs that aren't needed anymore. + if (overwriteTabs) { + for (let i = tabbrowser.browsers.length - 1; i >= 0; i--) { + if (!tabbrowser.tabs[i].selected) { + tabbrowser.removeTab(tabbrowser.tabs[i]); + } + } + } + + let restoreTabsLazily = + this._prefBranch.getBoolPref("sessionstore.restore_tabs_lazily") && + this._restore_on_demand; + + if (winData.tabs.length) { + var tabs = tabbrowser.addMultipleTabs( + restoreTabsLazily, + selectTab, + winData.tabs + ); + } + + // Move the originally open tabs to the end. + if (initialTabs) { + let endPosition = tabbrowser.tabs.length - 1; + for (let i = 0; i < initialTabs.length; i++) { + tabbrowser.unpinTab(initialTabs[i]); + tabbrowser.moveTabTo(initialTabs[i], endPosition); + } + } + + // We want to correlate the window with data from the last session, so + // assign another id if we have one. Otherwise clear so we don't do + // anything with it. + delete aWindow.__SS_lastSessionWindowID; + if (winData.__lastSessionWindowID) { + aWindow.__SS_lastSessionWindowID = winData.__lastSessionWindowID; + } + + if (overwriteTabs) { + delete this._windows[aWindow.__SSi].extData; + } + + // Restore cookies from legacy sessions, i.e. before bug 912717. + lazy.SessionCookies.restore(winData.cookies || []); + + if (winData.extData) { + if (!this._windows[aWindow.__SSi].extData) { + this._windows[aWindow.__SSi].extData = {}; + } + for (var key in winData.extData) { + this._windows[aWindow.__SSi].extData[key] = winData.extData[key]; + } + } + + let newClosedTabsData = winData._closedTabs || []; + newClosedTabsData = this._resetClosedIds(newClosedTabsData); + + let newLastClosedTabGroupCount = winData._lastClosedTabGroupCount || -1; + + if (overwriteTabs || firstWindow) { + // Overwrite existing closed tabs data when overwriteTabs=true + // or we're the first window to be restored. + this._windows[aWindow.__SSi]._closedTabs = newClosedTabsData; + } else if (this._max_tabs_undo > 0) { + // If we merge tabs, we also want to merge closed tabs data. We'll assume + // the restored tabs were closed more recently and append the current list + // of closed tabs to the new one... + newClosedTabsData = newClosedTabsData.concat( + this._windows[aWindow.__SSi]._closedTabs + ); + + // ... and make sure that we don't exceed the max number of closed tabs + // we can restore. + this._windows[aWindow.__SSi]._closedTabs = newClosedTabsData.slice( + 0, + this._max_tabs_undo + ); + } + // Because newClosedTabsData are put in first, we need to + // copy also the _lastClosedTabGroupCount. + this._windows[ + aWindow.__SSi + ]._lastClosedTabGroupCount = newLastClosedTabGroupCount; + + if (!this._isWindowLoaded(aWindow)) { + // from now on, the data will come from the actual window + delete this._statesToRestore[WINDOW_RESTORE_IDS.get(aWindow)]; + WINDOW_RESTORE_IDS.delete(aWindow); + delete this._windows[aWindow.__SSi]._restoring; + } + + // Restore tabs, if any. + if (winData.tabs.length) { + this.restoreTabs(aWindow, tabs, winData.tabs, selectTab); + } + + // set smoothScroll back to the original value + arrowScrollbox.smoothScroll = smoothScroll; + + TelemetryStopwatch.finish("FX_SESSION_RESTORE_RESTORE_WINDOW_MS"); + + this._setWindowStateReady(aWindow); + + this._sendWindowRestoredNotification(aWindow); + + Services.obs.notifyObservers(aWindow, NOTIFY_SINGLE_WINDOW_RESTORED); + + this._sendRestoreCompletedNotifications(); + }, + + /** + * Prepare connection to host beforehand. + * + * @param tab + * Tab we are loading from. + * @param url + * URL of a host. + * @returns a flag indicates whether a connection has been made + */ + prepareConnectionToHost(tab, url) { + if (url && !url.startsWith("about:")) { + let principal = Services.scriptSecurityManager.createNullPrincipal({ + userContextId: tab.userContextId, + }); + let sc = Services.io.QueryInterface(Ci.nsISpeculativeConnect); + let uri = Services.io.newURI(url); + try { + sc.speculativeConnect(uri, principal, null); + return true; + } catch (error) { + // Can't setup speculative connection for this url. + Cu.reportError(error); + return false; + } + } + return false; + }, + + /** + * Make a connection to a host when users hover mouse on a tab. + * This will also set a flag in the tab to prevent us from speculatively + * connecting a second time. + * + * @param tab + * a tab to speculatively connect on mouse hover. + */ + speculativeConnectOnTabHover(tab) { + let tabState = TAB_LAZY_STATES.get(tab); + if (tabState && !tabState.connectionPrepared) { + let url = this.getLazyTabValue(tab, "url"); + let prepared = this.prepareConnectionToHost(tab, url); + // This is used to test if a connection has been made beforehand. + if (gDebuggingEnabled) { + tab.__test_connection_prepared = prepared; + tab.__test_connection_url = url; + } + // A flag indicate that we've prepared a connection for this tab and + // if is called again, we shouldn't prepare another connection. + tabState.connectionPrepared = true; + } + }, + + /** + * This function will restore window features and then retore window data. + * + * @param windows + * ordered array of windows to restore + */ + _restoreWindowsFeaturesAndTabs(windows) { + // First, we restore window features, so that when users start interacting + // with a window, we don't steal the window focus. + for (let window of windows) { + let state = this._statesToRestore[WINDOW_RESTORE_IDS.get(window)]; + this.restoreWindowFeatures(window, state.windows[0]); + } + + // Then we restore data into windows. + for (let window of windows) { + let state = this._statesToRestore[WINDOW_RESTORE_IDS.get(window)]; + this.restoreWindow( + window, + state.windows[0], + state.options || { overwriteTabs: true } + ); + WINDOW_RESTORE_ZINDICES.delete(window); + } + }, + + /** + * This function will restore window in reversed z-index, so that users will + * be presented with most recently used window first. + * + * @param windows + * unordered array of windows to restore + */ + _restoreWindowsInReversedZOrder(windows) { + windows.sort( + (a, b) => + (WINDOW_RESTORE_ZINDICES.get(a) || 0) - + (WINDOW_RESTORE_ZINDICES.get(b) || 0) + ); + + this.windowToFocus = windows[0]; + this._restoreWindowsFeaturesAndTabs(windows); + }, + + /** + * Restore multiple windows using the provided state. + * @param aWindow + * Window reference to the first window to use for restoration. + * Additionally required windows will be opened. + * @param aState + * JS object or JSON string + * @param aOptions + * {overwriteTabs: true} to overwrite existing tabs w/ new ones + * {firstWindow: true} if this is the first non-private window we're + * restoring in this session, that might open an + * external link as well + */ + restoreWindows: function ssi_restoreWindows(aWindow, aState, aOptions = {}) { + // initialize window if necessary + if (aWindow && (!aWindow.__SSi || !this._windows[aWindow.__SSi])) { + this.onLoad(aWindow); + } + + let root; + try { + root = typeof aState == "string" ? JSON.parse(aState) : aState; + } catch (ex) { + // invalid state object - don't restore anything + this._log.error(ex); + this._sendRestoreCompletedNotifications(); + return; + } + + // Restore closed windows if any. + if (root._closedWindows) { + this._closedWindows = root._closedWindows; + this._closedObjectsChanged = true; + } + + // We're done here if there are no windows. + if (!root.windows || !root.windows.length) { + this._sendRestoreCompletedNotifications(); + return; + } + + let firstWindowData = root.windows.splice(0, 1); + // Store the restore state and restore option of the current window, + // so that the window can be restored in reversed z-order. + this._updateWindowRestoreState(aWindow, { + windows: firstWindowData, + options: aOptions, + }); + + // Begin the restoration: First open all windows in creation order. After all + // windows have opened, we restore states to windows in reversed z-order. + this._openWindows(root).then(windows => { + // We want to add current window to opened window, so that this window will be + // restored in reversed z-order. (We add the window to first position, in case + // no z-indices are found, that window will be restored first.) + windows.unshift(aWindow); + + this._restoreWindowsInReversedZOrder(windows); + }); + + lazy.DevToolsShim.restoreDevToolsSession(aState); + }, + + /** + * Manage history restoration for a window + * @param aWindow + * Window to restore the tabs into + * @param aTabs + * Array of tab references + * @param aTabData + * Array of tab data + * @param aSelectTab + * Index of the tab to select. This is a 1-based index where "1" + * indicates the first tab should be selected, and "0" indicates that + * the currently selected tab will not be changed. + */ + restoreTabs(aWindow, aTabs, aTabData, aSelectTab) { + var tabbrowser = aWindow.gBrowser; + + let numTabsToRestore = aTabs.length; + let numTabsInWindow = tabbrowser.tabs.length; + let tabsDataArray = this._windows[aWindow.__SSi].tabs; + + // Update the window state in case we shut down without being notified. + // Individual tab states will be taken care of by restoreTab() below. + if (numTabsInWindow == numTabsToRestore) { + // Remove all previous tab data. + tabsDataArray.length = 0; + } else { + // Remove all previous tab data except tabs that should not be overriden. + tabsDataArray.splice(numTabsInWindow - numTabsToRestore); + } + + // Let the tab data array have the right number of slots. + tabsDataArray.length = numTabsInWindow; + + if (aSelectTab > 0 && aSelectTab <= aTabs.length) { + // Update the window state in case we shut down without being notified. + this._windows[aWindow.__SSi].selected = aSelectTab; + } + + // If we restore the selected tab, make sure it goes first. + let selectedIndex = aTabs.indexOf(tabbrowser.selectedTab); + if (selectedIndex > -1) { + this.restoreTab(tabbrowser.selectedTab, aTabData[selectedIndex]); + } + + // Restore all tabs. + for (let t = 0; t < aTabs.length; t++) { + if (t != selectedIndex) { + this.restoreTab(aTabs[t], aTabData[t]); + } + } + }, + + // Restores the given tab state for a given tab. + restoreTab(tab, tabData, options = {}) { + let browser = tab.linkedBrowser; + + if (TAB_STATE_FOR_BROWSER.has(browser)) { + Cu.reportError("Must reset tab before calling restoreTab."); + return; + } + + let loadArguments = options.loadArguments; + let window = tab.ownerGlobal; + let tabbrowser = window.gBrowser; + let forceOnDemand = options.forceOnDemand; + let isRemotenessUpdate = options.isRemotenessUpdate; + + let willRestoreImmediately = + options.restoreImmediately || tabbrowser.selectedBrowser == browser; + + let isBrowserInserted = browser.isConnected; + + // Increase the busy state counter before modifying the tab. + this._setWindowStateBusy(window); + + // It's important to set the window state to dirty so that + // we collect their data for the first time when saving state. + DirtyWindows.add(window); + + // In case we didn't collect/receive data for any tabs yet we'll have to + // fill the array with at least empty tabData objects until |_tPos| or + // we'll end up with |null| entries. + for (let otherTab of Array.prototype.slice.call( + tabbrowser.tabs, + 0, + tab._tPos + )) { + let emptyState = { entries: [], lastAccessed: otherTab.lastAccessed }; + this._windows[window.__SSi].tabs.push(emptyState); + } + + // Update the tab state in case we shut down without being notified. + this._windows[window.__SSi].tabs[tab._tPos] = tabData; + + // Prepare the tab so that it can be properly restored. We'll also attach + // a copy of the tab's data in case we close it before it's been restored. + // Anything that dispatches an event to external consumers must happen at + // the end of this method, to make sure that the tab/browser object is in a + // reliable and consistent state. + + if (tabData.lastAccessed) { + tab.updateLastAccessed(tabData.lastAccessed); + } + + if ("attributes" in tabData) { + // Ensure that we persist tab attributes restored from previous sessions. + Object.keys(tabData.attributes).forEach(a => + lazy.TabAttributes.persist(a) + ); + } + + if (!tabData.entries) { + tabData.entries = []; + } + if (tabData.extData) { + TAB_CUSTOM_VALUES.set(tab, Cu.cloneInto(tabData.extData, {})); + } else { + TAB_CUSTOM_VALUES.delete(tab); + } + + // Tab is now open. + delete tabData.closedAt; + + // Ensure the index is in bounds. + let activeIndex = (tabData.index || tabData.entries.length) - 1; + activeIndex = Math.min(activeIndex, tabData.entries.length - 1); + activeIndex = Math.max(activeIndex, 0); + + // Save the index in case we updated it above. + tabData.index = activeIndex + 1; + + tab.setAttribute("pending", "true"); + + // If we're restoring this tab, it certainly shouldn't be in + // the ignored set anymore. + this._crashedBrowsers.delete(browser.permanentKey); + + // If we're in the midst of performing a process flip, then we must + // have initiated a navigation. This means that these userTyped* + // values are now out of date. + if ( + options.restoreContentReason == + RESTORE_TAB_CONTENT_REASON.NAVIGATE_AND_RESTORE + ) { + delete tabData.userTypedValue; + delete tabData.userTypedClear; + } + + // Update the persistent tab state cache with |tabData| information. + lazy.TabStateCache.update(browser.permanentKey, { + // NOTE: Copy the entries array shallowly, so as to not screw with the + // original tabData's history when getting history updates. + history: { entries: [...tabData.entries], index: tabData.index }, + scroll: tabData.scroll || null, + storage: tabData.storage || null, + formdata: tabData.formdata || null, + disallow: tabData.disallow || null, + userContextId: tabData.userContextId || 0, + + // This information is only needed until the tab has finished restoring. + // When that's done it will be removed from the cache and we always + // collect it in TabState._collectBaseTabData(). + image: tabData.image || "", + iconLoadingPrincipal: tabData.iconLoadingPrincipal || null, + searchMode: tabData.searchMode || null, + userTypedValue: tabData.userTypedValue || "", + userTypedClear: tabData.userTypedClear || 0, + }); + + // Restore tab attributes. + if ("attributes" in tabData) { + lazy.TabAttributes.set(tab, tabData.attributes); + } + + if (isBrowserInserted) { + // Start a new epoch to discard all frame script messages relating to a + // previous epoch. All async messages that are still on their way to chrome + // will be ignored and don't override any tab data set when restoring. + let epoch = this.startNextEpoch(browser.permanentKey); + + // Ensure that the tab will get properly restored in the event the tab + // crashes while restoring. But don't set this on lazy browsers as + // restoreTab will get called again when the browser is instantiated. + TAB_STATE_FOR_BROWSER.set(browser, TAB_STATE_NEEDS_RESTORE); + + this._sendRestoreHistory(browser, { + tabData, + epoch, + loadArguments, + isRemotenessUpdate, + }); + + // This could cause us to ignore MAX_CONCURRENT_TAB_RESTORES a bit, but + // it ensures each window will have its selected tab loaded. + if (willRestoreImmediately) { + this.restoreTabContent(tab, options); + } else if (!forceOnDemand) { + TabRestoreQueue.add(tab); + // Check if a tab is in queue and will be restored + // after the currently loading tabs. If so, prepare + // a connection to host to speed up page loading. + if (TabRestoreQueue.willRestoreSoon(tab)) { + if (activeIndex in tabData.entries) { + let url = tabData.entries[activeIndex].url; + let prepared = this.prepareConnectionToHost(tab, url); + if (gDebuggingEnabled) { + tab.__test_connection_prepared = prepared; + tab.__test_connection_url = url; + } + } + } + this.restoreNextTab(); + } + } else { + // TAB_LAZY_STATES holds data for lazy-browser tabs to proxy for + // data unobtainable from the unbound browser. This only applies to lazy + // browsers and will be removed once the browser is inserted in the document. + // This must preceed `updateTabLabelAndIcon` call for required data to be present. + let url = "about:blank"; + let title = ""; + + if (activeIndex in tabData.entries) { + url = tabData.entries[activeIndex].url; + title = tabData.entries[activeIndex].title || url; + } + TAB_LAZY_STATES.set(tab, { + url, + title, + userTypedValue: tabData.userTypedValue || "", + userTypedClear: tabData.userTypedClear || 0, + }); + } + + // Most of tabData has been restored, now continue with restoring + // attributes that may trigger external events. + + if (tabData.pinned) { + tabbrowser.pinTab(tab); + } else { + tabbrowser.unpinTab(tab); + } + + if (tabData.hidden) { + tabbrowser.hideTab(tab); + } else { + tabbrowser.showTab(tab); + } + + if (!!tabData.muted != browser.audioMuted) { + tab.toggleMuteAudio(tabData.muteReason); + } + + if (tab.hasAttribute("customizemode")) { + window.gCustomizeMode.setTab(tab); + } + + // Update tab label and icon to show something + // while we wait for the messages to be processed. + this.updateTabLabelAndIcon(tab, tabData); + + // Decrease the busy state counter after we're done. + this._setWindowStateReady(window); + }, + + /** + * Kicks off restoring the given tab. + * + * @param aTab + * the tab to restore + * @param aOptions + * optional arguments used when performing process switch during load + */ + restoreTabContent(aTab, aOptions = {}) { + let loadArguments = aOptions.loadArguments; + if (aTab.hasAttribute("customizemode") && !loadArguments) { + return; + } + + let browser = aTab.linkedBrowser; + let window = aTab.ownerGlobal; + let tabbrowser = window.gBrowser; + let tabData = lazy.TabState.clone(aTab, TAB_CUSTOM_VALUES.get(aTab)); + let activeIndex = tabData.index - 1; + let activePageData = tabData.entries[activeIndex] || null; + let uri = activePageData ? activePageData.url || null : null; + + this.markTabAsRestoring(aTab); + + let isRemotenessUpdate = aOptions.isRemotenessUpdate; + let explicitlyUpdateRemoteness = !Services.appinfo.sessionHistoryInParent; + // If we aren't already updating the browser's remoteness, check if it's + // necessary. + if (explicitlyUpdateRemoteness && !isRemotenessUpdate) { + isRemotenessUpdate = tabbrowser.updateBrowserRemotenessByURL( + browser, + uri + ); + + if (isRemotenessUpdate) { + // We updated the remoteness, so we need to send the history down again. + // + // Start a new epoch to discard all frame script messages relating to a + // previous epoch. All async messages that are still on their way to chrome + // will be ignored and don't override any tab data set when restoring. + let epoch = this.startNextEpoch(browser.permanentKey); + + this._sendRestoreHistory(browser, { + tabData, + epoch, + loadArguments, + isRemotenessUpdate, + }); + } + } + + this._sendRestoreTabContent(browser, { + loadArguments, + isRemotenessUpdate, + reason: + aOptions.restoreContentReason || RESTORE_TAB_CONTENT_REASON.SET_STATE, + }); + + // Focus the tab's content area, unless the restore is for a new tab URL or + // was triggered by a DocumentChannel process switch. + if ( + aTab.selected && + !window.isBlankPageURL(uri) && + !aOptions.isRemotenessUpdate + ) { + browser.focus(); + } + }, + + /** + * Marks a given pending tab as restoring. + * + * @param aTab + * the pending tab to mark as restoring + */ + markTabAsRestoring(aTab) { + let browser = aTab.linkedBrowser; + if (TAB_STATE_FOR_BROWSER.get(browser) != TAB_STATE_NEEDS_RESTORE) { + throw new Error("Given tab is not pending."); + } + + // Make sure that this tab is removed from the priority queue. + TabRestoreQueue.remove(aTab); + + // Increase our internal count. + this._tabsRestoringCount++; + + // Set this tab's state to restoring + TAB_STATE_FOR_BROWSER.set(browser, TAB_STATE_RESTORING); + aTab.removeAttribute("pending"); + }, + + /** + * This _attempts_ to restore the next available tab. If the restore fails, + * then we will attempt the next one. + * There are conditions where this won't do anything: + * if we're in the process of quitting + * if there are no tabs to restore + * if we have already reached the limit for number of tabs to restore + */ + restoreNextTab: function ssi_restoreNextTab() { + // If we call in here while quitting, we don't actually want to do anything + if (lazy.RunState.isQuitting) { + return; + } + + // Don't exceed the maximum number of concurrent tab restores. + if (this._tabsRestoringCount >= MAX_CONCURRENT_TAB_RESTORES) { + return; + } + + let tab = TabRestoreQueue.shift(); + if (tab) { + this.restoreTabContent(tab); + } + }, + + /** + * Restore visibility and dimension features to a window + * @param aWindow + * Window reference + * @param aWinData + * Object containing session data for the window + */ + restoreWindowFeatures: function ssi_restoreWindowFeatures(aWindow, aWinData) { + var hidden = aWinData.hidden ? aWinData.hidden.split(",") : []; + WINDOW_HIDEABLE_FEATURES.forEach(function(aItem) { + aWindow[aItem].visible = !hidden.includes(aItem); + }); + + if (aWinData.isPopup) { + this._windows[aWindow.__SSi].isPopup = true; + if (aWindow.gURLBar) { + aWindow.gURLBar.readOnly = true; + } + } else { + delete this._windows[aWindow.__SSi].isPopup; + if (aWindow.gURLBar) { + aWindow.gURLBar.readOnly = false; + } + } + + aWindow.setTimeout(() => { + this.restoreDimensions( + aWindow, + +(aWinData.width || 0), + +(aWinData.height || 0), + "screenX" in aWinData ? +aWinData.screenX : NaN, + "screenY" in aWinData ? +aWinData.screenY : NaN, + aWinData.sizemode || "", + aWinData.sizemodeBeforeMinimized || "", + aWinData.sidebar || "" + ); + }, 0); + }, + + /** + * Restore a window's dimensions + * @param aWidth + * Window width in desktop pixels + * @param aHeight + * Window height in desktop pixels + * @param aLeft + * Window left in desktop pixels + * @param aTop + * Window top in desktop pixels + * @param aSizeMode + * Window size mode (eg: maximized) + * @param aSizeModeBeforeMinimized + * Window size mode before window got minimized (eg: maximized) + * @param aSidebar + * Sidebar command + */ + restoreDimensions: function ssi_restoreDimensions( + aWindow, + aWidth, + aHeight, + aLeft, + aTop, + aSizeMode, + aSizeModeBeforeMinimized, + aSidebar + ) { + var win = aWindow; + var _this = this; + function win_(aName) { + return _this._getWindowDimension(win, aName); + } + + const dwu = win.windowUtils; + // find available space on the screen where this window is being placed + let screen = lazy.gScreenManager.screenForRect( + aLeft, + aTop, + aWidth, + aHeight + ); + if (screen) { + let screenLeft = {}, + screenTop = {}, + screenWidth = {}, + screenHeight = {}; + screen.GetAvailRectDisplayPix( + screenLeft, + screenTop, + screenWidth, + screenHeight + ); + + // We store aLeft / aTop (screenX/Y) in desktop pixels, see + // _getWindowDimension. + screenLeft = screenLeft.value; + screenTop = screenTop.value; + screenWidth = screenWidth.value; + screenHeight = screenHeight.value; + + let screenBottom = screenTop + screenHeight; + let screenRight = screenLeft + screenWidth; + + // NOTE: contentsScaleFactor is the desktopToDeviceScale of the screen. + // Naming could be more consistent here. + let cssToDesktopScale = + screen.defaultCSSScaleFactor / screen.contentsScaleFactor; + + let slop = SCREEN_EDGE_SLOP * cssToDesktopScale; + + // Pull the window within the screen's bounds (allowing a little slop + // for windows that may be deliberately placed with their border off-screen + // as when Win10 "snaps" a window to the left/right edge -- bug 1276516). + // First, ensure the left edge is large enough... + if (aLeft < screenLeft - slop) { + aLeft = screenLeft; + } + // Then check the resulting right edge, and reduce it if necessary. + let right = aLeft + aWidth * cssToDesktopScale; + if (right > screenRight + slop) { + right = screenRight; + // See if we can move the left edge leftwards to maintain width. + if (aLeft > screenLeft) { + aLeft = Math.max(right - aWidth * cssToDesktopScale, screenLeft); + } + } + // Finally, update aWidth to account for the adjusted left and right + // edges, and convert it back to CSS pixels on the target screen. + aWidth = (right - aLeft) / cssToDesktopScale; + + // And do the same in the vertical dimension. + if (aTop < screenTop - slop) { + aTop = screenTop; + } + let bottom = aTop + aHeight * cssToDesktopScale; + if (bottom > screenBottom + slop) { + bottom = screenBottom; + if (aTop > screenTop) { + aTop = Math.max(bottom - aHeight * cssToDesktopScale, screenTop); + } + } + aHeight = (bottom - aTop) / cssToDesktopScale; + } + + // Suppress animations. + dwu.suppressAnimation(true); + + // We want to make sure users will get their animations back in case an exception is thrown. + try { + // only modify those aspects which aren't correct yet + if ( + !isNaN(aLeft) && + !isNaN(aTop) && + (aLeft != win_("screenX") || aTop != win_("screenY")) + ) { + // moveTo uses CSS pixels relative to aWindow, while aLeft and aRight + // are on desktop pixels, undo the conversion we do in + // _getWindowDimension. + let desktopToCssScale = + aWindow.desktopToDeviceScale / aWindow.devicePixelRatio; + aWindow.moveTo(aLeft * desktopToCssScale, aTop * desktopToCssScale); + } + if ( + aWidth && + aHeight && + (aWidth != win_("width") || aHeight != win_("height")) && + !gResistFingerprintingEnabled + ) { + // Don't resize the window if it's currently maximized and we would + // maximize it again shortly after. + if (aSizeMode != "maximized" || win_("sizemode") != "maximized") { + aWindow.resizeTo(aWidth, aHeight); + } + } + this._windows[ + aWindow.__SSi + ].sizemodeBeforeMinimized = aSizeModeBeforeMinimized; + if ( + aSizeMode && + win_("sizemode") != aSizeMode && + !gResistFingerprintingEnabled + ) { + switch (aSizeMode) { + case "maximized": + aWindow.maximize(); + break; + case "minimized": + if (aSizeModeBeforeMinimized == "maximized") { + aWindow.maximize(); + } + aWindow.minimize(); + break; + case "normal": + aWindow.restore(); + break; + } + } + let sidebarBox = aWindow.document.getElementById("sidebar-box"); + if ( + aSidebar && + (sidebarBox.getAttribute("sidebarcommand") != aSidebar || + !sidebarBox.getAttribute("checked")) + ) { + aWindow.SidebarUI.showInitially(aSidebar); + } + // since resizing/moving a window brings it to the foreground, + // we might want to re-focus the last focused window + if (this.windowToFocus) { + this.windowToFocus.focus(); + } + } finally { + // Enable animations. + dwu.suppressAnimation(false); + } + }, + + /* ........ Disk Access .............. */ + + /** + * Save the current session state to disk, after a delay. + * + * @param aWindow (optional) + * Will mark the given window as dirty so that we will recollect its + * data before we start writing. + */ + saveStateDelayed(aWindow = null) { + if (aWindow) { + DirtyWindows.add(aWindow); + } + + lazy.SessionSaver.runDelayed(); + }, + + /* ........ Auxiliary Functions .............. */ + + /** + * Remove a closed window from the list of closed windows and indicate that + * the change should be notified. + * + * @param index + * The index of the window in this._closedWindows. + * + * @returns Array of closed windows. + */ + _removeClosedWindow(index) { + let windows = this._closedWindows.splice(index, 1); + this._closedObjectsChanged = true; + return windows; + }, + + /** + * Notifies observers that the list of closed tabs and/or windows has changed. + * Waits a tick to allow SessionStorage a chance to register the change. + */ + _notifyOfClosedObjectsChange() { + if (!this._closedObjectsChanged) { + return; + } + this._closedObjectsChanged = false; + lazy.setTimeout(() => { + Services.obs.notifyObservers(null, NOTIFY_CLOSED_OBJECTS_CHANGED); + }, 0); + }, + + /** + * Update the session start time and send a telemetry measurement + * for the number of days elapsed since the session was started. + * + * @param state + * The session state. + */ + _updateSessionStartTime: function ssi_updateSessionStartTime(state) { + // Attempt to load the session start time from the session state + if (state.session && state.session.startTime) { + this._sessionStartTime = state.session.startTime; + } + }, + + /** + * Iterator that yields all currently opened browser windows. + * (Might miss the most recent one.) + * This list is in focus order, but may include minimized windows + * before non-minimized windows. + */ + _browserWindows: { + *[Symbol.iterator]() { + for (let window of lazy.BrowserWindowTracker.orderedWindows) { + if (window.__SSi && !window.closed) { + yield window; + } + } + }, + }, + + /** + * Iterator that yields all currently opened browser windows, + * with minimized windows last. + * (Might miss the most recent window.) + */ + _orderedBrowserWindows: { + *[Symbol.iterator]() { + let windows = lazy.BrowserWindowTracker.orderedWindows; + windows.sort((a, b) => { + if ( + a.windowState == a.STATE_MINIMIZED && + b.windowState != b.STATE_MINIMIZED + ) { + return 1; + } + if ( + a.windowState != a.STATE_MINIMIZED && + b.windowState == b.STATE_MINIMIZED + ) { + return -1; + } + return 0; + }); + for (let window of windows) { + if (window.__SSi && !window.closed) { + yield window; + } + } + }, + }, + + /** + * Returns most recent window + * @returns Window reference + */ + _getTopWindow: function ssi_getTopWindow() { + return lazy.BrowserWindowTracker.getTopWindow({ allowPopups: true }); + }, + + /** + * Calls onClose for windows that are determined to be closed but aren't + * destroyed yet, which would otherwise cause getBrowserState and + * setBrowserState to treat them as open windows. + */ + _handleClosedWindows: function ssi_handleClosedWindows() { + let promises = []; + for (let window of Services.wm.getEnumerator("navigator:browser")) { + if (window.closed) { + promises.push(this.onClose(window)); + } + } + return Promise.all(promises); + }, + + /** + * Store a restore state of a window to this._statesToRestore. The window + * will be given an id that can be used to get the restore state from + * this._statesToRestore. + * + * @param window + * a reference to a window that has a state to restore + * @param state + * an object containing session data + */ + _updateWindowRestoreState(window, state) { + // Store z-index, so that windows can be restored in reversed z-order. + if ("zIndex" in state.windows[0]) { + WINDOW_RESTORE_ZINDICES.set(window, state.windows[0].zIndex); + } + do { + var ID = "window" + Math.random(); + } while (ID in this._statesToRestore); + WINDOW_RESTORE_IDS.set(window, ID); + this._statesToRestore[ID] = state; + }, + + /** + * open a new browser window for a given session state + * called when restoring a multi-window session + * @param aState + * Object containing session data + */ + _openWindowWithState: function ssi_openWindowWithState(aState) { + var argString = Cc["@mozilla.org/supports-string;1"].createInstance( + Ci.nsISupportsString + ); + argString.data = ""; + + // Build feature string + let features; + let winState = aState.windows[0]; + if (winState.chromeFlags) { + features = ["chrome", "suppressanimation"]; + let chromeFlags = winState.chromeFlags; + const allFlags = Ci.nsIWebBrowserChrome.CHROME_ALL; + const hasAll = (chromeFlags & allFlags) == allFlags; + if (hasAll) { + features.push("all"); + } + for (let [flag, onValue, offValue] of CHROME_FLAGS_MAP) { + if (hasAll && allFlags & flag) { + continue; + } + let value = chromeFlags & flag ? onValue : offValue; + if (value) { + features.push(value); + } + } + } else { + // |chromeFlags| is not found. Fallbacks to the old method. + features = ["chrome", "dialog=no", "suppressanimation"]; + let hidden = winState.hidden?.split(",") || []; + if (!hidden.length) { + features.push("all"); + } else { + features.push("resizable"); + WINDOW_HIDEABLE_FEATURES.forEach(aFeature => { + if (!hidden.includes(aFeature)) { + features.push(WINDOW_OPEN_FEATURES_MAP[aFeature] || aFeature); + } + }); + } + } + WINDOW_ATTRIBUTES.forEach(aFeature => { + // Use !isNaN as an easy way to ignore sizemode and check for numbers + if (aFeature in winState && !isNaN(winState[aFeature])) { + features.push(aFeature + "=" + winState[aFeature]); + } + }); + + if (winState.isPrivate) { + features.push("private"); + } + + var window = Services.ww.openWindow( + null, + AppConstants.BROWSER_CHROME_URL, + "_blank", + features.join(","), + argString + ); + + this._updateWindowRestoreState(window, aState); + WINDOW_SHOWING_PROMISES.set(window, lazy.PromiseUtils.defer()); + + return window; + }, + + /** + * whether the user wants to load any other page at startup + * (except the homepage) - needed for determining whether to overwrite the current tabs + * C.f.: nsBrowserContentHandler's defaultArgs implementation. + * @returns bool + */ + _isCmdLineEmpty: function ssi_isCmdLineEmpty(aWindow, aState) { + var pinnedOnly = + aState.windows && + aState.windows.every(win => win.tabs.every(tab => tab.pinned)); + + let hasFirstArgument = aWindow.arguments && aWindow.arguments[0]; + if (!pinnedOnly) { + let defaultArgs = Cc["@mozilla.org/browser/clh;1"].getService( + Ci.nsIBrowserHandler + ).defaultArgs; + if ( + aWindow.arguments && + aWindow.arguments[0] && + aWindow.arguments[0] == defaultArgs + ) { + hasFirstArgument = false; + } + } + + return !hasFirstArgument; + }, + + /** + * on popup windows, the AppWindow's attributes seem not to be set correctly + * we use thus JSDOMWindow attributes for sizemode and normal window attributes + * (and hope for reasonable values when maximized/minimized - since then + * outerWidth/outerHeight aren't the dimensions of the restored window) + * @param aWindow + * Window reference + * @param aAttribute + * String sizemode | width | height | other window attribute + * @returns string + */ + _getWindowDimension: function ssi_getWindowDimension(aWindow, aAttribute) { + if (aAttribute == "sizemode") { + switch (aWindow.windowState) { + case aWindow.STATE_FULLSCREEN: + case aWindow.STATE_MAXIMIZED: + return "maximized"; + case aWindow.STATE_MINIMIZED: + return "minimized"; + default: + return "normal"; + } + } + + // We want to persist the size / position in normal state, so that + // we can restore to them even if the window is currently maximized + // or minimized. However, attributes on window object only reflect + // the current state of the window, so when it isn't in the normal + // sizemode, their values aren't what we want the window to restore + // to. In that case, try to read from the attributes of the root + // element first instead. + if (aWindow.windowState != aWindow.STATE_NORMAL) { + let docElem = aWindow.document.documentElement; + let attr = parseInt(docElem.getAttribute(aAttribute), 10); + if (attr) { + if (aAttribute != "width" && aAttribute != "height") { + return attr; + } + // Width and height attribute report the inner size, but we want + // to store the outer size, so add the difference. + let appWin = aWindow.docShell.treeOwner + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIAppWindow); + let diff = + aAttribute == "width" + ? appWin.outerToInnerWidthDifferenceInCSSPixels + : appWin.outerToInnerHeightDifferenceInCSSPixels; + return attr + diff; + } + } + + switch (aAttribute) { + case "width": + return aWindow.outerWidth; + case "height": + return aWindow.outerHeight; + case "screenX": + case "screenY": + // We use desktop pixels rather than CSS pixels to store window + // positions, see bug 1247335. This allows proper multi-monitor + // positioning in mixed-DPI situations. + // screenX/Y are in CSS pixels for the current window, so, convert them + // to desktop pixels. + return ( + (aWindow[aAttribute] * aWindow.devicePixelRatio) / + aWindow.desktopToDeviceScale + ); + default: + return aAttribute in aWindow ? aWindow[aAttribute] : ""; + } + }, + + /** + * @param aState is a session state + * @param aRecentCrashes is the number of consecutive crashes + * @returns whether a restore page will be needed for the session state + */ + _needsRestorePage: function ssi_needsRestorePage(aState, aRecentCrashes) { + const SIX_HOURS_IN_MS = 6 * 60 * 60 * 1000; + + // don't display the page when there's nothing to restore + let winData = aState.windows || null; + if (!winData || !winData.length) { + return false; + } + + // don't wrap a single about:sessionrestore page + if ( + this._hasSingleTabWithURL(winData, "about:sessionrestore") || + this._hasSingleTabWithURL(winData, "about:welcomeback") + ) { + return false; + } + + // don't automatically restore in Safe Mode + if (Services.appinfo.inSafeMode) { + return true; + } + + let max_resumed_crashes = this._prefBranch.getIntPref( + "sessionstore.max_resumed_crashes" + ); + let sessionAge = + aState.session && + aState.session.lastUpdate && + Date.now() - aState.session.lastUpdate; + + let decision = + max_resumed_crashes != -1 && + (aRecentCrashes > max_resumed_crashes || + (sessionAge && sessionAge >= SIX_HOURS_IN_MS)); + if (decision) { + let key; + if (aRecentCrashes > max_resumed_crashes) { + if (sessionAge && sessionAge >= SIX_HOURS_IN_MS) { + key = "shown_many_crashes_old_session"; + } else { + key = "shown_many_crashes"; + } + } else { + key = "shown_old_session"; + } + Services.telemetry.keyedScalarAdd( + "browser.engagement.sessionrestore_interstitial", + key, + 1 + ); + } + return decision; + }, + + /** + * @param aWinData is the set of windows in session state + * @param aURL is the single URL we're looking for + * @returns whether the window data contains only the single URL passed + */ + _hasSingleTabWithURL(aWinData, aURL) { + if ( + aWinData && + aWinData.length == 1 && + aWinData[0].tabs && + aWinData[0].tabs.length == 1 && + aWinData[0].tabs[0].entries && + aWinData[0].tabs[0].entries.length == 1 + ) { + return aURL == aWinData[0].tabs[0].entries[0].url; + } + return false; + }, + + /** + * Determine if the tab state we're passed is something we should save. This + * is used when closing a tab or closing a window with a single tab + * + * @param aTabState + * The current tab state + * @returns boolean + */ + _shouldSaveTabState: function ssi_shouldSaveTabState(aTabState) { + // If the tab has only a transient about: history entry, no other + // session history, and no userTypedValue, then we don't actually want to + // store this tab's data. + return ( + aTabState.entries.length && + !( + aTabState.entries.length == 1 && + (aTabState.entries[0].url == "about:blank" || + aTabState.entries[0].url == "about:newtab" || + aTabState.entries[0].url == "about:privatebrowsing") && + !aTabState.userTypedValue + ) + ); + }, + + /** + * Determine if the tab state we're passed is something we should keep to be + * reopened at session restore. This is used when we are saving the current + * session state to disk. This method is very similar to _shouldSaveTabState, + * however, "about:blank" and "about:newtab" tabs will still be saved to disk. + * + * @param aTabState + * The current tab state + * @returns boolean + */ + _shouldSaveTab: function ssi_shouldSaveTab(aTabState) { + // If the tab has one of the following transient about: history entry, no + // userTypedValue, and no customizemode attribute, then we don't actually + // want to write this tab's data to disk. + return ( + aTabState.userTypedValue || + (aTabState.attributes && aTabState.attributes.customizemode == "true") || + (aTabState.entries.length && + aTabState.entries[0].url != "about:privatebrowsing") + ); + }, + + /** + * This is going to take a state as provided at startup (via + * SessionStartup.state) and split it into 2 parts. The first part + * (defaultState) will be a state that should still be restored at startup, + * while the second part (state) is a state that should be saved for later. + * defaultState will be comprised of windows with only pinned tabs, extracted + * from state. It will also contain window position information. + * + * defaultState will be restored at startup. state will be passed into + * LastSession and will be kept in case the user explicitly wants + * to restore the previous session (publicly exposed as restoreLastSession). + * + * @param state + * The state, presumably from SessionStartup.state + * @returns [defaultState, state] + */ + _prepDataForDeferredRestore: function ssi_prepDataForDeferredRestore(state) { + // Make sure that we don't modify the global state as provided by + // SessionStartup.state. + state = Cu.cloneInto(state, {}); + + let defaultState = { windows: [], selectedWindow: 1 }; + + state.selectedWindow = state.selectedWindow || 1; + + // Look at each window, remove pinned tabs, adjust selectedindex, + // remove window if necessary. + for (let wIndex = 0; wIndex < state.windows.length; ) { + let window = state.windows[wIndex]; + window.selected = window.selected || 1; + // We're going to put the state of the window into this object + let pinnedWindowState = { tabs: [] }; + for (let tIndex = 0; tIndex < window.tabs.length; ) { + if (window.tabs[tIndex].pinned) { + // Adjust window.selected + if (tIndex + 1 < window.selected) { + window.selected -= 1; + } else if (tIndex + 1 == window.selected) { + pinnedWindowState.selected = pinnedWindowState.tabs.length + 1; + } + // + 1 because the tab isn't actually in the array yet + + // Now add the pinned tab to our window + pinnedWindowState.tabs = pinnedWindowState.tabs.concat( + window.tabs.splice(tIndex, 1) + ); + // We don't want to increment tIndex here. + continue; + } + tIndex++; + } + + // At this point the window in the state object has been modified (or not) + // We want to build the rest of this new window object if we have pinnedTabs. + if (pinnedWindowState.tabs.length) { + // First get the other attributes off the window + WINDOW_ATTRIBUTES.forEach(function(attr) { + if (attr in window) { + pinnedWindowState[attr] = window[attr]; + delete window[attr]; + } + }); + // We're just copying position data into the pinned window. + // Not copying over: + // - _closedTabs + // - extData + // - isPopup + // - hidden + + // Assign a unique ID to correlate the window to be opened with the + // remaining data + window.__lastSessionWindowID = pinnedWindowState.__lastSessionWindowID = + "" + Date.now() + Math.random(); + + // Actually add this window to our defaultState + defaultState.windows.push(pinnedWindowState); + // Remove the window from the state if it doesn't have any tabs + if (!window.tabs.length) { + if (wIndex + 1 <= state.selectedWindow) { + state.selectedWindow -= 1; + } else if (wIndex + 1 == state.selectedWindow) { + defaultState.selectedIndex = defaultState.windows.length + 1; + } + + state.windows.splice(wIndex, 1); + // We don't want to increment wIndex here. + continue; + } + } + wIndex++; + } + + return [defaultState, state]; + }, + + _sendRestoreCompletedNotifications: function ssi_sendRestoreCompletedNotifications() { + // not all windows restored, yet + if (this._restoreCount > 1) { + this._restoreCount--; + return; + } + + // observers were already notified + if (this._restoreCount == -1) { + return; + } + + // This was the last window restored at startup, notify observers. + if (!this._browserSetState) { + Services.obs.notifyObservers(null, NOTIFY_WINDOWS_RESTORED); + this._deferredAllWindowsRestored.resolve(); + } else { + // _browserSetState is used only by tests, and it uses an alternate + // notification in order not to retrigger startup observers that + // are listening for NOTIFY_WINDOWS_RESTORED. + Services.obs.notifyObservers(null, NOTIFY_BROWSER_STATE_RESTORED); + } + + this._browserSetState = false; + this._restoreCount = -1; + }, + + /** + * Set the given window's busy state + * @param aWindow the window + * @param aValue the window's busy state + */ + _setWindowStateBusyValue: function ssi_changeWindowStateBusyValue( + aWindow, + aValue + ) { + this._windows[aWindow.__SSi].busy = aValue; + + // Keep the to-be-restored state in sync because that is returned by + // getWindowState() as long as the window isn't loaded, yet. + if (!this._isWindowLoaded(aWindow)) { + let stateToRestore = this._statesToRestore[ + WINDOW_RESTORE_IDS.get(aWindow) + ].windows[0]; + stateToRestore.busy = aValue; + } + }, + + /** + * Set the given window's state to 'not busy'. + * @param aWindow the window + */ + _setWindowStateReady: function ssi_setWindowStateReady(aWindow) { + let newCount = (this._windowBusyStates.get(aWindow) || 0) - 1; + if (newCount < 0) { + throw new Error("Invalid window busy state (less than zero)."); + } + this._windowBusyStates.set(aWindow, newCount); + + if (newCount == 0) { + this._setWindowStateBusyValue(aWindow, false); + this._sendWindowStateReadyEvent(aWindow); + } + }, + + /** + * Set the given window's state to 'busy'. + * @param aWindow the window + */ + _setWindowStateBusy: function ssi_setWindowStateBusy(aWindow) { + let newCount = (this._windowBusyStates.get(aWindow) || 0) + 1; + this._windowBusyStates.set(aWindow, newCount); + + if (newCount == 1) { + this._setWindowStateBusyValue(aWindow, true); + this._sendWindowStateBusyEvent(aWindow); + } + }, + + /** + * Dispatch an SSWindowStateReady event for the given window. + * @param aWindow the window + */ + _sendWindowStateReadyEvent: function ssi_sendWindowStateReadyEvent(aWindow) { + let event = aWindow.document.createEvent("Events"); + event.initEvent("SSWindowStateReady", true, false); + aWindow.dispatchEvent(event); + }, + + /** + * Dispatch an SSWindowStateBusy event for the given window. + * @param aWindow the window + */ + _sendWindowStateBusyEvent: function ssi_sendWindowStateBusyEvent(aWindow) { + let event = aWindow.document.createEvent("Events"); + event.initEvent("SSWindowStateBusy", true, false); + aWindow.dispatchEvent(event); + }, + + /** + * Dispatch the SSWindowRestoring event for the given window. + * @param aWindow + * The window which is going to be restored + */ + _sendWindowRestoringNotification(aWindow) { + let event = aWindow.document.createEvent("Events"); + event.initEvent("SSWindowRestoring", true, false); + aWindow.dispatchEvent(event); + }, + + /** + * Dispatch the SSWindowRestored event for the given window. + * @param aWindow + * The window which has been restored + */ + _sendWindowRestoredNotification(aWindow) { + let event = aWindow.document.createEvent("Events"); + event.initEvent("SSWindowRestored", true, false); + aWindow.dispatchEvent(event); + }, + + /** + * Dispatch the SSTabRestored event for the given tab. + * @param aTab + * The tab which has been restored + * @param aIsRemotenessUpdate + * True if this tab was restored due to flip from running from + * out-of-main-process to in-main-process or vice-versa. + */ + _sendTabRestoredNotification(aTab, aIsRemotenessUpdate) { + let event = aTab.ownerDocument.createEvent("CustomEvent"); + event.initCustomEvent("SSTabRestored", true, false, { + isRemotenessUpdate: aIsRemotenessUpdate, + }); + aTab.dispatchEvent(event); + }, + + /** + * @param aWindow + * Window reference + * @returns whether this window's data is still cached in _statesToRestore + * because it's not fully loaded yet + */ + _isWindowLoaded: function ssi_isWindowLoaded(aWindow) { + return !WINDOW_RESTORE_IDS.has(aWindow); + }, + + /** + * Resize this._closedWindows to the value of the pref, except in the case + * where we don't have any non-popup windows on Windows and Linux. Then we must + * resize such that we have at least one non-popup window. + */ + _capClosedWindows: function ssi_capClosedWindows() { + if (this._closedWindows.length <= this._max_windows_undo) { + return; + } + let spliceTo = this._max_windows_undo; + if (AppConstants.platform != "macosx") { + let normalWindowIndex = 0; + // try to find a non-popup window in this._closedWindows + while ( + normalWindowIndex < this._closedWindows.length && + !!this._closedWindows[normalWindowIndex].isPopup + ) { + normalWindowIndex++; + } + if (normalWindowIndex >= this._max_windows_undo) { + spliceTo = normalWindowIndex + 1; + } + } + if (spliceTo < this._closedWindows.length) { + this._closedWindows.splice(spliceTo, this._closedWindows.length); + this._closedObjectsChanged = true; + } + }, + + /** + * Clears the set of windows that are "resurrected" before writing to disk to + * make closing windows one after the other until shutdown work as expected. + * + * This function should only be called when we are sure that there has been + * a user action that indicates the browser is actively being used and all + * windows that have been closed before are not part of a series of closing + * windows. + */ + _clearRestoringWindows: function ssi_clearRestoringWindows() { + for (let i = 0; i < this._closedWindows.length; i++) { + delete this._closedWindows[i]._shouldRestore; + } + }, + + /** + * Reset state to prepare for a new session state to be restored. + */ + _resetRestoringState: function ssi_initRestoringState() { + TabRestoreQueue.reset(); + this._tabsRestoringCount = 0; + }, + + /** + * Reset the restoring state for a particular tab. This will be called when + * removing a tab or when a tab needs to be reset (it's being overwritten). + * + * @param aTab + * The tab that will be "reset" + */ + _resetLocalTabRestoringState(aTab) { + let browser = aTab.linkedBrowser; + + // Keep the tab's previous state for later in this method + let previousState = TAB_STATE_FOR_BROWSER.get(browser); + + if (!previousState) { + Cu.reportError("Given tab is not restoring."); + return; + } + + // The browser is no longer in any sort of restoring state. + TAB_STATE_FOR_BROWSER.delete(browser); + + if (Services.appinfo.sessionHistoryInParent) { + this._restoreListeners.get(browser.permanentKey)?.unregister(); + browser.browsingContext.clearRestoreState(); + } + + aTab.removeAttribute("pending"); + + if (previousState == TAB_STATE_RESTORING) { + if (this._tabsRestoringCount) { + this._tabsRestoringCount--; + } + } else if (previousState == TAB_STATE_NEEDS_RESTORE) { + // Make sure that the tab is removed from the list of tabs to restore. + // Again, this is normally done in restoreTabContent, but that isn't being called + // for this tab. + TabRestoreQueue.remove(aTab); + } + }, + + _resetTabRestoringState(tab) { + let browser = tab.linkedBrowser; + + if (!TAB_STATE_FOR_BROWSER.has(browser)) { + Cu.reportError("Given tab is not restoring."); + return; + } + + if (!Services.appinfo.sessionHistoryInParent) { + browser.messageManager.sendAsyncMessage("SessionStore:resetRestore", {}); + } + this._resetLocalTabRestoringState(tab); + }, + + /** + * Each fresh tab starts out with epoch=0. This function can be used to + * start a next epoch by incrementing the current value. It will enables us + * to ignore stale messages sent from previous epochs. The function returns + * the new epoch ID for the given |browser|. + */ + startNextEpoch(permanentKey) { + let next = this.getCurrentEpoch(permanentKey) + 1; + this._browserEpochs.set(permanentKey, next); + return next; + }, + + /** + * Returns the current epoch for the given <browser>. If we haven't assigned + * a new epoch this will default to zero for new tabs. + */ + getCurrentEpoch(permanentKey) { + return this._browserEpochs.get(permanentKey) || 0; + }, + + /** + * Each time a <browser> element is restored, we increment its "epoch". To + * check if a message from content-sessionStore.js is out of date, we can + * compare the epoch received with the message to the <browser> element's + * epoch. This function does that, and returns true if |epoch| is up-to-date + * with respect to |browser|. + */ + isCurrentEpoch(permanentKey, epoch) { + return this.getCurrentEpoch(permanentKey) == epoch; + }, + + /** + * Resets the epoch for a given <browser>. We need to this every time we + * receive a hint that a new docShell has been loaded into the browser as + * the frame script starts out with epoch=0. + */ + resetEpoch(permanentKey, frameLoader = null) { + this._browserEpochs.delete(permanentKey); + if (frameLoader) { + frameLoader.requestEpochUpdate(0); + } + }, + + /** + * Countdown for a given duration, skipping beats if the computer is too busy, + * sleeping or otherwise unavailable. + * + * @param {number} delay An approximate delay to wait in milliseconds (rounded + * up to the closest second). + * + * @return Promise + */ + looseTimer(delay) { + let DELAY_BEAT = 1000; + let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + let beats = Math.ceil(delay / DELAY_BEAT); + let deferred = lazy.PromiseUtils.defer(); + timer.initWithCallback( + function() { + if (beats <= 0) { + deferred.resolve(); + } + --beats; + }, + DELAY_BEAT, + Ci.nsITimer.TYPE_REPEATING_PRECISE_CAN_SKIP + ); + // Ensure that the timer is both canceled once we are done with it + // and not garbage-collected until then. + deferred.promise.then( + () => timer.cancel(), + () => timer.cancel() + ); + return deferred; + }, + + /** + * Builds a single nsISessionStoreRestoreData tree for the provided |formdata| + * and |scroll| trees. + */ + buildRestoreData(formdata, scroll) { + function addFormEntries(root, fields, isXpath) { + for (let [key, value] of Object.entries(fields)) { + switch (typeof value) { + case "string": + root.addTextField(isXpath, key, value); + break; + case "boolean": + root.addCheckbox(isXpath, key, value); + break; + case "object": { + if (value === null) { + break; + } + if ( + value.hasOwnProperty("type") && + value.hasOwnProperty("fileList") + ) { + root.addFileList(isXpath, key, value.type, value.fileList); + break; + } + if ( + value.hasOwnProperty("selectedIndex") && + value.hasOwnProperty("value") + ) { + root.addSingleSelect( + isXpath, + key, + value.selectedIndex, + value.value + ); + break; + } + if ( + key === "sessionData" && + ["about:sessionrestore", "about:welcomeback"].includes( + formdata.url + ) + ) { + root.addTextField(isXpath, key, JSON.stringify(value)); + break; + } + if (Array.isArray(value)) { + root.addMultipleSelect(isXpath, key, value); + break; + } + } + } + } + } + + let root = SessionStoreUtils.constructSessionStoreRestoreData(); + if (scroll?.hasOwnProperty("scroll")) { + root.scroll = scroll.scroll; + } + if (formdata?.hasOwnProperty("url")) { + root.url = formdata.url; + if (formdata.hasOwnProperty("innerHTML")) { + // eslint-disable-next-line no-unsanitized/property + root.innerHTML = formdata.innerHTML; + } + if (formdata.hasOwnProperty("xpath")) { + addFormEntries(root, formdata.xpath, /* isXpath */ true); + } + if (formdata.hasOwnProperty("id")) { + addFormEntries(root, formdata.id, /* isXpath */ false); + } + } + let childrenLength = Math.max( + scroll?.children?.length || 0, + formdata?.children?.length || 0 + ); + for (let i = 0; i < childrenLength; i++) { + root.addChild( + this.buildRestoreData(formdata?.children?.[i], scroll?.children?.[i]), + i + ); + } + return root; + }, + + _waitForStateStop(browser, expectedURL = null) { + const deferred = lazy.PromiseUtils.defer(); + + const listener = { + unregister(reject = true) { + if (reject) { + deferred.reject(); + } + + SessionStoreInternal._restoreListeners.delete(browser.permanentKey); + + try { + browser.removeProgressListener( + this, + Ci.nsIWebProgress.NOTIFY_STATE_WINDOW + ); + } catch {} // May have already gotten rid of the browser's webProgress. + }, + + onStateChange(webProgress, request, stateFlags, status) { + if ( + webProgress.isTopLevel && + stateFlags & Ci.nsIWebProgressListener.STATE_IS_WINDOW && + stateFlags & Ci.nsIWebProgressListener.STATE_STOP + ) { + // FIXME: We sometimes see spurious STATE_STOP events for about:blank + // loads, so we have to account for that here. + let aboutBlankOK = !expectedURL || expectedURL === "about:blank"; + let url = request.QueryInterface(Ci.nsIChannel).originalURI.spec; + if (url !== "about:blank" || aboutBlankOK) { + this.unregister(false); + deferred.resolve(); + } + } + }, + + QueryInterface: ChromeUtils.generateQI([ + "nsIWebProgressListener", + "nsISupportsWeakReference", + ]), + }; + + this._restoreListeners.get(browser.permanentKey)?.unregister(); + this._restoreListeners.set(browser.permanentKey, listener); + + browser.addProgressListener( + listener, + Ci.nsIWebProgress.NOTIFY_STATE_WINDOW + ); + + return deferred.promise; + }, + + _listenForNavigations(browser, callbacks) { + const listener = { + unregister() { + browser.browsingContext?.sessionHistory?.removeSHistoryListener(this); + + try { + browser.removeProgressListener( + this, + Ci.nsIWebProgress.NOTIFY_STATE_WINDOW + ); + } catch {} // May have already gotten rid of the browser's webProgress. + + SessionStoreInternal._restoreListeners.delete(browser.permanentKey); + }, + + OnHistoryReload() { + this.unregister(); + return callbacks.onHistoryReload(); + }, + + // TODO(kashav): ContentRestore.sys.mjs handles OnHistoryNewEntry + // separately, so we should eventually support that here as well. + OnHistoryNewEntry() {}, + OnHistoryGotoIndex() {}, + OnHistoryPurge() {}, + OnHistoryReplaceEntry() {}, + + onStateChange(webProgress, request, stateFlags, status) { + if ( + webProgress.isTopLevel && + stateFlags & Ci.nsIWebProgressListener.STATE_IS_WINDOW && + stateFlags & Ci.nsIWebProgressListener.STATE_START + ) { + this.unregister(); + callbacks.onStartRequest(); + } + }, + + QueryInterface: ChromeUtils.generateQI([ + "nsISHistoryListener", + "nsIWebProgressListener", + "nsISupportsWeakReference", + ]), + }; + + this._restoreListeners.get(browser.permanentKey)?.unregister(); + this._restoreListeners.set(browser.permanentKey, listener); + + browser.browsingContext?.sessionHistory?.addSHistoryListener(listener); + + browser.addProgressListener( + listener, + Ci.nsIWebProgress.NOTIFY_STATE_WINDOW + ); + }, + + /** + * This mirrors ContentRestore.restoreHistory() for parent process session + * history restores. + */ + _restoreHistory(browser, data) { + if (!Services.appinfo.sessionHistoryInParent) { + throw new Error("This function should only be used with SHIP"); + } + + this._tabStateToRestore.set(browser.permanentKey, data); + + // In case about:blank isn't done yet. + // XXX(kashav): Does this actually accomplish anything? Can we remove? + browser.stop(); + + lazy.SessionHistory.restoreFromParent( + browser.browsingContext.sessionHistory, + data.tabData + ); + + let url = data.tabData?.entries[data.tabData.index - 1]?.url; + let disallow = data.tabData?.disallow; + + let promise = SessionStoreUtils.restoreDocShellState( + browser.browsingContext, + url, + disallow + ); + this._tabStateRestorePromises.set(browser.permanentKey, promise); + + const onResolve = () => { + if (TAB_STATE_FOR_BROWSER.get(browser) !== TAB_STATE_RESTORING) { + this._listenForNavigations(browser, { + // The history entry was reloaded before we began restoring tab + // content, just proceed as we would normally. + onHistoryReload: () => { + this._restoreTabContent(browser); + return false; + }, + + // Some foreign code, like an extension, loaded a new URI on the + // browser. We no longer want to restore saved tab data, but may + // still have browser state that needs to be restored. + onStartRequest: () => { + this._tabStateToRestore.delete(browser.permanentKey); + this._restoreTabContent(browser); + }, + }); + } + + this._tabStateRestorePromises.delete(browser.permanentKey); + + this._restoreHistoryComplete(browser, data); + }; + + promise.then(onResolve).catch(() => {}); + }, + + /** + * Either load the saved typed value or restore the active history entry. + * If neither is possible, just load an empty document. + */ + _restoreTabEntry(browser, tabData) { + let url = "about:blank"; + let loadFlags = Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_HISTORY; + + if (tabData.userTypedValue && tabData.userTypedClear) { + url = tabData.userTypedValue; + loadFlags = Ci.nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP; + } else if (tabData.entries.length) { + return SessionStoreUtils.initializeRestore( + browser.browsingContext, + this.buildRestoreData(tabData.formdata, tabData.scroll) + ); + } + + let loadPromise = this._waitForStateStop(browser, url); + + browser.browsingContext.loadURI(url, { + loadFlags, + triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(), + }); + + return loadPromise; + }, + + /** + * This mirrors ContentRestore.restoreTabContent() for parent process session + * history restores. + */ + _restoreTabContent(browser, options = {}) { + if (!Services.appinfo.sessionHistoryInParent) { + throw new Error("This function should only be used with SHIP"); + } + + this._restoreListeners.get(browser.permanentKey)?.unregister(); + + this._restoreTabContentStarted(browser, options); + + let state = this._tabStateToRestore.get(browser.permanentKey); + this._tabStateToRestore.delete(browser.permanentKey); + + let promises = [this._tabStateRestorePromises.get(browser.permanentKey)]; + + if (state) { + promises.push(this._restoreTabEntry(browser, state.tabData)); + } else { + // The browser started another load, so we decided to not restore + // saved tab data. We should still wait for that new load to finish + // before proceeding. + promises.push(this._waitForStateStop(browser)); + } + + Promise.allSettled(promises).then(() => { + this._restoreTabContentComplete(browser, options); + }); + }, + + _sendRestoreTabContent(browser, options) { + if (Services.appinfo.sessionHistoryInParent) { + this._restoreTabContent(browser, options); + } else { + browser.messageManager.sendAsyncMessage( + "SessionStore:restoreTabContent", + options + ); + } + }, + + _restoreHistoryComplete(browser, data) { + let win = browser.ownerGlobal; + let tab = win?.gBrowser.getTabForBrowser(browser); + if (!tab) { + return; + } + + // Notify the tabbrowser that the tab chrome has been restored. + let tabData = lazy.TabState.collect(tab, TAB_CUSTOM_VALUES.get(tab)); + + // Update tab label and icon again after the tab history was updated. + this.updateTabLabelAndIcon(tab, tabData); + + let event = win.document.createEvent("Events"); + event.initEvent("SSTabRestoring", true, false); + tab.dispatchEvent(event); + }, + + _restoreTabContentStarted(browser, data) { + let win = browser.ownerGlobal; + let tab = win?.gBrowser.getTabForBrowser(browser); + if (!tab) { + return; + } + + let initiatedBySessionStore = + TAB_STATE_FOR_BROWSER.get(browser) != TAB_STATE_NEEDS_RESTORE; + let isNavigateAndRestore = + data.reason == RESTORE_TAB_CONTENT_REASON.NAVIGATE_AND_RESTORE; + + // We need to be careful when restoring the urlbar's search mode because + // we race a call to gURLBar.setURI due to the location change. setURI + // will exit search mode and set gURLBar.value to the restored URL, + // clobbering any search mode and userTypedValue we restore here. If + // this is a typical restore -- restoring on startup or restoring a + // closed tab for example -- then we need to restore search mode after + // that setURI call, and so we wait until restoreTabContentComplete, at + // which point setURI will have been called. If this is not a typical + // restore -- it was not initiated by session store or it's due to a + // remoteness change -- then we do not want to restore search mode at + // all, and so we remove it from the tab state cache. In particular, if + // the restore is due to a remoteness change, then the user is loading a + // new URL and the current search mode should not be carried over to it. + let cacheState = lazy.TabStateCache.get(browser.permanentKey); + if (cacheState.searchMode) { + if (!initiatedBySessionStore || isNavigateAndRestore) { + lazy.TabStateCache.update(browser.permanentKey, { + searchMode: null, + userTypedValue: null, + }); + } + return; + } + + if (!initiatedBySessionStore) { + // If a load not initiated by sessionstore was started in a + // previously pending tab. Mark the tab as no longer pending. + this.markTabAsRestoring(tab); + } else if (!isNavigateAndRestore) { + // If the user was typing into the URL bar when we crashed, but hadn't hit + // enter yet, then we just need to write that value to the URL bar without + // loading anything. This must happen after the load, as the load will clear + // userTypedValue. + // + // Note that we only want to do that if we're restoring state for reasons + // _other_ than a navigateAndRestore remoteness-flip, as such a flip + // implies that the user was navigating. + let tabData = lazy.TabState.collect(tab, TAB_CUSTOM_VALUES.get(tab)); + if ( + tabData.userTypedValue && + !tabData.userTypedClear && + !browser.userTypedValue + ) { + browser.userTypedValue = tabData.userTypedValue; + if (tab.selected) { + win.gURLBar.setURI(); + } + } + + // Remove state we don't need any longer. + lazy.TabStateCache.update(browser.permanentKey, { + userTypedValue: null, + userTypedClear: null, + }); + } + }, + + _restoreTabContentComplete(browser, data) { + let win = browser.ownerGlobal; + let tab = browser.ownerGlobal?.gBrowser.getTabForBrowser(browser); + if (!tab) { + return; + } + // Restore search mode and its search string in userTypedValue, if + // appropriate. + let cacheState = lazy.TabStateCache.get(browser.permanentKey); + if (cacheState.searchMode) { + win.gURLBar.setSearchMode(cacheState.searchMode, browser); + browser.userTypedValue = cacheState.userTypedValue; + if (tab.selected) { + win.gURLBar.setURI(); + } + lazy.TabStateCache.update(browser.permanentKey, { + searchMode: null, + userTypedValue: null, + }); + } + + // This callback is used exclusively by tests that want to + // monitor the progress of network loads. + if (gDebuggingEnabled) { + Services.obs.notifyObservers(browser, NOTIFY_TAB_RESTORED); + } + + SessionStoreInternal._resetLocalTabRestoringState(tab); + SessionStoreInternal.restoreNextTab(); + + this._sendTabRestoredNotification(tab, data.isRemotenessUpdate); + + Services.obs.notifyObservers(null, "sessionstore-one-or-no-tab-restored"); + }, + + /** + * Send the "SessionStore:restoreHistory" message to content, triggering a + * content restore. This method is intended to be used internally by + * SessionStore, as it also ensures that permissions are avaliable in the + * content process before triggering the history restore in the content + * process. + * + * @param browser The browser to transmit the permissions for + * @param options The options data to send to content. + */ + _sendRestoreHistory(browser, options) { + if (options.tabData.storage) { + SessionStoreUtils.restoreSessionStorageFromParent( + browser.browsingContext, + options.tabData.storage + ); + delete options.tabData.storage; + } + + if (Services.appinfo.sessionHistoryInParent) { + this._restoreHistory(browser, options); + } else { + browser.messageManager.sendAsyncMessage( + "SessionStore:restoreHistory", + options + ); + } + + if (browser && browser.frameLoader) { + browser.frameLoader.requestEpochUpdate(options.epoch); + } + }, + + // Flush out session history state so that it can be used to restore the state + // into a new process in `finishTabRemotenessChange`. + // + // NOTE: This codepath is temporary while the Fission Session History rewrite + // is in process, and will be removed & replaced once that rewrite is + // complete. (bug 1645062) + async prepareToChangeRemoteness(aBrowser) { + aBrowser.messageManager.sendAsyncMessage( + "SessionStore:prepareForProcessChange" + ); + await lazy.TabStateFlusher.flush(aBrowser); + }, + + // Handle finishing the remoteness change for a tab by restoring session + // history state into it, and resuming the ongoing network load. + // + // NOTE: This codepath is temporary while the Fission Session History rewrite + // is in process, and will be removed & replaced once that rewrite is + // complete. (bug 1645062) + finishTabRemotenessChange(aTab, aSwitchId) { + let window = aTab.ownerGlobal; + if (!window || !window.__SSi || window.closed) { + return; + } + + let tabState = lazy.TabState.clone(aTab, TAB_CUSTOM_VALUES.get(aTab)); + let options = { + restoreImmediately: true, + restoreContentReason: RESTORE_TAB_CONTENT_REASON.NAVIGATE_AND_RESTORE, + isRemotenessUpdate: true, + loadArguments: { + redirectLoadSwitchId: aSwitchId, + // As we're resuming a load which has been redirected from another + // process, record the history index which is currently being requested. + // It has to be offset by 1 to get back to native history indices from + // SessionStore history indicies. + redirectHistoryIndex: tabState.requestedIndex - 1, + }, + }; + + // Need to reset restoring tabs. + if (TAB_STATE_FOR_BROWSER.has(aTab.linkedBrowser)) { + this._resetLocalTabRestoringState(aTab); + } + + // Restore the state into the tab. + this.restoreTab(aTab, tabState, options); + }, +}; + +/** + * Priority queue that keeps track of a list of tabs to restore and returns + * the tab we should restore next, based on priority rules. We decide between + * pinned, visible and hidden tabs in that and FIFO order. Hidden tabs are only + * restored with restore_hidden_tabs=true. + */ +var TabRestoreQueue = { + // The separate buckets used to store tabs. + tabs: { priority: [], visible: [], hidden: [] }, + + // Preferences used by the TabRestoreQueue to determine which tabs + // are restored automatically and which tabs will be on-demand. + prefs: { + // Lazy getter that returns whether tabs are restored on demand. + get restoreOnDemand() { + let updateValue = () => { + let value = Services.prefs.getBoolPref(PREF); + let definition = { value, configurable: true }; + Object.defineProperty(this, "restoreOnDemand", definition); + return value; + }; + + const PREF = "browser.sessionstore.restore_on_demand"; + Services.prefs.addObserver(PREF, updateValue); + return updateValue(); + }, + + // Lazy getter that returns whether pinned tabs are restored on demand. + get restorePinnedTabsOnDemand() { + let updateValue = () => { + let value = Services.prefs.getBoolPref(PREF); + let definition = { value, configurable: true }; + Object.defineProperty(this, "restorePinnedTabsOnDemand", definition); + return value; + }; + + const PREF = "browser.sessionstore.restore_pinned_tabs_on_demand"; + Services.prefs.addObserver(PREF, updateValue); + return updateValue(); + }, + + // Lazy getter that returns whether we should restore hidden tabs. + get restoreHiddenTabs() { + let updateValue = () => { + let value = Services.prefs.getBoolPref(PREF); + let definition = { value, configurable: true }; + Object.defineProperty(this, "restoreHiddenTabs", definition); + return value; + }; + + const PREF = "browser.sessionstore.restore_hidden_tabs"; + Services.prefs.addObserver(PREF, updateValue); + return updateValue(); + }, + }, + + // Resets the queue and removes all tabs. + reset() { + this.tabs = { priority: [], visible: [], hidden: [] }; + }, + + // Adds a tab to the queue and determines its priority bucket. + add(tab) { + let { priority, hidden, visible } = this.tabs; + + if (tab.pinned) { + priority.push(tab); + } else if (tab.hidden) { + hidden.push(tab); + } else { + visible.push(tab); + } + }, + + // Removes a given tab from the queue, if it's in there. + remove(tab) { + let { priority, hidden, visible } = this.tabs; + + // We'll always check priority first since we don't + // have an indicator if a tab will be there or not. + let set = priority; + let index = set.indexOf(tab); + + if (index == -1) { + set = tab.hidden ? hidden : visible; + index = set.indexOf(tab); + } + + if (index > -1) { + set.splice(index, 1); + } + }, + + // Returns and removes the tab with the highest priority. + shift() { + let set; + let { priority, hidden, visible } = this.tabs; + + let { restoreOnDemand, restorePinnedTabsOnDemand } = this.prefs; + let restorePinned = !(restoreOnDemand && restorePinnedTabsOnDemand); + if (restorePinned && priority.length) { + set = priority; + } else if (!restoreOnDemand) { + if (visible.length) { + set = visible; + } else if (this.prefs.restoreHiddenTabs && hidden.length) { + set = hidden; + } + } + + return set && set.shift(); + }, + + // Moves a given tab from the 'hidden' to the 'visible' bucket. + hiddenToVisible(tab) { + let { hidden, visible } = this.tabs; + let index = hidden.indexOf(tab); + + if (index > -1) { + hidden.splice(index, 1); + visible.push(tab); + } + }, + + // Moves a given tab from the 'visible' to the 'hidden' bucket. + visibleToHidden(tab) { + let { visible, hidden } = this.tabs; + let index = visible.indexOf(tab); + + if (index > -1) { + visible.splice(index, 1); + hidden.push(tab); + } + }, + + /** + * Returns true if the passed tab is in one of the sets that we're + * restoring content in automatically. + * + * @param tab (<xul:tab>) + * The tab to check + * @returns bool + */ + willRestoreSoon(tab) { + let { priority, hidden, visible } = this.tabs; + let { + restoreOnDemand, + restorePinnedTabsOnDemand, + restoreHiddenTabs, + } = this.prefs; + let restorePinned = !(restoreOnDemand && restorePinnedTabsOnDemand); + let candidateSet = []; + + if (restorePinned && priority.length) { + candidateSet.push(...priority); + } + + if (!restoreOnDemand) { + if (visible.length) { + candidateSet.push(...visible); + } + + if (restoreHiddenTabs && hidden.length) { + candidateSet.push(...hidden); + } + } + + return candidateSet.indexOf(tab) > -1; + }, +}; + +// A map storing a closed window's state data until it goes aways (is GC'ed). +// This ensures that API clients can still read (but not write) states of +// windows they still hold a reference to but we don't. +var DyingWindowCache = { + _data: new WeakMap(), + + has(window) { + return this._data.has(window); + }, + + get(window) { + return this._data.get(window); + }, + + set(window, data) { + this._data.set(window, data); + }, + + remove(window) { + this._data.delete(window); + }, +}; + +// A weak set of dirty windows. We use it to determine which windows we need to +// recollect data for when getCurrentState() is called. +var DirtyWindows = { + _data: new WeakMap(), + + has(window) { + return this._data.has(window); + }, + + add(window) { + return this._data.set(window, true); + }, + + remove(window) { + this._data.delete(window); + }, + + clear(window) { + this._data = new WeakMap(); + }, +}; + +// The state from the previous session (after restoring pinned tabs). This +// state is persisted and passed through to the next session during an app +// restart to make the third party add-on warning not trash the deferred +// session +var LastSession = { + _state: null, + + get canRestore() { + return !!this._state; + }, + + getState() { + return this._state; + }, + + setState(state) { + this._state = state; + }, + + clear(silent = false) { + if (this._state) { + this._state = null; + if (!silent) { + Services.obs.notifyObservers(null, NOTIFY_LAST_SESSION_CLEARED); + } + } + }, +}; + +// Exposed for tests +export const _LastSession = LastSession; |