The Tor Browser: browser/components/sessionstore/src/SessionStore.jsm@6474c204b198 (annotated)

browser/components/sessionstore/src/SessionStore.jsm@6474c204b198 (annotated)

browser/components/sessionstore/src/SessionStore.jsm

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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 / annotate

browser/components/sessionstore/src/SessionStore.jsm@6474c204b198 (annotated)

browser/components/sessionstore/src/SessionStore.jsm