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

--1:000000000000
+:3fc03c7eb39d
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+this.EXPORTED_SYMBOLS = ["SessionStore"];
+const Cu = Components.utils;
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+const STATE_STOPPED = 0;
+const STATE_RUNNING = 1;
+const STATE_QUITTING = -1;
+const TAB_STATE_NEEDS_RESTORE = 1;
+const TAB_STATE_RESTORING = 2;
+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_TAB_RESTORED = "sessionstore-debug-tab-restored"; // WARNING: debug-only
+// Maximum number of tabs to restore simultaneously. Previously controlled by
+// the browser.sessionstore.max_concurrent_tabs pref.
+const MAX_CONCURRENT_TAB_RESTORES = 3;
+// global notifications observed
+const OBSERVING = [
+"domwindowopened", "domwindowclosed",
+"quit-application-requested", "quit-application-granted",
+"browser-lastwindow-close-granted",
+"quit-application", "browser:purge-session-history",
+"browser:purge-domain-data",
+"gather-telemetry",
+];
+// XUL Window properties to (re)store
+// Restored in restoreDimensions()
+const WINDOW_ATTRIBUTES = ["width", "height", "screenX", "screenY", "sizemode"];
+// Hideable window features to (re)store
+// Restored in restoreWindowFeatures()
+const WINDOW_HIDEABLE_FEATURES = [
+"menubar", "toolbar", "locationbar", "personalbar", "statusbar", "scrollbars"
+];
+const MESSAGES = [
+// The content script gives us a reference to an object that performs
+// synchronous collection of session data.
+"SessionStore:setupSyncHandler",
+// 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.
+"SessionStore:restoreTabContentComplete",
+// The document has been restored, so the restore is done. We trigger
+// SSTabRestored at this time.
+"SessionStore:restoreDocumentComplete",
+// A tab that is being restored was reloaded. We call restoreTabContent to
+// finish restoring it right away.
+"SessionStore:reloadPendingTab",
+];
+// These are tab events that we listen to.
+const TAB_EVENTS = [
+"TabOpen", "TabClose", "TabSelect", "TabShow", "TabHide", "TabPinned",
+"TabUnpinned"
+];
+// The number of milliseconds in a day
+const MS_PER_DAY = 1000.0 * 60.0 * 60.0 * 24.0;
+Cu.import("resource://gre/modules/Services.jsm", this);
+Cu.import("resource://gre/modules/XPCOMUtils.jsm", this);
+Cu.import("resource://gre/modules/TelemetryTimestamps.jsm", this);
+Cu.import("resource://gre/modules/TelemetryStopwatch.jsm", this);
+Cu.import("resource://gre/modules/osfile.jsm", this);
+Cu.import("resource://gre/modules/PrivateBrowsingUtils.jsm", this);
+Cu.import("resource://gre/modules/Promise.jsm", this);
+Cu.import("resource://gre/modules/Task.jsm", this);
+XPCOMUtils.defineLazyServiceGetter(this, "gSessionStartup",
+"@mozilla.org/browser/sessionstartup;1", "nsISessionStartup");
+XPCOMUtils.defineLazyServiceGetter(this, "gScreenManager",
+"@mozilla.org/gfx/screenmanager;1", "nsIScreenManager");
+XPCOMUtils.defineLazyServiceGetter(this, "Telemetry",
+"@mozilla.org/base/telemetry;1", "nsITelemetry");
+XPCOMUtils.defineLazyModuleGetter(this, "console",
+"resource://gre/modules/devtools/Console.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "RecentWindow",
+"resource:///modules/RecentWindow.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "GlobalState",
+"resource:///modules/sessionstore/GlobalState.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PrivacyFilter",
+"resource:///modules/sessionstore/PrivacyFilter.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ScratchpadManager",
+"resource:///modules/devtools/scratchpad-manager.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "SessionSaver",
+"resource:///modules/sessionstore/SessionSaver.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "SessionCookies",
+"resource:///modules/sessionstore/SessionCookies.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "SessionFile",
+"resource:///modules/sessionstore/SessionFile.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "TabAttributes",
+"resource:///modules/sessionstore/TabAttributes.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "TabState",
+"resource:///modules/sessionstore/TabState.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "TabStateCache",
+"resource:///modules/sessionstore/TabStateCache.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Utils",
+"resource:///modules/sessionstore/Utils.jsm");
+/**
+* |true| if we are in debug mode, |false| otherwise.
+* Debug mode is controlled by preference browser.sessionstore.debug
+*/
+let gDebuggingEnabled = false;
+function debug(aMsg) {
+if (gDebuggingEnabled) {
+aMsg = ("SessionStore: " + aMsg).replace(/\S{80}/g, "$&\n");
+Services.console.logStringMessage(aMsg);
+}
+}
+this.SessionStore = {
+get promiseInitialized() {
+return SessionStoreInternal.promiseInitialized;
+},
+get canRestoreLastSession() {
+return SessionStoreInternal.canRestoreLastSession;
+},
+set canRestoreLastSession(val) {
+SessionStoreInternal.canRestoreLastSession = val;
+},
+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);
+},
+duplicateTab: function ss_duplicateTab(aWindow, aTab, aDelta = 0) {
+return SessionStoreInternal.duplicateTab(aWindow, aTab, aDelta);
+},
+getClosedTabCount: function ss_getClosedTabCount(aWindow) {
+return SessionStoreInternal.getClosedTabCount(aWindow);
+},
+getClosedTabData: function ss_getClosedTabDataAt(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();
+},
+undoCloseWindow: function ss_undoCloseWindow(aIndex) {
+return SessionStoreInternal.undoCloseWindow(aIndex);
+},
+forgetClosedWindow: function ss_forgetClosedWindow(aIndex) {
+return SessionStoreInternal.forgetClosedWindow(aIndex);
+},
+getWindowValue: function ss_getWindowValue(aWindow, aKey) {
+return SessionStoreInternal.getWindowValue(aWindow, aKey);
+},
+setWindowValue: function ss_setWindowValue(aWindow, aKey, aStringValue) {
+SessionStoreInternal.setWindowValue(aWindow, aKey, aStringValue);
+},
+deleteWindowValue: function ss_deleteWindowValue(aWindow, aKey) {
+SessionStoreInternal.deleteWindowValue(aWindow, aKey);
+},
+getTabValue: function ss_getTabValue(aTab, aKey) {
+return SessionStoreInternal.getTabValue(aTab, aKey);
+},
+setTabValue: function ss_setTabValue(aTab, aKey, aStringValue) {
+SessionStoreInternal.setTabValue(aTab, aKey, aStringValue);
+},
+deleteTabValue: function ss_deleteTabValue(aTab, aKey) {
+SessionStoreInternal.deleteTabValue(aTab, aKey);
+},
+getGlobalValue: function ss_getGlobalValue(aKey) {
+return SessionStoreInternal.getGlobalValue(aKey);
+},
+setGlobalValue: function ss_setGlobalValue(aKey, aStringValue) {
+SessionStoreInternal.setGlobalValue(aKey, aStringValue);
+},
+deleteGlobalValue: function ss_deleteGlobalValue(aKey) {
+SessionStoreInternal.deleteGlobalValue(aKey);
+},
+persistTabAttribute: function ss_persistTabAttribute(aName) {
+SessionStoreInternal.persistTabAttribute(aName);
+},
+restoreLastSession: function ss_restoreLastSession() {
+SessionStoreInternal.restoreLastSession();
+},
+getCurrentState: function (aUpdateAll) {
+return SessionStoreInternal.getCurrentState(aUpdateAll);
+},
+/**
+* Backstage pass to implementation details, used for testing purpose.
+* Controlled by preference "browser.sessionstore.testmode".
+*/
+get _internal() {
+if (Services.prefs.getBoolPref("browser.sessionstore.debug")) {
+return SessionStoreInternal;
+}
+return undefined;
+},
+};
+// Freeze the SessionStore object. We don't want anyone to modify it.
+Object.freeze(SessionStore);
+let SessionStoreInternal = {
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsIDOMEventListener,
+Ci.nsIObserver,
+Ci.nsISupportsWeakReference
+]),
+// set default load state
+_loadState: STATE_STOPPED,
+_globalState: new GlobalState(),
+// During the initial restore and setBrowserState calls tracks the number of
+// windows yet to be restored
+_restoreCount: -1,
+// This number gets incremented each time we start to restore a tab.
+_nextRestoreEpoch: 1,
+// For each <browser> element being restored, records the current epoch.
+_browserEpochs: new WeakMap(),
+// 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,
+// 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,
+// A promise resolved once initialization is complete
+_deferredInitialized: Promise.defer(),
+// Whether session has been initialized
+_sessionInitialized: false,
+// Promise that is resolved when we're ready to initialize
+// and restore the session.
+_promiseReadyForInitialization: null,
+/**
+* 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();
+}
+},
+/**
+* Initialize the sessionstore service.
+*/
+init: function () {
+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;
+},
+/**
+* Initialize the session using the state provided by SessionStartup
+*/
+initSession: function () {
+let state;
+let ss = gSessionStartup;
+try {
+if (ss.doRestore() ||
+ss.sessionType == Ci.nsISessionStartup.DEFER_SESSION)
+state = ss.state;
+}
+catch(ex) { dump(ex + "\n"); } // no state to restore, which is ok
+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 == Ci.nsISessionStartup.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)
+state = iniState;
+else
+state = null;
+if (remainingState.windows.length) {
+LastSession.setState(remainingState);
+}
+}
+else {
+// Get the last deferred session in case the user still wants to
+// restore it
+LastSession.setState(state.lastSessionState);
+if (ss.previousSessionCrashed) {
+this._recentCrashes = (state.session &&
+state.session.recentCrashes || 0) + 1;
+if (this._needsRestorePage(state, this._recentCrashes)) {
+// replace the crashed session with a restore-page-only session
+let pageData = {
+url: "about:sessionrestore",
+formdata: {
+id: { "sessionData": state },
+xpath: {}
+}
+};
+state = { windows: [{ tabs: [{ entries: [pageData] }] }] };
+} else if (this._hasSingleTabWithURL(state.windows,
+"about:welcomeback")) {
+// 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";
+}
+}
+// 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;
+});
+}
+}
+catch (ex) { debug("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 (this._loadState != STATE_QUITTING &&
+this._prefBranch.getBoolPref("sessionstore.resume_session_once"))
+this._prefBranch.setBoolPref("sessionstore.resume_session_once", false);
+this._performUpgradeBackup();
+return state;
+},
+/**
+* If this is the first time we launc this build of Firefox,
+* backup sessionstore.js.
+*/
+_performUpgradeBackup: function ssi_performUpgradeBackup() {
+// Perform upgrade backup, if necessary
+const PREF_UPGRADE = "sessionstore.upgradeBackup.latestBuildID";
+let buildID = Services.appinfo.platformBuildID;
+let latestBackup = this._prefBranch.getCharPref(PREF_UPGRADE);
+if (latestBackup == buildID) {
+return Promise.resolve();
+}
+return Task.spawn(function task() {
+try {
+// Perform background backup
+yield SessionFile.createBackupCopy("-" + buildID);
+this._prefBranch.setCharPref(PREF_UPGRADE, buildID);
+// In case of success, remove previous backup.
+yield SessionFile.removeBackupCopy("-" + latestBackup);
+} catch (ex) {
+debug("Could not perform upgrade backup " + ex);
+debug(ex.stack);
+}
+}.bind(this));
+},
+_initPrefs : function() {
+this._prefBranch = Services.prefs.getBranch("browser.");
+gDebuggingEnabled = this._prefBranch.getBoolPref("sessionstore.debug");
+Services.prefs.addObserver("browser.sessionstore.debug", () => {
+gDebuggingEnabled = this._prefBranch.getBoolPref("sessionstore.debug");
+}, false);
+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);
+},
+/**
+* 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.");
+}
+// save all data for session resuming
+if (this._sessionInitialized) {
+SessionSaver.run();
+}
+// clear out priority queue in case it's still holding refs
+TabRestoreQueue.reset();
+// Make sure to cancel pending saves.
+SessionSaver.cancel();
+},
+/**
+* Handle notifications
+*/
+observe: function ssi_observe(aSubject, aTopic, aData) {
+switch (aTopic) {
+case "domwindowopened": // catch new windows
+this.onOpen(aSubject);
+break;
+case "domwindowclosed": // catch closed windows
+this.onClose(aSubject);
+break;
+case "quit-application-requested":
+this.onQuitApplicationRequested();
+break;
+case "quit-application-granted":
+this.onQuitApplicationGranted();
+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();
+break;
+case "browser:purge-domain-data":
+this.onPurgeDomainData(aData);
+break;
+case "nsPref:changed": // catch pref changes
+this.onPrefChange(aData);
+break;
+case "gather-telemetry":
+this.onGatherTelemetry();
+break;
+}
+},
+/**
+* This method handles incoming messages sent by the session store content
+* script and thus enables communication with OOP tabs.
+*/
+receiveMessage: function ssi_receiveMessage(aMessage) {
+var browser = aMessage.target;
+var win = browser.ownerDocument.defaultView;
+let tab = this._getTabForBrowser(browser);
+if (!tab) {
+// Ignore messages from <browser> elements that are not tabs.
+return;
+}
+switch (aMessage.name) {
+case "SessionStore:setupSyncHandler":
+TabState.setSyncHandler(browser, aMessage.objects.handler);
+break;
+case "SessionStore:update":
+this.recordTelemetry(aMessage.data.telemetry);
+TabState.update(browser, aMessage.data);
+this.saveStateDelayed(win);
+break;
+case "SessionStore:restoreHistoryComplete":
+if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
+// Notify the tabbrowser that the tab chrome has been restored.
+let tabData = browser.__SS_data;
+// wall-paper fix for bug 439675: make sure that the URL to be loaded
+// is always visible in the address bar
+let activePageData = tabData.entries[tabData.index - 1] || null;
+let uri = activePageData ? activePageData.url || null : null;
+browser.userTypedValue = uri;
+// If the page has a title, set it.
+if (activePageData) {
+if (activePageData.title) {
+tab.label = activePageData.title;
+tab.crop = "end";
+} else if (activePageData.url != "about:blank") {
+tab.label = activePageData.url;
+tab.crop = "center";
+}
+}
+// Restore the tab icon.
+if ("image" in tabData) {
+win.gBrowser.setIcon(tab, tabData.image);
+}
+let event = win.document.createEvent("Events");
+event.initEvent("SSTabRestoring", true, false);
+tab.dispatchEvent(event);
+}
+break;
+case "SessionStore:restoreTabContentStarted":
+if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
+// 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, since it will clear
+// userTypedValue.
+let tabData = browser.__SS_data;
+if (tabData.userTypedValue && !tabData.userTypedClear) {
+browser.userTypedValue = tabData.userTypedValue;
+win.URLBarSetURI();
+}
+}
+break;
+case "SessionStore:restoreTabContentComplete":
+if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
+// 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, null);
+}
+if (tab) {
+SessionStoreInternal._resetLocalTabRestoringState(tab);
+SessionStoreInternal.restoreNextTab();
+}
+}
+break;
+case "SessionStore:restoreDocumentComplete":
+if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
+// Document has been restored. Delete all the state associated
+// with it and trigger SSTabRestored.
+let tab = browser.__SS_restore_tab;
+delete browser.__SS_restore_data;
+delete browser.__SS_restore_tab;
+delete browser.__SS_data;
+this._sendTabRestoredNotification(tab);
+}
+break;
+case "SessionStore:reloadPendingTab":
+if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
+if (tab && browser.__SS_restoreState == TAB_STATE_NEEDS_RESTORE) {
+this.restoreTabContent(tab);
+}
+}
+break;
+default:
+debug("received unknown message '" + aMessage.name + "'");
+break;
+}
+},
+/**
+* Record telemetry measurements stored in an object.
+* @param telemetry
+*        {histogramID: value, ...} An object mapping histogramIDs to the
+*        value to be recorded for that ID,
+*/
+recordTelemetry: function (telemetry) {
+for (let histogramId in telemetry){
+Telemetry.getHistogramById(histogramId).add(telemetry[histogramId]);
+}
+},
+/* ........ Window Event Handlers .............. */
+/**
+* Implement nsIDOMEventListener for handling various window and tab events
+*/
+handleEvent: function ssi_handleEvent(aEvent) {
+var win = aEvent.currentTarget.ownerDocument.defaultView;
+let browser;
+switch (aEvent.type) {
+case "TabOpen":
+this.onTabAdd(win, aEvent.originalTarget);
+break;
+case "TabClose":
+// aEvent.detail determines if the tab was closed by moving to a different window
+if (!aEvent.detail)
+this.onTabClose(win, aEvent.originalTarget);
+this.onTabRemove(win, aEvent.originalTarget);
+break;
+case "TabSelect":
+this.onTabSelect(win);
+break;
+case "TabShow":
+this.onTabShow(win, aEvent.originalTarget);
+break;
+case "TabHide":
+this.onTabHide(win, aEvent.originalTarget);
+break;
+case "TabPinned":
+case "TabUnpinned":
+this.saveStateDelayed(win);
+break;
+}
+this._clearRestoringWindows();
+},
+/**
+* Generate a unique window identifier
+* @return string
+*         A unique string to identify a window
+*/
+_generateWindowID: function ssi_generateWindowID() {
+return "window" + (this._nextWindowID++);
+},
+/**
+* If it's the first window load since app start...
+* - determine if we're reloading after a crash or a forced-restart
+* - restore window state
+* - restart downloads
+* Set up event listeners for this window's tabs
+* @param aWindow
+*        Window reference
+* @param aInitialState
+*        The initial state to be loaded after startup (optional)
+*/
+onLoad: function ssi_onLoad(aWindow, aInitialState = null) {
+// return if window has already been initialized
+if (aWindow && aWindow.__SSi && this._windows[aWindow.__SSi])
+return;
+// ignore windows opened while shutting down
+if (this._loadState == STATE_QUITTING)
+return;
+// Assign the window a unique identifier we can use to reference
+// internal data about the window.
+aWindow.__SSi = this._generateWindowID();
+let mm = aWindow.messageManager;
+MESSAGES.forEach(msg => mm.addMessageListener(msg, this));
+// Load the frame script after registering listeners.
+mm.loadFrameScript("chrome://browser/content/content-sessionStore.js", true);
+// and create its data object
+this._windows[aWindow.__SSi] = { tabs: [], selected: 0, _closedTabs: [], busy: false };
+let isPrivateWindow = false;
+if (PrivateBrowsingUtils.isWindowPrivate(aWindow))
+this._windows[aWindow.__SSi].isPrivate = isPrivateWindow = true;
+if (!this._isWindowLoaded(aWindow))
+this._windows[aWindow.__SSi]._restoring = true;
+if (!aWindow.toolbar.visible)
+this._windows[aWindow.__SSi].isPopup = true;
+// perform additional initialization when the first window is loading
+if (this._loadState == STATE_STOPPED) {
+this._loadState = STATE_RUNNING;
+SessionSaver.updateLastSaveTime();
+// restore a crashed session resp. resume the last session if requested
+if (aInitialState) {
+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 = gSessionStartup.state;
+// Nothing to restore now, notify observers things are complete.
+Services.obs.notifyObservers(null, NOTIFY_WINDOWS_RESTORED, "");
+} 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);
+let overwrite = this._isCmdLineEmpty(aWindow, aInitialState);
+let options = {firstWindow: true, overwriteTabs: overwrite};
+this.restoreWindow(aWindow, aInitialState, options);
+}
+}
+else {
+// Nothing to restore, notify observers things are complete.
+Services.obs.notifyObservers(null, NOTIFY_WINDOWS_RESTORED, "");
+// The next delayed save request should execute immediately.
+SessionSaver.clearLastSaveTime();
+}
+}
+// this window was opened by _openWindowWithState
+else if (!this._isWindowLoaded(aWindow)) {
+let state = this._statesToRestore[aWindow.__SS_restoreID];
+let options = {overwriteTabs: true, isFollowUp: state.windows.length == 1};
+this.restoreWindow(aWindow, state, options);
+}
+// 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.restoreWindow(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;
+#ifndef XP_MACOSX
+if (!this._doResumeSession()) {
+#endif
+// 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._closedWindows.splice(closedWindowIndex, 1);
+}
+// Or update _closedWindows with the modified state
+else {
+delete normalTabsState.windows[0].__lastSessionWindowID;
+this._closedWindows[closedWindowIndex] = normalTabsState.windows[0];
+}
+#ifndef XP_MACOSX
+}
+else {
+// If we're just restoring the window, make sure it gets removed from
+// _closedWindows.
+this._closedWindows.splice(closedWindowIndex, 1);
+newWindowState = closedWindowState;
+delete newWindowState.hidden;
+}
+#endif
+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, state, 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;
+}
+var tabbrowser = aWindow.gBrowser;
+// add tab change listeners to all already existing tabs
+for (let i = 0; i < tabbrowser.tabs.length; i++) {
+this.onTabAdd(aWindow, tabbrowser.tabs[i], true);
+}
+// notification of tab add/remove/selection/show/hide
+TAB_EVENTS.forEach(function(aEvent) {
+tabbrowser.tabContainer.addEventListener(aEvent, this, true);
+}, this);
+},
+/**
+* On window open
+* @param aWindow
+*        Window reference
+*/
+onOpen: function ssi_onOpen(aWindow) {
+let onload = () => {
+aWindow.removeEventListener("load", onload);
+let windowType = aWindow.document.documentElement.getAttribute("windowtype");
+// Ignore non-browser windows.
+if (windowType != "navigator:browser") {
+return;
+}
+if (this._sessionInitialized) {
+this.onLoad(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) {
+let deferred = Promise.defer();
+// Wait for the given window's delayed startup to be finished.
+Services.obs.addObserver(function obs(subject, topic) {
+if (aWindow == subject) {
+Services.obs.removeObserver(obs, topic);
+deferred.resolve();
+}
+}, "browser-delayed-startup-finished", false);
+// 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([deferred.promise, gSessionStartup.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.onLoad(aWindow);
+} else {
+let initialState = this.initSession();
+this._sessionInitialized = true;
+this.onLoad(aWindow, initialState);
+// Let everyone know we're done.
+this._deferredInitialized.resolve();
+}
+}, console.error);
+};
+aWindow.addEventListener("load", onload);
+},
+/**
+* On window close...
+* - remove event listeners from tabs
+* - save all window data
+* @param aWindow
+*        Window reference
+*/
+onClose: function ssi_onClose(aWindow) {
+// 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();
+}
+this._windows[aWindow.__SSi] = this._statesToRestore[aWindow.__SS_restoreID];
+delete this._statesToRestore[aWindow.__SS_restoreID];
+delete aWindow.__SS_restoreID;
+}
+// ignore windows not tracked by SessionStore
+if (!aWindow.__SSi || !this._windows[aWindow.__SSi]) {
+return;
+}
+// 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;
+TAB_EVENTS.forEach(function(aEvent) {
+tabbrowser.tabContainer.removeEventListener(aEvent, this, true);
+}, this);
+let winData = this._windows[aWindow.__SSi];
+// Collect window data only when *not* closed during shutdown.
+if (this._loadState == STATE_RUNNING) {
+// Flush all data queued in the content script before the window is gone.
+TabState.flushWindow(aWindow);
+// update all window data for a last time
+this._collectWindowData(aWindow);
+if (isFullyLoaded) {
+winData.title = aWindow.content.document.title || tabbrowser.selectedTab.label;
+winData.title = this._replaceLoadingTitle(winData.title, tabbrowser,
+tabbrowser.selectedTab);
+SessionCookies.update([winData]);
+}
+#ifndef XP_MACOSX
+// Until we decide otherwise elsewhere, this window is part of a series
+// of closing windows to quit.
+winData._shouldRestore = true;
+#endif
+// 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();
+// Save non-private windows if they have at
+// least one saveable tab or are the last window.
+if (!winData.isPrivate) {
+// Remove any open private tabs the window may contain.
+PrivacyFilter.filterPrivateTabs(winData);
+// Determine whether the window has any tabs worth saving.
+let hasSaveableTabs = winData.tabs.some(this._shouldSaveTabState);
+// 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 =
+Object.keys(this._windows).length == 1 &&
+!this._closedWindows.some(win => win._shouldRestore || false);
+if (hasSaveableTabs || isLastWindow) {
+// we don't want to save the busy state
+delete winData.busy;
+this._closedWindows.unshift(winData);
+this._capClosedWindows();
+}
+}
+// clear this window from the list
+delete this._windows[aWindow.__SSi];
+// save the state without this window to disk
+this.saveStateDelayed();
+}
+for (let i = 0; i < tabbrowser.tabs.length; i++) {
+this.onTabRemove(aWindow, tabbrowser.tabs[i], true);
+}
+// Cache the window state until it is completely gone.
+DyingWindowCache.set(aWindow, winData);
+let mm = aWindow.messageManager;
+MESSAGES.forEach(msg => mm.removeMessageListener(msg, this));
+delete aWindow.__SSi;
+},
+/**
+* On quit application requested
+*/
+onQuitApplicationRequested: function ssi_onQuitApplicationRequested() {
+// get a current snapshot of all windows
+this._forEachBrowserWindow(function(aWindow) {
+// Flush all data queued in the content script to not lose it when
+// shutting down.
+TabState.flushWindow(aWindow);
+this._collectWindowData(aWindow);
+});
+// we must cache this because _getMostRecentBrowserWindow will always
+// return null by the time quit-application occurs
+var activeWindow = this._getMostRecentBrowserWindow();
+if (activeWindow)
+this.activeWindowSSiCache = activeWindow.__SSi || "";
+DirtyWindows.clear();
+},
+/**
+* On quit application granted
+*/
+onQuitApplicationGranted: function ssi_onQuitApplicationGranted() {
+// freeze the data at what we've got (ignoring closing windows)
+this._loadState = STATE_QUITTING;
+},
+/**
+* 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") {
+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
+LastSession.clear();
+}
+this._loadState = STATE_QUITTING; // just to be sure
+this._uninit();
+},
+/**
+* On purge of session history
+*/
+onPurgeSessionHistory: function ssi_onPurgeSessionHistory() {
+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 (this._loadState == STATE_QUITTING)
+return;
+LastSession.clear();
+let openWindows = {};
+this._forEachBrowserWindow(function(aWindow) {
+Array.forEach(aWindow.gBrowser.tabs, function(aTab) {
+delete aTab.linkedBrowser.__SS_data;
+if (aTab.linkedBrowser.__SS_restoreState)
+this._resetTabRestoringState(aTab);
+}, this);
+openWindows[aWindow.__SSi] = true;
+});
+// also clear all data about closed tabs and windows
+for (let ix in this._windows) {
+if (ix in openWindows) {
+this._windows[ix]._closedTabs = [];
+} else {
+delete this._windows[ix];
+}
+}
+// also clear all data about closed windows
+this._closedWindows = [];
+// give the tabbrowsers a chance to clear their histories first
+var win = this._getMostRecentBrowserWindow();
+if (win) {
+win.setTimeout(() => SessionSaver.run(), 0);
+} else if (this._loadState == STATE_RUNNING) {
+SessionSaver.run();
+}
+this._clearRestoringWindows();
+},
+/**
+* On purge of domain data
+* @param aData
+*        String domain data
+*/
+onPurgeDomainData: function ssi_onPurgeDomainData(aData) {
+// does a session history entry contain a url for the given domain?
+function containsDomain(aEntry) {
+if (Utils.hasRootDomain(aEntry.url, aData)) {
+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);
+}
+}
+// 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 == 0) {
+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 (this._loadState == STATE_RUNNING) {
+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) {
+this._windows[ix]._closedTabs.splice(this._max_tabs_undo, this._windows[ix]._closedTabs.length);
+}
+break;
+case "sessionstore.max_windows_undo":
+this._max_windows_undo = this._prefBranch.getIntPref("sessionstore.max_windows_undo");
+this._capClosedWindows();
+break;
+}
+},
+/**
+* set up listeners for a new tab
+* @param aWindow
+*        Window reference
+* @param aTab
+*        Tab reference
+* @param aNoNotification
+*        bool Do not save state if we're updating an existing tab
+*/
+onTabAdd: function ssi_onTabAdd(aWindow, aTab, aNoNotification) {
+if (!aNoNotification) {
+this.saveStateDelayed(aWindow);
+}
+},
+/**
+* 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) {
+let browser = aTab.linkedBrowser;
+delete browser.__SS_data;
+// 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 = browser.__SS_restoreState;
+if (previousState) {
+this._resetTabRestoringState(aTab);
+if (previousState == TAB_STATE_RESTORING)
+this.restoreNextTab();
+}
+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;
+}
+// Flush all data queued in the content script before the tab is gone.
+TabState.flush(aTab.linkedBrowser);
+// Get the latest data for this tab (generally, from the cache)
+let tabState = TabState.collect(aTab);
+// Don't save private tabs
+let isPrivateWindow = PrivateBrowsingUtils.isWindowPrivate(aWindow);
+if (!isPrivateWindow && tabState.isPrivate) {
+return;
+}
+// store closed-tab data for undo
+if (this._shouldSaveTabState(tabState)) {
+let tabTitle = aTab.label;
+let tabbrowser = aWindow.gBrowser;
+tabTitle = this._replaceLoadingTitle(tabTitle, tabbrowser, aTab);
+this._windows[aWindow.__SSi]._closedTabs.unshift({
+state: tabState,
+title: tabTitle,
+image: tabbrowser.getIcon(aTab),
+pos: aTab._tPos,
+closedAt: Date.now()
+});
+var length = this._windows[aWindow.__SSi]._closedTabs.length;
+if (length > this._max_tabs_undo)
+this._windows[aWindow.__SSi]._closedTabs.splice(this._max_tabs_undo, length - this._max_tabs_undo);
+}
+},
+/**
+* When a tab is selected, save session data
+* @param aWindow
+*        Window reference
+*/
+onTabSelect: function ssi_onTabSelect(aWindow) {
+if (this._loadState == STATE_RUNNING) {
+this._windows[aWindow.__SSi].selected = aWindow.gBrowser.tabContainer.selectedIndex;
+let tab = aWindow.gBrowser.selectedTab;
+// If __SS_restoreState is still on the browser and it is
+// TAB_STATE_NEEDS_RESTORE, then then we haven't restored
+// this tab yet. Explicitly call restoreTabContent to kick off the restore.
+if (tab.linkedBrowser.__SS_restoreState &&
+tab.linkedBrowser.__SS_restoreState == TAB_STATE_NEEDS_RESTORE)
+this.restoreTabContent(tab);
+}
+},
+onTabShow: function ssi_onTabShow(aWindow, aTab) {
+// If the tab hasn't been restored yet, move it into the right bucket
+if (aTab.linkedBrowser.__SS_restoreState &&
+aTab.linkedBrowser.__SS_restoreState == 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 due to changing groups in Panorama.
+this.saveStateDelayed(aWindow);
+},
+onTabHide: function ssi_onTabHide(aWindow, aTab) {
+// If the tab hasn't been restored yet, move it into the right bucket
+if (aTab.linkedBrowser.__SS_restoreState &&
+aTab.linkedBrowser.__SS_restoreState == TAB_STATE_NEEDS_RESTORE) {
+TabRestoreQueue.visibleToHidden(aTab);
+}
+// Default delay of 2 seconds gives enough time to catch multiple TabHide
+// events due to changing groups in Panorama.
+this.saveStateDelayed(aWindow);
+},
+onGatherTelemetry: function() {
+// On the first gather-telemetry notification of the session,
+// gather telemetry data.
+Services.obs.removeObserver(this, "gather-telemetry");
+let stateString = SessionStore.getBrowserState();
+return SessionFile.gatherTelemetry(stateString);
+},
+/* ........ 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 this._toJSONString(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._getMostRecentBrowserWindow();
+if (!window) {
+this._restoreCount = 1;
+this._openWindowWithState(state);
+return;
+}
+// close all other browser windows
+this._forEachBrowserWindow(function(aWindow) {
+if (aWindow != window) {
+aWindow.close();
+this.onClose(aWindow);
+}
+});
+// make sure closed window data isn't kept
+this._closedWindows = [];
+// 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 to the given state
+this.restoreWindow(window, state, {overwriteTabs: true});
+},
+getWindowState: function ssi_getWindowState(aWindow) {
+if ("__SSi" in aWindow) {
+return this._toJSONString(this._getWindowState(aWindow));
+}
+if (DyingWindowCache.has(aWindow)) {
+let data = DyingWindowCache.get(aWindow);
+return this._toJSONString({ 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.restoreWindow(aWindow, aState, {overwriteTabs: aOverwrite});
+},
+getTabState: function ssi_getTabState(aTab) {
+if (!aTab.ownerDocument) {
+throw Components.Exception("Invalid tab object: no ownerDocument", Cr.NS_ERROR_INVALID_ARG);
+}
+if (!aTab.ownerDocument.defaultView.__SSi) {
+throw Components.Exception("Default view is not tracked", Cr.NS_ERROR_INVALID_ARG);
+}
+let tabState = TabState.collect(aTab);
+return this._toJSONString(tabState);
+},
+setTabState: function ssi_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 = 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);
+}
+if (!aTab.ownerDocument) {
+throw Components.Exception("Invalid tab object: no ownerDocument", Cr.NS_ERROR_INVALID_ARG);
+}
+let window = aTab.ownerDocument.defaultView;
+if (!("__SSi" in window)) {
+throw Components.Exception("Window is not tracked", Cr.NS_ERROR_INVALID_ARG);
+}
+if (aTab.linkedBrowser.__SS_restoreState) {
+this._resetTabRestoringState(aTab);
+}
+this._setWindowStateBusy(window);
+this.restoreTabs(window, [aTab], [tabState], 0);
+},
+duplicateTab: function ssi_duplicateTab(aWindow, aTab, aDelta = 0) {
+if (!aTab.ownerDocument) {
+throw Components.Exception("Invalid tab object: no ownerDocument", Cr.NS_ERROR_INVALID_ARG);
+}
+if (!aTab.ownerDocument.defaultView.__SSi) {
+throw Components.Exception("Default view is not tracked", Cr.NS_ERROR_INVALID_ARG);
+}
+if (!aWindow.getBrowser) {
+throw Components.Exception("Invalid window object: no getBrowser", Cr.NS_ERROR_INVALID_ARG);
+}
+// Flush all data queued in the content script because we will need that
+// state to properly duplicate the given tab.
+TabState.flush(aTab.linkedBrowser);
+// Duplicate the tab state
+let tabState = TabState.clone(aTab);
+tabState.index += aDelta;
+tabState.index = Math.max(1, Math.min(tabState.index, tabState.entries.length));
+tabState.pinned = false;
+this._setWindowStateBusy(aWindow);
+let newTab = aTab == aWindow.gBrowser.selectedTab ?
+aWindow.gBrowser.addTab(null, {relatedToCurrent: true, ownerTab: aTab}) :
+aWindow.gBrowser.addTab();
+this.restoreTabs(aWindow, [newTab], [tabState], 0,
+true /* Load this tab right away. */);
+return newTab;
+},
+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_getClosedTabDataAt(aWindow) {
+if ("__SSi" in aWindow) {
+return this._toJSONString(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 this._toJSONString(data._closedTabs);
+},
+undoCloseTab: function ssi_undoCloseTab(aWindow, aIndex) {
+if (!aWindow.__SSi) {
+throw Components.Exception("Window is not tracked", Cr.NS_ERROR_INVALID_ARG);
+}
+var closedTabs = this._windows[aWindow.__SSi]._closedTabs;
+// default to the most-recently closed tab
+aIndex = aIndex || 0;
+if (!(aIndex in 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 closedTab = closedTabs.splice(aIndex, 1).shift();
+let closedTabState = closedTab.state;
+this._setWindowStateBusy(aWindow);
+// create a new tab
+let tabbrowser = aWindow.gBrowser;
+let tab = tabbrowser.addTab();
+// restore tab content
+this.restoreTabs(aWindow, [tab], [closedTabState], 1);
+// restore the tab's position
+tabbrowser.moveTabTo(tab, closedTab.pos);
+// focus the tab's content area (bug 342432)
+tab.linkedBrowser.focus();
+return tab;
+},
+forgetClosedTab: function ssi_forgetClosedTab(aWindow, aIndex) {
+if (!aWindow.__SSi) {
+throw Components.Exception("Window is not tracked", Cr.NS_ERROR_INVALID_ARG);
+}
+var closedTabs = this._windows[aWindow.__SSi]._closedTabs;
+// default to the most-recently closed tab
+aIndex = aIndex || 0;
+if (!(aIndex in closedTabs)) {
+throw Components.Exception("Invalid index: not in the closed tabs", Cr.NS_ERROR_INVALID_ARG);
+}
+// remove closed tab from the array
+closedTabs.splice(aIndex, 1);
+},
+getClosedWindowCount: function ssi_getClosedWindowCount() {
+return this._closedWindows.length;
+},
+getClosedWindowData: function ssi_getClosedWindowData() {
+return this._toJSONString(this._closedWindows);
+},
+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._closedWindows.splice(aIndex, 1) };
+let window = this._openWindowWithState(state);
+this.windowToFocus = window;
+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
+this._closedWindows.splice(aIndex, 1);
+},
+getWindowValue: function ssi_getWindowValue(aWindow, aKey) {
+if ("__SSi" in aWindow) {
+var 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);
+},
+setWindowValue: function ssi_setWindowValue(aWindow, aKey, aStringValue) {
+if (typeof aStringValue != "string") {
+throw new TypeError("setWindowValue 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);
+},
+deleteWindowValue: function ssi_deleteWindowValue(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);
+},
+getTabValue: function ssi_getTabValue(aTab, aKey) {
+let data = {};
+if (aTab.__SS_extdata) {
+data = aTab.__SS_extdata;
+}
+else if (aTab.linkedBrowser.__SS_data && aTab.linkedBrowser.__SS_data.extData) {
+// If the tab hasn't been fully restored, get the data from the to-be-restored data
+data = aTab.linkedBrowser.__SS_data.extData;
+}
+return data[aKey] || "";
+},
+setTabValue: function ssi_setTabValue(aTab, aKey, aStringValue) {
+if (typeof aStringValue != "string") {
+throw new TypeError("setTabValue only accepts string values");
+}
+// If the tab hasn't been restored, then set the data there, otherwise we
+// could lose newly added data.
+let saveTo;
+if (aTab.__SS_extdata) {
+saveTo = aTab.__SS_extdata;
+}
+else if (aTab.linkedBrowser.__SS_data && aTab.linkedBrowser.__SS_data.extData) {
+saveTo = aTab.linkedBrowser.__SS_data.extData;
+}
+else {
+aTab.__SS_extdata = {};
+saveTo = aTab.__SS_extdata;
+}
+saveTo[aKey] = aStringValue;
+this.saveStateDelayed(aTab.ownerDocument.defaultView);
+},
+deleteTabValue: function ssi_deleteTabValue(aTab, aKey) {
+// We want to make sure that if data is accessed early, we attempt to delete
+// that data from __SS_data as well. Otherwise we'll throw in cases where
+// data can be set or read.
+let deleteFrom;
+if (aTab.__SS_extdata) {
+deleteFrom = aTab.__SS_extdata;
+}
+else if (aTab.linkedBrowser.__SS_data && aTab.linkedBrowser.__SS_data.extData) {
+deleteFrom = aTab.linkedBrowser.__SS_data.extData;
+}
+if (deleteFrom && aKey in deleteFrom) {
+delete deleteFrom[aKey];
+this.saveStateDelayed(aTab.ownerDocument.defaultView);
+}
+},
+getGlobalValue: function ssi_getGlobalValue(aKey) {
+return this._globalState.get(aKey);
+},
+setGlobalValue: function ssi_setGlobalValue(aKey, aStringValue) {
+if (typeof aStringValue != "string") {
+throw new TypeError("setGlobalValue only accepts string values");
+}
+this._globalState.set(aKey, aStringValue);
+this.saveStateDelayed();
+},
+deleteGlobalValue: function ssi_deleteGlobalValue(aKey) {
+this._globalState.delete(aKey);
+this.saveStateDelayed();
+},
+persistTabAttribute: function ssi_persistTabAttribute(aName) {
+if (TabAttributes.persist(aName)) {
+this.saveStateDelayed();
+}
+},
+/**
+* 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 winddow. 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");
+}
+// First collect each window with its id...
+let windows = {};
+this._forEachBrowserWindow(function(aWindow) {
+if (aWindow.__SS_lastSessionWindowID)
+windows[aWindow.__SS_lastSessionWindowID] = aWindow;
+});
+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._getMostRecentBrowserWindow();
+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);
+// 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);
+}
+// Restore into that window - pretend it's a followup since we'll already
+// have a focused window.
+//XXXzpao This is going to merge extData together (taking what was in
+//        winState over what is in the window already. The hack we have
+//        in _preWindowToRestoreInto will prevent most (all?) Panorama
+//        weirdness but we will still merge other extData.
+//        Bug 588217 should make this go away by merging the group data.
+let options = {overwriteTabs: canOverwriteTabs, isFollowUp: true};
+this.restoreWindow(windowToUse, { windows: [winState] }, options);
+}
+else {
+this._openWindowWithState({ windows: [winState] });
+}
+}
+// Merge closed windows from this session with ones from last session
+if (lastSessionState._closedWindows) {
+this._closedWindows = this._closedWindows.concat(lastSessionState._closedWindows);
+this._capClosedWindows();
+}
+if (lastSessionState.scratchpads) {
+ScratchpadManager.restoreSession(lastSessionState.scratchpads);
+}
+// 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();
+},
+/**
+* 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;
+// Step 1 of processing:
+// Inspect extData for Panorama identifiers. If found, then we want to
+// inspect further. If there is a single group, then we can use this
+// window. If there are multiple groups then we won't use this window.
+let groupsData = this.getWindowValue(aWindow, "tabview-groups");
+if (groupsData) {
+groupsData = JSON.parse(groupsData);
+// If there are multiple groups, we don't want to use this window.
+if (groupsData.totalNumber > 1)
+return [false, false];
+}
+// Step 2 of processing:
+// If we're still here, then the window is usable. 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 normalTabsLen = tabbrowser.tabs.length - tabbrowser._numPinnedTabs;
+let startupPref = this._prefBranch.getIntPref("startup.page");
+if (startupPref == 1)
+homePages = homePages.concat(aWindow.gHomeButton.getHomePage().split("|"));
+for (let i = tabbrowser._numPinnedTabs; i < tabbrowser.tabs.length; i++) {
+let tab = tabbrowser.tabs[i];
+if (homePages.indexOf(tab.linkedBrowser.currentURI.spec) != -1) {
+removableTabs.push(tab);
+}
+}
+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);
+var hidden = WINDOW_HIDEABLE_FEATURES.filter(function(aItem) {
+return aWindow[aItem] && !aWindow[aItem].visible;
+});
+if (hidden.length != 0)
+winData.hidden = hidden.join(",");
+else if (winData.hidden)
+delete winData.hidden;
+var sidebar = aWindow.document.getElementById("sidebar-box").getAttribute("sidebarcommand");
+if (sidebar)
+winData.sidebar = sidebar;
+else if (winData.sidebar)
+delete winData.sidebar;
+},
+/**
+* gather session data as object
+* @param aUpdateAll
+*        Bool update all windows
+* @returns object
+*/
+getCurrentState: function (aUpdateAll) {
+this._handleClosedWindows();
+var activeWindow = this._getMostRecentBrowserWindow();
+TelemetryStopwatch.start("FX_SESSION_RESTORE_COLLECT_ALL_WINDOWS_DATA_MS");
+if (this._loadState == STATE_RUNNING) {
+// update the data for all windows with activities since the last save operation
+this._forEachBrowserWindow(function(aWindow) {
+if (!this._isWindowLoaded(aWindow)) // window data is still in _statesToRestore
+return;
+if (aUpdateAll || DirtyWindows.has(aWindow) || aWindow == activeWindow) {
+this._collectWindowData(aWindow);
+}
+else { // always update the window features (whose change alone never triggers a save operation)
+this._updateWindowFeatures(aWindow);
+}
+});
+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++;
+}
+TelemetryStopwatch.start("FX_SESSION_RESTORE_COLLECT_COOKIES_MS");
+SessionCookies.update(total);
+TelemetryStopwatch.finish("FX_SESSION_RESTORE_COLLECT_COOKIES_MS");
+// collect the data for all windows yet to be restored
+for (ix in this._statesToRestore) {
+for each (let winData in this._statesToRestore[ix].windows) {
+total.push(winData);
+if (!winData.isPopup)
+nonPopupCount++;
+}
+}
+// shallow copy this._closedWindows to preserve current state
+let lastClosedWindowsCopy = this._closedWindows.slice();
+#ifndef XP_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 > 0 &&
+this._loadState == STATE_QUITTING) {
+// 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 > 0)
+}
+#endif
+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
+};
+// get open Scratchpad window states too
+let scratchpads = ScratchpadManager.getSessionState();
+let state = {
+windows: total,
+selectedWindow: ix + 1,
+_closedWindows: lastClosedWindowsCopy,
+session: session,
+scratchpads: scratchpads,
+global: this._globalState.getState()
+};
+// 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[aWindow.__SS_restoreID];
+if (this._loadState == STATE_RUNNING) {
+this._collectWindowData(aWindow);
+}
+let windows = [this._windows[aWindow.__SSi]];
+SessionCookies.update(windows);
+return { windows: windows };
+},
+_collectWindowData: function ssi_collectWindowData(aWindow) {
+if (!this._isWindowLoaded(aWindow))
+return;
+TelemetryStopwatch.start("FX_SESSION_RESTORE_COLLECT_SINGLE_WINDOW_DATA_MS");
+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) {
+tabsData.push(TabState.collect(tab));
+}
+winData.selected = tabbrowser.mTabBox.selectedIndex + 1;
+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);
+TelemetryStopwatch.finish("FX_SESSION_RESTORE_COLLECT_SINGLE_WINDOW_DATA_MS");
+},
+/* ........ Restoring Functionality .............. */
+/**
+* restore features to a single window
+* @param aWindow
+*        Window reference
+* @param aState
+*        JS object or its eval'able source
+* @param aOptions
+*        {overwriteTabs: true} to overwrite existing tabs w/ new ones
+*        {isFollowUp: true} if this is not the restoration of the 1st window
+*        {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, aState, aOptions = {}) {
+let overwriteTabs = aOptions && aOptions.overwriteTabs;
+let isFollowUp = aOptions && aOptions.isFollowUp;
+let firstWindow = aOptions && aOptions.firstWindow;
+if (isFollowUp) {
+this.windowToFocus = aWindow;
+}
+// initialize window if necessary
+if (aWindow && (!aWindow.__SSi || !this._windows[aWindow.__SSi]))
+this.onLoad(aWindow);
+try {
+var root = typeof aState == "string" ? JSON.parse(aState) : aState;
+if (!root.windows[0]) {
+this._sendRestoreCompletedNotifications();
+return; // nothing to restore
+}
+}
+catch (ex) { // invalid state object - don't restore anything
+debug(ex);
+this._sendRestoreCompletedNotifications();
+return;
+}
+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._setWindowStateBusy(aWindow);
+if (root._closedWindows)
+this._closedWindows = root._closedWindows;
+var winData;
+if (!root.selectedWindow || root.selectedWindow > root.windows.length) {
+root.selectedWindow = 0;
+}
+// open new windows for all further window entries of a multi-window session
+// (unless they don't contain any tab data)
+for (var w = 1; w < root.windows.length; w++) {
+winData = root.windows[w];
+if (winData && winData.tabs && winData.tabs[0]) {
+var window = this._openWindowWithState({ windows: [winData] });
+if (w == root.selectedWindow - 1) {
+this.windowToFocus = window;
+}
+}
+}
+winData = root.windows[0];
+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 == 0)) {
+winData.tabs = [];
+}
+var tabbrowser = aWindow.gBrowser;
+var openTabCount = overwriteTabs ? tabbrowser.browsers.length : -1;
+var newTabCount = winData.tabs.length;
+var tabs = [];
+// disable smooth scrolling while adding, moving, removing and selecting tabs
+var tabstrip = tabbrowser.tabContainer.mTabstrip;
+var smoothScroll = tabstrip.smoothScroll;
+tabstrip.smoothScroll = false;
+// unpin all tabs to ensure they are not reordered in the next loop
+if (overwriteTabs) {
+for (let t = tabbrowser._numPinnedTabs - 1; t > -1; t--)
+tabbrowser.unpinTab(tabbrowser.tabs[t]);
+}
+// 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.slice(tabbrowser.tabs);
+}
+// make sure that the selected tab won't be closed in order to
+// prevent unnecessary flickering
+if (overwriteTabs && tabbrowser.selectedTab._tPos >= newTabCount)
+tabbrowser.moveTabTo(tabbrowser.selectedTab, newTabCount - 1);
+let numVisibleTabs = 0;
+for (var t = 0; t < newTabCount; t++) {
+tabs.push(t < openTabCount ?
+tabbrowser.tabs[t] :
+tabbrowser.addTab("about:blank", {skipAnimation: true}));
+if (winData.tabs[t].pinned)
+tabbrowser.pinTab(tabs[t]);
+if (winData.tabs[t].hidden) {
+tabbrowser.hideTab(tabs[t]);
+}
+else {
+tabbrowser.showTab(tabs[t]);
+numVisibleTabs++;
+}
+}
+if (!overwriteTabs && firstWindow) {
+// Move the originally open tabs to the end
+let endPosition = tabbrowser.tabs.length - 1;
+for (let i = 0; i < initialTabs.length; i++) {
+tabbrowser.moveTabTo(initialTabs[i], endPosition);
+}
+}
+// if all tabs to be restored are hidden, make the first one visible
+if (!numVisibleTabs && winData.tabs.length) {
+winData.tabs[0].hidden = false;
+tabbrowser.showTab(tabs[0]);
+}
+// If overwriting tabs, we want to reset each tab's "restoring" state. Since
+// we're overwriting those tabs, they should no longer be restoring. The
+// tabs will be rebuilt and marked if they need to be restored after loading
+// state (in restoreTabs).
+if (overwriteTabs) {
+for (let i = 0; i < tabbrowser.tabs.length; i++) {
+let tab = tabbrowser.tabs[i];
+if (tabbrowser.browsers[i].__SS_restoreState)
+this._resetTabRestoringState(tab);
+}
+}
+// 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;
+// when overwriting tabs, remove all superflous ones
+if (overwriteTabs && newTabCount < openTabCount) {
+Array.slice(tabbrowser.tabs, newTabCount, openTabCount)
+.forEach(tabbrowser.removeTab, tabbrowser);
+}
+if (overwriteTabs) {
+this.restoreWindowFeatures(aWindow, winData);
+delete this._windows[aWindow.__SSi].extData;
+}
+if (winData.cookies) {
+this.restoreCookies(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 || [];
+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);
+}
+this.restoreTabs(aWindow, tabs, winData.tabs,
+(overwriteTabs ? (parseInt(winData.selected || "1")) : 0));
+if (aState.scratchpads) {
+ScratchpadManager.restoreSession(aState.scratchpads);
+}
+// set smoothScroll back to the original value
+tabstrip.smoothScroll = smoothScroll;
+TelemetryStopwatch.finish("FX_SESSION_RESTORE_RESTORE_WINDOW_MS");
+this._sendRestoreCompletedNotifications();
+},
+/**
+* Sets the tabs restoring order with the following priority:
+* Selected tab, pinned tabs, optimized visible tabs, other visible tabs and
+* hidden tabs.
+* @param aTabBrowser
+*        Tab browser object
+* @param aTabs
+*        Array of tab references
+* @param aTabData
+*        Array of tab data
+* @param aSelectedTab
+*        Index of selected tab (1 is first tab, 0 no selected tab)
+*/
+_setTabsRestoringOrder : function ssi__setTabsRestoringOrder(
+aTabBrowser, aTabs, aTabData, aSelectedTab) {
+// Store the selected tab. Need to substract one to get the index in aTabs.
+let selectedTab;
+if (aSelectedTab > 0 && aTabs[aSelectedTab - 1]) {
+selectedTab = aTabs[aSelectedTab - 1];
+}
+// Store the pinned tabs and hidden tabs.
+let pinnedTabs = [];
+let pinnedTabsData = [];
+let hiddenTabs = [];
+let hiddenTabsData = [];
+if (aTabs.length > 1) {
+for (let t = aTabs.length - 1; t >= 0; t--) {
+if (aTabData[t].pinned) {
+pinnedTabs.unshift(aTabs.splice(t, 1)[0]);
+pinnedTabsData.unshift(aTabData.splice(t, 1)[0]);
+} else if (aTabData[t].hidden) {
+hiddenTabs.unshift(aTabs.splice(t, 1)[0]);
+hiddenTabsData.unshift(aTabData.splice(t, 1)[0]);
+}
+}
+}
+// Optimize the visible tabs only if there is a selected tab.
+if (selectedTab) {
+let selectedTabIndex = aTabs.indexOf(selectedTab);
+if (selectedTabIndex > 0) {
+let scrollSize = aTabBrowser.tabContainer.mTabstrip.scrollClientSize;
+let tabWidth = aTabs[0].getBoundingClientRect().width;
+let maxVisibleTabs = Math.ceil(scrollSize / tabWidth);
+if (maxVisibleTabs < aTabs.length) {
+let firstVisibleTab = 0;
+let nonVisibleTabsCount = aTabs.length - maxVisibleTabs;
+if (nonVisibleTabsCount >= selectedTabIndex) {
+// Selected tab is leftmost since we scroll to it when possible.
+firstVisibleTab = selectedTabIndex;
+} else {
+// Selected tab is rightmost or no more room to scroll right.
+firstVisibleTab = nonVisibleTabsCount;
+}
+aTabs = aTabs.splice(firstVisibleTab, maxVisibleTabs).concat(aTabs);
+aTabData =
+aTabData.splice(firstVisibleTab, maxVisibleTabs).concat(aTabData);
+}
+}
+}
+// Merge the stored tabs in order.
+aTabs = pinnedTabs.concat(aTabs, hiddenTabs);
+aTabData = pinnedTabsData.concat(aTabData, hiddenTabsData);
+// Load the selected tab to the first position and select it.
+if (selectedTab) {
+let selectedTabIndex = aTabs.indexOf(selectedTab);
+if (selectedTabIndex > 0) {
+aTabs = aTabs.splice(selectedTabIndex, 1).concat(aTabs);
+aTabData = aTabData.splice(selectedTabIndex, 1).concat(aTabData);
+}
+aTabBrowser.selectedTab = selectedTab;
+}
+return [aTabs, aTabData];
+},
+/**
+* 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 selected tab
+* @param aRestoreImmediately
+*        Flag to indicate whether the given set of tabs aTabs should be
+*        restored/loaded immediately even if restore_on_demand = true
+*/
+restoreTabs: function (aWindow, aTabs, aTabData, aSelectTab,
+aRestoreImmediately = false)
+{
+var tabbrowser = aWindow.gBrowser;
+if (!this._isWindowLoaded(aWindow)) {
+// from now on, the data will come from the actual window
+delete this._statesToRestore[aWindow.__SS_restoreID];
+delete aWindow.__SS_restoreID;
+delete this._windows[aWindow.__SSi]._restoring;
+}
+// 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(aWindow);
+// Set the state to restore as the window's current state. Normally, this
+// will just be overridden the next time we collect state but we need this
+// as a fallback should Firefox be shutdown early without notifying us
+// beforehand.
+this._windows[aWindow.__SSi].tabs = aTabData.slice();
+this._windows[aWindow.__SSi].selected = aSelectTab;
+if (aTabs.length == 0) {
+// This is normally done later, but as we're returning early
+// here we need to take care of it.
+this._setWindowStateReady(aWindow);
+return;
+}
+// Sets the tabs restoring order.
+[aTabs, aTabData] =
+this._setTabsRestoringOrder(tabbrowser, aTabs, aTabData, aSelectTab);
+// Prepare the tabs so that they can be properly restored. We'll pin/unpin
+// and show/hide tabs as necessary. We'll also set the labels, user typed
+// value, and attach a copy of the tab's data in case we close it before
+// it's been restored.
+for (let t = 0; t < aTabs.length; t++) {
+let tab = aTabs[t];
+let browser = tabbrowser.getBrowserForTab(tab);
+let tabData = aTabData[t];
+if (tabData.pinned)
+tabbrowser.pinTab(tab);
+else
+tabbrowser.unpinTab(tab);
+if (tabData.hidden)
+tabbrowser.hideTab(tab);
+else
+tabbrowser.showTab(tab);
+if (tabData.lastAccessed) {
+tab.lastAccessed = tabData.lastAccessed;
+}
+if ("attributes" in tabData) {
+// Ensure that we persist tab attributes restored from previous sessions.
+Object.keys(tabData.attributes).forEach(a => TabAttributes.persist(a));
+}
+if (!tabData.entries) {
+tabData.entries = [];
+}
+if (tabData.extData) {
+tab.__SS_extdata = {};
+for (let key in tabData.extData)
+tab.__SS_extdata[key] = tabData.extData[key];
+} else {
+delete tab.__SS_extdata;
+}
+// Flush all data from the content script synchronously. This is done so
+// that all async messages that are still on their way to chrome will
+// be ignored and don't override any tab data set when restoring.
+TabState.flush(tab.linkedBrowser);
+// 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;
+// In electrolysis, we may need to change the browser's remote
+// attribute so that it runs in a content process.
+let activePageData = tabData.entries[activeIndex] || null;
+let uri = activePageData ? activePageData.url || null : null;
+tabbrowser.updateBrowserRemoteness(browser, uri);
+// Start a new epoch and include the epoch in the restoreHistory
+// message. If a message is received that relates to a previous epoch, we
+// discard it.
+let epoch = this._nextRestoreEpoch++;
+this._browserEpochs.set(browser.permanentKey, epoch);
+// keep the data around to prevent dataloss in case
+// a tab gets closed before it's been properly restored
+browser.__SS_data = tabData;
+browser.__SS_restoreState = TAB_STATE_NEEDS_RESTORE;
+browser.setAttribute("pending", "true");
+tab.setAttribute("pending", "true");
+// Update the persistent tab state cache with |tabData| information.
+TabStateCache.update(browser, {
+history: {entries: tabData.entries, index: tabData.index},
+scroll: tabData.scroll || null,
+storage: tabData.storage || null,
+formdata: tabData.formdata || null,
+disallow: tabData.disallow || null,
+pageStyle: tabData.pageStyle || null
+});
+browser.messageManager.sendAsyncMessage("SessionStore:restoreHistory",
+{tabData: tabData, epoch: epoch});
+// Restore tab attributes.
+if ("attributes" in tabData) {
+TabAttributes.set(tab, tabData.attributes);
+}
+// This could cause us to ignore MAX_CONCURRENT_TAB_RESTORES a bit, but
+// it ensures each window will have its selected tab loaded.
+if (aRestoreImmediately || tabbrowser.selectedBrowser == browser) {
+this.restoreTabContent(tab);
+} else {
+TabRestoreQueue.add(tab);
+this.restoreNextTab();
+}
+}
+this._setWindowStateReady(aWindow);
+},
+/**
+* Restores the specified tab. If the tab can't be restored (eg, no history or
+* calling gotoIndex fails), then state changes will be rolled back.
+* This method will check if gTabsProgressListener is attached to the tab's
+* window, ensuring that we don't get caught without one.
+* This method removes the session history listener right before starting to
+* attempt a load. This will prevent cases of "stuck" listeners.
+* If this method returns false, then it is up to the caller to decide what to
+* do. In the common case (restoreNextTab), we will want to then attempt to
+* restore the next tab. In the other case (selecting the tab, reloading the
+* tab), the caller doesn't actually want to do anything if no page is loaded.
+*
+* @param aTab
+*        the tab to restore
+*
+* @returns true/false indicating whether or not a load actually happened
+*/
+restoreTabContent: function (aTab) {
+let window = aTab.ownerDocument.defaultView;
+let browser = aTab.linkedBrowser;
+let tabData = browser.__SS_data;
+// 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
+browser.__SS_restoreState = TAB_STATE_RESTORING;
+browser.removeAttribute("pending");
+aTab.removeAttribute("pending");
+let activeIndex = tabData.index - 1;
+// Attach data that will be restored on "load" event, after tab is restored.
+if (tabData.entries.length) {
+// restore those aspects of the currently active documents which are not
+// preserved in the plain history entries (mainly scroll state and text data)
+browser.__SS_restore_data = tabData.entries[activeIndex] || {};
+} else {
+browser.__SS_restore_data = {};
+}
+browser.__SS_restore_tab = aTab;
+browser.messageManager.sendAsyncMessage("SessionStore:restoreTabContent");
+},
+/**
+* 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 (this._loadState == STATE_QUITTING)
+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.indexOf(aItem) == -1;
+});
+if (aWinData.isPopup) {
+this._windows[aWindow.__SSi].isPopup = true;
+if (aWindow.gURLBar) {
+aWindow.gURLBar.readOnly = true;
+aWindow.gURLBar.setAttribute("enablehistory", "false");
+}
+}
+else {
+delete this._windows[aWindow.__SSi].isPopup;
+if (aWindow.gURLBar) {
+aWindow.gURLBar.readOnly = false;
+aWindow.gURLBar.setAttribute("enablehistory", "true");
+}
+}
+var _this = this;
+aWindow.setTimeout(function() {
+_this.restoreDimensions.apply(_this, [aWindow,
++aWinData.width || 0,
++aWinData.height || 0,
+"screenX" in aWinData ? +aWinData.screenX : NaN,
+"screenY" in aWinData ? +aWinData.screenY : NaN,
+aWinData.sizemode || "", aWinData.sidebar || ""]);
+}, 0);
+},
+/**
+* Restore a window's dimensions
+* @param aWidth
+*        Window width
+* @param aHeight
+*        Window height
+* @param aLeft
+*        Window left
+* @param aTop
+*        Window top
+* @param aSizeMode
+*        Window size mode (eg: maximized)
+* @param aSidebar
+*        Sidebar command
+*/
+restoreDimensions: function ssi_restoreDimensions(aWindow, aWidth, aHeight, aLeft, aTop, aSizeMode, aSidebar) {
+var win = aWindow;
+var _this = this;
+function win_(aName) { return _this._getWindowDimension(win, aName); }
+// find available space on the screen where this window is being placed
+let screen = gScreenManager.screenForRect(aLeft, aTop, aWidth, aHeight);
+if (screen) {
+let screenLeft = {}, screenTop = {}, screenWidth = {}, screenHeight = {};
+screen.GetAvailRectDisplayPix(screenLeft, screenTop, screenWidth, screenHeight);
+// constrain the dimensions to the actual space available
+if (aWidth > screenWidth.value) {
+aWidth = screenWidth.value;
+}
+if (aHeight > screenHeight.value) {
+aHeight = screenHeight.value;
+}
+// and then pull the window within the screen's bounds
+if (aLeft < screenLeft.value) {
+aLeft = screenLeft.value;
+} else if (aLeft + aWidth > screenLeft.value + screenWidth.value) {
+aLeft = screenLeft.value + screenWidth.value - aWidth;
+}
+if (aTop < screenTop.value) {
+aTop = screenTop.value;
+} else if (aTop + aHeight > screenTop.value + screenHeight.value) {
+aTop = screenTop.value + screenHeight.value - aHeight;
+}
+}
+// only modify those aspects which aren't correct yet
+if (aWidth && aHeight && (aWidth != win_("width") || aHeight != win_("height"))) {
+// 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);
+}
+}
+if (!isNaN(aLeft) && !isNaN(aTop) && (aLeft != win_("screenX") || aTop != win_("screenY"))) {
+aWindow.moveTo(aLeft, aTop);
+}
+if (aSizeMode && win_("sizemode") != aSizeMode)
+{
+switch (aSizeMode)
+{
+case "maximized":
+aWindow.maximize();
+break;
+case "minimized":
+aWindow.minimize();
+break;
+case "normal":
+aWindow.restore();
+break;
+}
+}
+var sidebar = aWindow.document.getElementById("sidebar-box");
+if (sidebar.getAttribute("sidebarcommand") != aSidebar) {
+aWindow.toggleSidebar(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();
+}
+},
+/**
+* Restores cookies
+* @param aCookies
+*        Array of cookie objects
+*/
+restoreCookies: function ssi_restoreCookies(aCookies) {
+// MAX_EXPIRY should be 2^63-1, but JavaScript can't handle that precision
+var MAX_EXPIRY = Math.pow(2, 62);
+for (let i = 0; i < aCookies.length; i++) {
+var cookie = aCookies[i];
+try {
+Services.cookies.add(cookie.host, cookie.path || "", cookie.name || "",
+cookie.value, !!cookie.secure, !!cookie.httponly, true,
+"expiry" in cookie ? cookie.expiry : MAX_EXPIRY);
+}
+catch (ex) { console.error(ex); } // don't let a single cookie stop recovering
+}
+},
+/* ........ 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: function (aWindow = null) {
+if (aWindow) {
+DirtyWindows.add(aWindow);
+}
+SessionSaver.runDelayed();
+},
+/* ........ Auxiliary Functions .............. */
+/**
+* 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;
+// ms to days
+let sessionLength = (Date.now() - this._sessionStartTime) / MS_PER_DAY;
+if (sessionLength > 0) {
+// Submit the session length telemetry measurement
+Services.telemetry.getHistogramById("FX_SESSION_RESTORE_SESSION_LENGTH").add(sessionLength);
+}
+}
+},
+/**
+* call a callback for all currently opened browser windows
+* (might miss the most recent one)
+* @param aFunc
+*        Callback each window is passed to
+*/
+_forEachBrowserWindow: function ssi_forEachBrowserWindow(aFunc) {
+var windowsEnum = Services.wm.getEnumerator("navigator:browser");
+while (windowsEnum.hasMoreElements()) {
+var window = windowsEnum.getNext();
+if (window.__SSi && !window.closed) {
+aFunc.call(this, window);
+}
+}
+},
+/**
+* Returns most recent window
+* @returns Window reference
+*/
+_getMostRecentBrowserWindow: function ssi_getMostRecentBrowserWindow() {
+return RecentWindow.getMostRecentBrowserWindow({ 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() {
+var windowsEnum = Services.wm.getEnumerator("navigator:browser");
+while (windowsEnum.hasMoreElements()) {
+var window = windowsEnum.getNext();
+if (window.closed) {
+this.onClose(window);
+}
+}
+},
+/**
+* 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 = "chrome,dialog=no,macsuppressanimation,all";
+let winState = aState.windows[0];
+WINDOW_ATTRIBUTES.forEach(function(aFeature) {
+// Use !isNaN as an easy way to ignore sizemode and check for numbers
+if (aFeature in winState && !isNaN(winState[aFeature]))
+features += "," + aFeature + "=" + winState[aFeature];
+});
+if (winState.isPrivate) {
+features += ",private";
+}
+var window =
+Services.ww.openWindow(null, this._prefBranch.getCharPref("chromeURL"),
+"_blank", features, argString);
+do {
+var ID = "window" + Math.random();
+} while (ID in this._statesToRestore);
+this._statesToRestore[(window.__SS_restoreID = ID)] = aState;
+return window;
+},
+/**
+* Gets the tab for the given browser. This should be marginally better
+* than using tabbrowser's getTabForContentWindow. This assumes the browser
+* is the linkedBrowser of a tab, not a dangling browser.
+*
+* @param aBrowser
+*        The browser from which to get the tab.
+*/
+_getTabForBrowser: function ssi_getTabForBrowser(aBrowser) {
+let window = aBrowser.ownerDocument.defaultView;
+for (let i = 0; i < window.gBrowser.tabs.length; i++) {
+let tab = window.gBrowser.tabs[i];
+if (tab.linkedBrowser == aBrowser)
+return tab;
+}
+return undefined;
+},
+/**
+* Whether or not to resume session, if not recovering from a crash.
+* @returns bool
+*/
+_doResumeSession: function ssi_doResumeSession() {
+return this._prefBranch.getIntPref("startup.page") == 3 ||
+this._prefBranch.getBoolPref("sessionstore.resume_session_once");
+},
+/**
+* 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(function (win)
+win.tabs.every(function (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 XULWindow'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";
+}
+}
+var dimension;
+switch (aAttribute) {
+case "width":
+dimension = aWindow.outerWidth;
+break;
+case "height":
+dimension = aWindow.outerHeight;
+break;
+default:
+dimension = aAttribute in aWindow ? aWindow[aAttribute] : "";
+break;
+}
+if (aWindow.windowState == aWindow.STATE_NORMAL) {
+return dimension;
+}
+return aWindow.document.documentElement.getAttribute(aAttribute) || dimension;
+},
+/**
+* Get nsIURI from string
+* @param string
+* @returns nsIURI
+*/
+_getURIFromString: function ssi_getURIFromString(aString) {
+return Services.io.newURI(aString, null, null);
+},
+/**
+* @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 == 0)
+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);
+return max_resumed_crashes != -1 &&
+(aRecentCrashes > max_resumed_crashes ||
+sessionAge && sessionAge >= SIX_HOURS_IN_MS);
+},
+/**
+* @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: function(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.userTypedValue);
+},
+/**
+* This is going to take a state as provided at startup (via
+* nsISessionStartup.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 contain the cookies that go along with the history
+* entries in those tabs. 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 nsISessionStartup.state
+* @returns [defaultState, state]
+*/
+_prepDataForDeferredRestore: function ssi_prepDataForDeferredRestore(state) {
+// Make sure that we don't modify the global state as provided by
+// nsSessionStartup.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: [], cookies: []};
+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 + 2;
+// + 2 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();
+// Extract the cookies that belong with each pinned tab
+this._splitCookiesFromWindow(window, pinnedWindowState);
+// 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];
+},
+/**
+* Splits out the cookies from aWinState into aTargetWinState based on the
+* tabs that are in aTargetWinState.
+* This alters the state of aWinState and aTargetWinState.
+*/
+_splitCookiesFromWindow:
+function ssi_splitCookiesFromWindow(aWinState, aTargetWinState) {
+if (!aWinState.cookies || !aWinState.cookies.length)
+return;
+// Get the hosts for history entries in aTargetWinState
+let cookieHosts = SessionCookies.getHostsForWindow(aTargetWinState);
+// By creating a regex we reduce overhead and there is only one loop pass
+// through either array (cookieHosts and aWinState.cookies).
+let hosts = Object.keys(cookieHosts).join("|").replace("\\.", "\\.", "g");
+// If we don't actually have any hosts, then we don't want to do anything.
+if (!hosts.length)
+return;
+let cookieRegex = new RegExp(".*(" + hosts + ")");
+for (let cIndex = 0; cIndex < aWinState.cookies.length;) {
+if (cookieRegex.test(aWinState.cookies[cIndex].host)) {
+aTargetWinState.cookies =
+aTargetWinState.cookies.concat(aWinState.cookies.splice(cIndex, 1));
+continue;
+}
+cIndex++;
+}
+},
+/**
+* Converts a JavaScript object into a JSON string
+* (see http://www.json.org/ for more information).
+*
+* The inverse operation consists of JSON.parse(JSON_string).
+*
+* @param aJSObject is the object to be converted
+* @returns the object's JSON representation
+*/
+_toJSONString: function ssi_toJSONString(aJSObject) {
+return JSON.stringify(aJSObject);
+},
+_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.
+Services.obs.notifyObservers(null,
+this._browserSetState ? NOTIFY_BROWSER_STATE_RESTORED : NOTIFY_WINDOWS_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[aWindow.__SS_restoreID].windows[0];
+stateToRestore.busy = aValue;
+}
+},
+/**
+* Set the given window's state to 'not busy'.
+* @param aWindow the window
+*/
+_setWindowStateReady: function ssi_setWindowStateReady(aWindow) {
+this._setWindowStateBusyValue(aWindow, false);
+this._sendWindowStateEvent(aWindow, "Ready");
+},
+/**
+* Set the given window's state to 'busy'.
+* @param aWindow the window
+*/
+_setWindowStateBusy: function ssi_setWindowStateBusy(aWindow) {
+this._setWindowStateBusyValue(aWindow, true);
+this._sendWindowStateEvent(aWindow, "Busy");
+},
+/**
+* Dispatch an SSWindowState_____ event for the given window.
+* @param aWindow the window
+* @param aType the type of event, SSWindowState will be prepended to this string
+*/
+_sendWindowStateEvent: function ssi_sendWindowStateEvent(aWindow, aType) {
+let event = aWindow.document.createEvent("Events");
+event.initEvent("SSWindowState" + aType, true, false);
+aWindow.dispatchEvent(event);
+},
+/**
+* Dispatch the SSTabRestored event for the given tab.
+* @param aTab the which has been restored
+*/
+_sendTabRestoredNotification: function ssi_sendTabRestoredNotification(aTab) {
+let event = aTab.ownerDocument.createEvent("Events");
+event.initEvent("SSTabRestored", true, false);
+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 !aWindow.__SS_restoreID;
+},
+/**
+* Replace "Loading..." with the tab label (with minimal side-effects)
+* @param aString is the string the title is stored in
+* @param aTabbrowser is a tabbrowser object, containing aTab
+* @param aTab is the tab whose title we're updating & using
+*
+* @returns aString that has been updated with the new title
+*/
+_replaceLoadingTitle : function ssi_replaceLoadingTitle(aString, aTabbrowser, aTab) {
+if (aString == aTabbrowser.mStringBundle.getString("tabs.connecting")) {
+aTabbrowser.setTabTitle(aTab);
+[aString, aTab.label] = [aTab.label, aString];
+}
+return aString;
+},
+/**
+* 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;
+#ifndef XP_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;
+#endif
+this._closedWindows.splice(spliceTo, this._closedWindows.length);
+},
+/**
+* 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: function (aTab) {
+let window = aTab.ownerDocument.defaultView;
+let browser = aTab.linkedBrowser;
+// Keep the tab's previous state for later in this method
+let previousState = browser.__SS_restoreState;
+// The browser is no longer in any sort of restoring state.
+delete browser.__SS_restoreState;
+this._browserEpochs.delete(browser.permanentKey);
+aTab.removeAttribute("pending");
+browser.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: function (tab) {
+let browser = tab.linkedBrowser;
+if (browser.__SS_restoreState) {
+browser.messageManager.sendAsyncMessage("SessionStore:resetRestore", {});
+}
+this._resetLocalTabRestoringState(tab);
+},
+/**
+* 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: function (browser, epoch) {
+return this._browserEpochs.get(browser.permanentKey, 0) == epoch;
+},
+};
+/**
+* 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.
+*/
+let 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: value, configurable: true};
+Object.defineProperty(this, "restoreOnDemand", definition);
+return value;
+}
+const PREF = "browser.sessionstore.restore_on_demand";
+Services.prefs.addObserver(PREF, updateValue, false);
+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: value, configurable: true};
+Object.defineProperty(this, "restorePinnedTabsOnDemand", definition);
+return value;
+}
+const PREF = "browser.sessionstore.restore_pinned_tabs_on_demand";
+Services.prefs.addObserver(PREF, updateValue, false);
+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: value, configurable: true};
+Object.defineProperty(this, "restoreHiddenTabs", definition);
+return value;
+}
+const PREF = "browser.sessionstore.restore_hidden_tabs";
+Services.prefs.addObserver(PREF, updateValue, false);
+return updateValue();
+}
+},
+// Resets the queue and removes all tabs.
+reset: function () {
+this.tabs = {priority: [], visible: [], hidden: []};
+},
+// Adds a tab to the queue and determines its priority bucket.
+add: function (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: function (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: function () {
+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: function (tab) {
+let {hidden, visible} = this.tabs;
+let index = hidden.indexOf(tab);
+if (index > -1) {
+hidden.splice(index, 1);
+visible.push(tab);
+} else {
+throw new Error("restore queue: hidden tab not found");
+}
+},
+// Moves a given tab from the 'visible' to the 'hidden' bucket.
+visibleToHidden: function (tab) {
+let {visible, hidden} = this.tabs;
+let index = visible.indexOf(tab);
+if (index > -1) {
+visible.splice(index, 1);
+hidden.push(tab);
+} else {
+throw new Error("restore queue: visible tab not found");
+}
+}
+};
+// 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.
+let DyingWindowCache = {
+_data: new WeakMap(),
+has: function (window) {
+return this._data.has(window);
+},
+get: function (window) {
+return this._data.get(window);
+},
+set: function (window, data) {
+this._data.set(window, data);
+},
+remove: function (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.
+let DirtyWindows = {
+_data: new WeakMap(),
+has: function (window) {
+return this._data.has(window);
+},
+add: function (window) {
+return this._data.set(window, true);
+},
+remove: function (window) {
+this._data.delete(window);
+},
+clear: function (window) {
+this._data.clear();
+}
+};
+// 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
+let LastSession = {
+_state: null,
+get canRestore() {
+return !!this._state;
+},
+getState: function () {
+return this._state;
+},
+setState: function (state) {
+this._state = state;
+},
+clear: function () {
+if (this._state) {
+this._state = null;
+Services.obs.notifyObservers(null, NOTIFY_LAST_SESSION_CLEARED, null);
+}
+}
+};

The Tor Browser / file comparison

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

browser/components/sessionstore/src/SessionStore.jsm