gecko/browser/metro/components/SessionStore.js

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

const Cc = Components.classes;
const Ci = Components.interfaces;
const Cu = Components.utils;
const Cr = Components.results;

Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");
Cu.import("resource://gre/modules/WindowsPrefSync.jsm");

#ifdef MOZ_CRASHREPORTER
XPCOMUtils.defineLazyServiceGetter(this, "CrashReporter",
  "@mozilla.org/xre/app-info;1", "nsICrashReporter");
#endif

XPCOMUtils.defineLazyModuleGetter(this, "CrashMonitor",
  "resource://gre/modules/CrashMonitor.jsm");

XPCOMUtils.defineLazyServiceGetter(this, "gUUIDGenerator",
  "@mozilla.org/uuid-generator;1", "nsIUUIDGenerator");

XPCOMUtils.defineLazyGetter(this, "NetUtil", function() {
  Cu.import("resource://gre/modules/NetUtil.jsm");
  return NetUtil;
});

XPCOMUtils.defineLazyModuleGetter(this, "UITelemetry",
  "resource://gre/modules/UITelemetry.jsm");

// -----------------------------------------------------------------------
// Session Store
// -----------------------------------------------------------------------

const STATE_STOPPED = 0;
const STATE_RUNNING = 1;
const STATE_QUITTING = -1;

function SessionStore() { }

SessionStore.prototype = {
  classID: Components.ID("{8c1f07d6-cba3-4226-a315-8bd43d67d032}"),

  QueryInterface: XPCOMUtils.generateQI([Ci.nsISessionStore,
                                         Ci.nsIDOMEventListener,
                                         Ci.nsIObserver,
                                         Ci.nsISupportsWeakReference]),

  _windows: {},
  _tabsFromOtherGroups: [],
  _selectedWindow: 1,
  _orderedWindows: [],
  _lastSaveTime: 0,
  _lastSessionTime: 0,
  _interval: 10000,
  _maxTabsUndo: 1,
  _shouldRestore: false,

  // Tab telemetry variables
  _maxTabsOpen: 1,

  init: function ss_init() {
    // Get file references
    this._sessionFile = Services.dirsvc.get("ProfD", Ci.nsILocalFile);
    this._sessionFileBackup = this._sessionFile.clone();
    this._sessionCache = this._sessionFile.clone();
    this._sessionFile.append("sessionstore.js");
    this._sessionFileBackup.append("sessionstore.bak");
    this._sessionCache.append("sessionstoreCache");

    this._loadState = STATE_STOPPED;

    try {
      UITelemetry.addSimpleMeasureFunction("metro-tabs",
                                          this._getTabStats.bind(this));
    } catch (ex) {
      // swallow exception that occurs if metro-tabs measure is already set up
    }

    CrashMonitor.previousCheckpoints.then(checkpoints => {
      let previousSessionCrashed = false;

      if (checkpoints) {
        // If the previous session finished writing the final state, we'll
        // assume there was no crash.
        previousSessionCrashed = !checkpoints["sessionstore-final-state-write-complete"];
      } else {
        // If no checkpoints are saved, this is the first run with CrashMonitor or the
        // metroSessionCheckpoints file was corrupted/deleted, so fallback to defining
        // a crash as init-ing with an unexpected previousExecutionState
        // 1 == RUNNING, 2 == SUSPENDED
        previousSessionCrashed = Services.metro.previousExecutionState == 1 ||
          Services.metro.previousExecutionState == 2;
      }

      Services.telemetry.getHistogramById("SHUTDOWN_OK").add(!previousSessionCrashed);
    });

    try {
      let shutdownWasUnclean = false;

      if (this._sessionFileBackup.exists()) {
        this._sessionFileBackup.remove(false);
        shutdownWasUnclean = true;
      }

      if (this._sessionFile.exists()) {
        this._sessionFile.copyTo(null, this._sessionFileBackup.leafName);

        switch(Services.metro.previousExecutionState) {
          // 0 == NotRunning
          case 0:
            // Disable crash recovery if we have exceeded the timeout
            this._lastSessionTime = this._sessionFile.lastModifiedTime;
            let delta = Date.now() - this._lastSessionTime;
            let timeout =
              Services.prefs.getIntPref(
                  "browser.sessionstore.resume_from_crash_timeout");
            this._shouldRestore = shutdownWasUnclean
                                && (delta < (timeout * 60000));
            break;
          // 1 == Running
          case 1:
            // We should never encounter this situation
            Components.utils.reportError("SessionRestore.init called with "
                                       + "previous execution state 'Running'");
            this._shouldRestore = true;
            break;
          // 2 == Suspended
          case 2:
            // We should never encounter this situation
            Components.utils.reportError("SessionRestore.init called with "
                                       + "previous execution state 'Suspended'");
            this._shouldRestore = true;
            break;
          // 3 == Terminated
          case 3:
            // Terminated means that Windows terminated our already-suspended
            // process to get back some resources. When we re-launch, we want
            // to provide the illusion that our process was suspended the
            // whole time, and never terminated.
            this._shouldRestore = true;
            break;
          // 4 == ClosedByUser
          case 4:
            // ClosedByUser indicates that the user performed a "close" gesture
            // on our tile. We should act as if the browser closed normally,
            // even if we were closed from a suspended state (in which case
            // we'll have determined that it was an unclean shtudown)
            this._shouldRestore = false;
            break;
        }
      }

      if (!this._sessionCache.exists() || !this._sessionCache.isDirectory()) {
        this._sessionCache.create(Ci.nsIFile.DIRECTORY_TYPE, 0700);
      }
    } catch (ex) {
      Cu.reportError(ex); // file was write-locked?
    }

    this._interval = Services.prefs.getIntPref("browser.sessionstore.interval");
    this._maxTabsUndo = Services.prefs.getIntPref("browser.sessionstore.max_tabs_undo");

    // Disable crash recovery if it has been turned off
    if (!Services.prefs.getBoolPref("browser.sessionstore.resume_from_crash"))
      this._shouldRestore = false;

    // Do we need to restore session just this once, in case of a restart?
    if (Services.prefs.getBoolPref("browser.sessionstore.resume_session_once")) {
      Services.prefs.setBoolPref("browser.sessionstore.resume_session_once", false);
      this._shouldRestore = true;
    }
  },

  _clearDisk: function ss_clearDisk() {
    if (this._sessionFile.exists()) {
      try {
        this._sessionFile.remove(false);
      } catch (ex) { dump(ex + '\n'); } // couldn't remove the file - what now?
    }
    if (this._sessionFileBackup.exists()) {
      try {
        this._sessionFileBackup.remove(false);
      } catch (ex) { dump(ex + '\n'); } // couldn't remove the file - what now?
    }

    this._clearCache();
  },

  _clearCache: function ss_clearCache() {
    // First, let's get a list of files we think should be active
    let activeFiles = [];
    this._forEachBrowserWindow(function(aWindow) {
      let tabs = aWindow.Browser.tabs;
      for (let i = 0; i < tabs.length; i++) {
        let browser = tabs[i].browser;
        if (browser.__SS_extdata && "thumbnail" in browser.__SS_extdata)
          activeFiles.push(browser.__SS_extdata.thumbnail);
      }
    });

    // Now, let's find the stale files in the cache folder
    let staleFiles = [];
    let cacheFiles = this._sessionCache.directoryEntries;
    while (cacheFiles.hasMoreElements()) {
      let file = cacheFiles.getNext().QueryInterface(Ci.nsILocalFile);
      let fileURI = Services.io.newFileURI(file);
      if (activeFiles.indexOf(fileURI) == -1)
        staleFiles.push(file);
    }

    // Remove the stale files in a separate step to keep the enumerator from
    // messing up if we remove the files as we collect them.
    staleFiles.forEach(function(aFile) {
      aFile.remove(false);
    })
  },

  _getTabStats: function() {
    return {
      currTabCount: this._currTabCount,
      maxTabCount: this._maxTabsOpen
    };
  },

  observe: function ss_observe(aSubject, aTopic, aData) {
    let self = this;
    let observerService = Services.obs;
    switch (aTopic) {
      case "app-startup":
        observerService.addObserver(this, "final-ui-startup", true);
        observerService.addObserver(this, "domwindowopened", true);
        observerService.addObserver(this, "domwindowclosed", true);
        observerService.addObserver(this, "browser-lastwindow-close-granted", true);
        observerService.addObserver(this, "browser:purge-session-history", true);
        observerService.addObserver(this, "quit-application-requested", true);
        observerService.addObserver(this, "quit-application-granted", true);
        observerService.addObserver(this, "quit-application", true);
        observerService.addObserver(this, "reset-telemetry-vars", true);
        break;
      case "final-ui-startup":
        observerService.removeObserver(this, "final-ui-startup");
        if (WindowsPrefSync) {
          // Pulls in Desktop controlled prefs and pushes out Metro controlled prefs
          WindowsPrefSync.init();
        }
        this.init();
        break;
      case "domwindowopened":
        let window = aSubject;
        window.addEventListener("load", function() {
          self.onWindowOpen(window);
          window.removeEventListener("load", arguments.callee, false);
        }, false);
        break;
      case "domwindowclosed": // catch closed windows
        this.onWindowClose(aSubject);
        break;
      case "browser-lastwindow-close-granted":
        // If a save has been queued, kill the timer and save state now
        if (this._saveTimer) {
          this._saveTimer.cancel();
          this._saveTimer = null;
          this.saveState();
        }

        // Freeze the data at what we've got (ignoring closing windows)
        this._loadState = STATE_QUITTING;
        break;
      case "quit-application-requested":
        // Get a current snapshot of all windows
        this._forEachBrowserWindow(function(aWindow) {
          self._collectWindowData(aWindow);
        });
        break;
      case "quit-application-granted":
        // Get a current snapshot of all windows
        this._forEachBrowserWindow(function(aWindow) {
          self._collectWindowData(aWindow);
        });

        // Freeze the data at what we've got (ignoring closing windows)
        this._loadState = STATE_QUITTING;
        break;
      case "quit-application":
        // If we are restarting, lets restore the tabs
        if (aData == "restart") {
          Services.prefs.setBoolPref("browser.sessionstore.resume_session_once", true);

          // Ignore purges when restarting. The notification is fired after "quit-application".
          Services.obs.removeObserver(this, "browser:purge-session-history");
        }

        // Freeze the data at what we've got (ignoring closing windows)
        this._loadState = STATE_QUITTING;

        // No need for this back up, we are shutting down just fine
        if (this._sessionFileBackup.exists())
          this._sessionFileBackup.remove(false);

        observerService.removeObserver(this, "domwindowopened");
        observerService.removeObserver(this, "domwindowclosed");
        observerService.removeObserver(this, "browser-lastwindow-close-granted");
        observerService.removeObserver(this, "quit-application-requested");
        observerService.removeObserver(this, "quit-application-granted");
        observerService.removeObserver(this, "quit-application");
        observerService.removeObserver(this, "reset-telemetry-vars");

        // If a save has been queued, kill the timer and save state now
        if (this._saveTimer) {
          this._saveTimer.cancel();
          this._saveTimer = null;
        }
        this.saveState();
        break;
      case "browser:purge-session-history": // catch sanitization
        this._clearDisk();

        // 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;

        // Clear all data about closed tabs
        for (let [ssid, win] in Iterator(this._windows))
          win._closedTabs = [];

        if (this._loadState == STATE_RUNNING) {
          // Save the purged state immediately
          this.saveStateNow();
        }
        break;
      case "timer-callback":
        // Timer call back for delayed saving
        this._saveTimer = null;
        this.saveState();
        break;
      case "reset-telemetry-vars":
        // Used in mochitests only.
        this._maxTabsOpen = 1;
    }
  },

  updateTabTelemetryVars: function(window) {
    this._currTabCount = window.Browser.tabs.length;
      if (this._currTabCount > this._maxTabsOpen) {
        this._maxTabsOpen = this._currTabCount;
      }
  },

  handleEvent: function ss_handleEvent(aEvent) {
    let window = aEvent.currentTarget.ownerDocument.defaultView;
    switch (aEvent.type) {
      case "load":
        browser = aEvent.currentTarget;
        if (aEvent.target == browser.contentDocument && browser.__SS_tabFormData) {
          browser.messageManager.sendAsyncMessage("SessionStore:restoreSessionTabData", {
            formdata: browser.__SS_tabFormData.formdata,
            scroll: browser.__SS_tabFormData.scroll
          });
        }
        break;
      case "TabOpen":
        this.updateTabTelemetryVars(window);
        let browser = aEvent.originalTarget.linkedBrowser;
        browser.addEventListener("load", this, true);
      case "TabClose": {
        let browser = aEvent.originalTarget.linkedBrowser;
        if (aEvent.type == "TabOpen") {
          this.onTabAdd(window, browser);
        }
        else {
          this.onTabClose(window, browser);
          this.onTabRemove(window, browser);
        }
        break;
    }
      case "TabRemove":
        this.updateTabTelemetryVars(window);
        break;
      case "TabSelect": {
        let browser = aEvent.originalTarget.linkedBrowser;
        this.onTabSelect(window, browser);
        break;
      }
    }
  },

  receiveMessage: function ss_receiveMessage(aMessage) {
    let browser = aMessage.target;
    switch (aMessage.name) {
      case "SessionStore:collectFormdata":
        browser.__SS_data.formdata = aMessage.json.data;
        break;
      case "SessionStore:collectScrollPosition":
        browser.__SS_data.scroll = aMessage.json.data;
        break;
      default:
        let window = aMessage.target.ownerDocument.defaultView;
        this.onTabLoad(window, aMessage.target, aMessage);
        break;
    }
  },

  onWindowOpen: function ss_onWindowOpen(aWindow) {
    // Return if window has already been initialized
    if (aWindow && aWindow.__SSID && this._windows[aWindow.__SSID])
      return;

    // Ignore non-browser windows and windows opened while shutting down
    if (aWindow.document.documentElement.getAttribute("windowtype") != "navigator:browser" || this._loadState == STATE_QUITTING)
      return;

    // Assign it a unique identifier and create its data object
    aWindow.__SSID = "window" + gUUIDGenerator.generateUUID().toString();
    this._windows[aWindow.__SSID] = { tabs: [], selected: 0, _closedTabs: [] };
    this._orderedWindows.push(aWindow.__SSID);

    // Perform additional initialization when the first window is loading
    if (this._loadState == STATE_STOPPED) {
      this._loadState = STATE_RUNNING;
      this._lastSaveTime = Date.now();

      // Nothing to restore, notify observers things are complete
      if (!this.shouldRestore()) {
        this._clearCache();
        Services.obs.notifyObservers(null, "sessionstore-windows-restored", "");
      }
    }

    // Add tab change listeners to all already existing tabs
    let tabs = aWindow.Browser.tabs;
    for (let i = 0; i < tabs.length; i++)
      this.onTabAdd(aWindow, tabs[i].browser, true);

    // Notification of tab add/remove/selection
    let tabContainer = aWindow.document.getElementById("tabs");
    tabContainer.addEventListener("TabOpen", this, true);
    tabContainer.addEventListener("TabClose", this, true);
    tabContainer.addEventListener("TabRemove", this, true);
    tabContainer.addEventListener("TabSelect", this, true);
  },

  onWindowClose: function ss_onWindowClose(aWindow) {
    // Ignore windows not tracked by SessionStore
    if (!aWindow.__SSID || !this._windows[aWindow.__SSID])
      return;

    let tabContainer = aWindow.document.getElementById("tabs");
    tabContainer.removeEventListener("TabOpen", this, true);
    tabContainer.removeEventListener("TabClose", this, true);
    tabContainer.removeEventListener("TabRemove", this, true);
    tabContainer.removeEventListener("TabSelect", this, true);

    if (this._loadState == STATE_RUNNING) {
      // Update all window data for a last time
      this._collectWindowData(aWindow);

      // Clear this window from the list
      delete this._windows[aWindow.__SSID];

      // Save the state without this window to disk
      this.saveStateDelayed();
    }

    let tabs = aWindow.Browser.tabs;
    for (let i = 0; i < tabs.length; i++)
      this.onTabRemove(aWindow, tabs[i].browser, true);

    delete aWindow.__SSID;
  },

  onTabAdd: function ss_onTabAdd(aWindow, aBrowser, aNoNotification) {
    aBrowser.messageManager.addMessageListener("pageshow", this);
    aBrowser.messageManager.addMessageListener("Content:SessionHistory", this);
    aBrowser.messageManager.addMessageListener("SessionStore:collectFormdata", this);
    aBrowser.messageManager.addMessageListener("SessionStore:collectScrollPosition", this);

    if (!aNoNotification)
      this.saveStateDelayed();
    this._updateCrashReportURL(aWindow);
  },

  onTabRemove: function ss_onTabRemove(aWindow, aBrowser, aNoNotification) {
    aBrowser.messageManager.removeMessageListener("pageshow", this);
    aBrowser.messageManager.removeMessageListener("Content:SessionHistory", this);
    aBrowser.messageManager.removeMessageListener("SessionStore:collectFormdata", this);
    aBrowser.messageManager.removeMessageListener("SessionStore:collectScrollPosition", this);

    // If this browser is being restored, skip any session save activity
    if (aBrowser.__SS_restore)
      return;

    delete aBrowser.__SS_data;

    if (!aNoNotification)
      this.saveStateDelayed();
  },

  onTabClose: function ss_onTabClose(aWindow, aBrowser) {
    if (this._maxTabsUndo == 0)
      return;

    if (aWindow.Browser.tabs.length > 0) {
      // Bundle this browser's data and extra data and save in the closedTabs
      // window property
      //
      // NB: The access to aBrowser.__SS_extdata throws during automation (in
      // browser_msgmgr_01). See bug 888736.
      let data = aBrowser.__SS_data;
      if (!data) {
        return; // Cannot restore an empty tab.
      }
      try { data.extData = aBrowser.__SS_extdata; } catch (e) { }

      this._windows[aWindow.__SSID]._closedTabs.unshift({ state: data });
      let length = this._windows[aWindow.__SSID]._closedTabs.length;
      if (length > this._maxTabsUndo)
        this._windows[aWindow.__SSID]._closedTabs.splice(this._maxTabsUndo, length - this._maxTabsUndo);
    }
  },

  onTabLoad: function ss_onTabLoad(aWindow, aBrowser, aMessage) {
    // If this browser is being restored, skip any session save activity
    if (aBrowser.__SS_restore)
      return;

    // Ignore a transient "about:blank"
    if (!aBrowser.canGoBack && aBrowser.currentURI.spec == "about:blank")
      return;

    if (aMessage.name == "Content:SessionHistory") {
      delete aBrowser.__SS_data;
      this._collectTabData(aBrowser, aMessage.json);
    }

    // Save out the state as quickly as possible
    if (aMessage.name == "pageshow")
      this.saveStateNow();

    this._updateCrashReportURL(aWindow);
  },

  onTabSelect: function ss_onTabSelect(aWindow, aBrowser) {
    if (this._loadState != STATE_RUNNING)
      return;

    let index = aWindow.Elements.browsers.selectedIndex;
    this._windows[aWindow.__SSID].selected = parseInt(index) + 1; // 1-based

    // Restore the resurrected browser
    if (aBrowser.__SS_restore) {
      let data = aBrowser.__SS_data;
      if (data.entries.length > 0) {
        let json = {
          uri: data.entries[data.index - 1].url,
          flags: null,
          entries: data.entries,
          index: data.index
        };
        aBrowser.messageManager.sendAsyncMessage("WebNavigation:LoadURI", json);
      }

      delete aBrowser.__SS_restore;
    }

    this._updateCrashReportURL(aWindow);
  },

  saveStateDelayed: function ss_saveStateDelayed() {
    if (!this._saveTimer) {
      // Interval until the next disk operation is allowed
      let minimalDelay = this._lastSaveTime + this._interval - Date.now();

      // If we have to wait, set a timer, otherwise saveState directly
      let delay = Math.max(minimalDelay, 2000);
      if (delay > 0) {
        this._saveTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
        this._saveTimer.init(this, delay, Ci.nsITimer.TYPE_ONE_SHOT);
      } else {
        this.saveState();
      }
    }
  },

  saveStateNow: function ss_saveStateNow() {
    // Kill any queued timer and save immediately
    if (this._saveTimer) {
      this._saveTimer.cancel();
      this._saveTimer = null;
    }
    this.saveState();
  },

  saveState: function ss_saveState() {
    let data = this._getCurrentState();
    // sanity check before we overwrite the session file
    if (data.windows && data.windows.length && data.selectedWindow) {
      this._writeFile(this._sessionFile, JSON.stringify(data));

      this._lastSaveTime = Date.now();
    } else {
      dump("SessionStore: Not saving state with invalid data: " + JSON.stringify(data) + "\n");
    }
  },

  _getCurrentState: function ss_getCurrentState() {
    let self = this;
    this._forEachBrowserWindow(function(aWindow) {
      self._collectWindowData(aWindow);
    });

    let data = { windows: [] };
    for (let i = 0; i < this._orderedWindows.length; i++)
      data.windows.push(this._windows[this._orderedWindows[i]]);
    data.selectedWindow = this._selectedWindow;
    return data;
  },

  _collectTabData: function ss__collectTabData(aBrowser, aHistory) {
    // If this browser is being restored, skip any session save activity
    if (aBrowser.__SS_restore)
      return;

    aHistory = aHistory || { entries: [{ url: aBrowser.currentURI.spec, title: aBrowser.contentTitle }], index: 1 };

    let tabData = {};
    tabData.entries = aHistory.entries;
    tabData.index = aHistory.index;
    tabData.attributes = { image: aBrowser.mIconURL };

    aBrowser.__SS_data = tabData;
  },

  _getTabData: function(aWindow) {
    return aWindow.Browser.tabs
      .filter(tab => !tab.isPrivate && tab.browser.__SS_data)
      .map(tab => {
        let browser = tab.browser;
        let tabData = browser.__SS_data;
        if (browser.__SS_extdata)
          tabData.extData = browser.__SS_extdata;
        return tabData;
      });
  },

  _collectWindowData: function ss__collectWindowData(aWindow) {
    // Ignore windows not tracked by SessionStore
    if (!aWindow.__SSID || !this._windows[aWindow.__SSID])
      return;

    let winData = this._windows[aWindow.__SSID];

    let index = aWindow.Elements.browsers.selectedIndex;
    winData.selected = parseInt(index) + 1; // 1-based

    let tabData = this._getTabData(aWindow);
    winData.tabs = tabData.concat(this._tabsFromOtherGroups);
  },

  _forEachBrowserWindow: function ss_forEachBrowserWindow(aFunc) {
    let windowsEnum = Services.wm.getEnumerator("navigator:browser");
    while (windowsEnum.hasMoreElements()) {
      let window = windowsEnum.getNext();
      if (window.__SSID && !window.closed)
        aFunc.call(this, window);
    }
  },

  _writeFile: function ss_writeFile(aFile, aData) {
    let stateString = Cc["@mozilla.org/supports-string;1"].createInstance(Ci.nsISupportsString);
    stateString.data = aData;
    Services.obs.notifyObservers(stateString, "sessionstore-state-write", "");

    // Don't touch the file if an observer has deleted all state data
    if (!stateString.data)
      return;

    // Initialize the file output stream.
    let ostream = Cc["@mozilla.org/network/safe-file-output-stream;1"].createInstance(Ci.nsIFileOutputStream);
    ostream.init(aFile, 0x02 | 0x08 | 0x20, 0600, ostream.DEFER_OPEN);

    // Obtain a converter to convert our data to a UTF-8 encoded input stream.
    let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"].createInstance(Ci.nsIScriptableUnicodeConverter);
    converter.charset = "UTF-8";

    // Asynchronously copy the data to the file.
    let istream = converter.convertToInputStream(aData);
    NetUtil.asyncCopy(istream, ostream, function(rc) {
      if (Components.isSuccessCode(rc)) {
        if (Services.startup.shuttingDown) {
          Services.obs.notifyObservers(null, "sessionstore-final-state-write-complete", "");
        }
        Services.obs.notifyObservers(null, "sessionstore-state-write-complete", "");
      }
    });
  },

  _updateCrashReportURL: function ss_updateCrashReportURL(aWindow) {
#ifdef MOZ_CRASHREPORTER
    try {
      let currentURI = aWindow.Browser.selectedBrowser.currentURI.clone();
      // if the current URI contains a username/password, remove it
      try {
        currentURI.userPass = "";
      }
      catch (ex) { } // ignore failures on about: URIs

      CrashReporter.annotateCrashReport("URL", currentURI.spec);
    }
    catch (ex) {
      // don't make noise when crashreporter is built but not enabled
      if (ex.result != Components.results.NS_ERROR_NOT_INITIALIZED)
        Components.utils.reportError("SessionStore:" + ex);
    }
#endif
  },

  getBrowserState: function ss_getBrowserState() {
    let data = this._getCurrentState();
    return JSON.stringify(data);
  },

  getClosedTabCount: function ss_getClosedTabCount(aWindow) {
    if (!aWindow || !aWindow.__SSID)
      return 0; // not a browser window, or not otherwise tracked by SS.

    return this._windows[aWindow.__SSID]._closedTabs.length;
  },

  getClosedTabData: function ss_getClosedTabData(aWindow) {
    if (!aWindow.__SSID)
      throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);

    return JSON.stringify(this._windows[aWindow.__SSID]._closedTabs);
  },

  undoCloseTab: function ss_undoCloseTab(aWindow, aIndex) {
    if (!aWindow.__SSID)
      throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);

    let closedTabs = this._windows[aWindow.__SSID]._closedTabs;
    if (!closedTabs)
      return null;

    // default to the most-recently closed tab
    aIndex = aIndex || 0;
    if (!(aIndex in closedTabs))
      throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);

    // fetch the data of closed tab, while removing it from the array
    let closedTab = closedTabs.splice(aIndex, 1).shift();

    // create a new tab and bring to front
    let tab = aWindow.Browser.addTab(closedTab.state.entries[closedTab.state.index - 1].url, true);

    tab.browser.messageManager.sendAsyncMessage("WebNavigation:LoadURI", {
      uri: closedTab.state.entries[closedTab.state.index - 1].url,
      flags: null,
      entries: closedTab.state.entries,
      index: closedTab.state.index
    });

    // Put back the extra data
    tab.browser.__SS_extdata = closedTab.extData;

    return tab.chromeTab;
  },

  forgetClosedTab: function ss_forgetClosedTab(aWindow, aIndex) {
    if (!aWindow.__SSID)
      throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);

    let closedTabs = this._windows[aWindow.__SSID]._closedTabs;

    // default to the most-recently closed tab
    aIndex = aIndex || 0;
    if (!(aIndex in closedTabs))
      throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);

    // remove closed tab from the array
    closedTabs.splice(aIndex, 1);
  },

  getTabValue: function ss_getTabValue(aTab, aKey) {
    let browser = aTab.linkedBrowser;
    let data = browser.__SS_extdata || {};
    return data[aKey] || "";
  },

  setTabValue: function ss_setTabValue(aTab, aKey, aStringValue) {
    let browser = aTab.linkedBrowser;

    // Thumbnails are actually stored in the cache, so do the save and update the URI
    if (aKey == "thumbnail") {
      let file = this._sessionCache.clone();
      file.append("thumbnail-" + browser.contentWindowId);
      file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0600);

      let source = Services.io.newURI(aStringValue, "UTF8", null);
      let target = Services.io.newFileURI(file)

      let persist = Cc["@mozilla.org/embedding/browser/nsWebBrowserPersist;1"].createInstance(Ci.nsIWebBrowserPersist);
      persist.persistFlags = Ci.nsIWebBrowserPersist.PERSIST_FLAGS_REPLACE_EXISTING_FILES | Ci.nsIWebBrowserPersist.PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION;
      persist.saveURI(source, null, null, 0, null, null, file);

      aStringValue = target.spec;
    }

    if (!browser.__SS_extdata)
      browser.__SS_extdata = {};
    browser.__SS_extdata[aKey] = aStringValue;
    this.saveStateDelayed();
  },

  deleteTabValue: function ss_deleteTabValue(aTab, aKey) {
    let browser = aTab.linkedBrowser;
    if (browser.__SS_extdata && browser.__SS_extdata[aKey])
      delete browser.__SS_extdata[aKey];
    else
      throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
  },

  shouldRestore: function ss_shouldRestore() {
    return this._shouldRestore || (3 == Services.prefs.getIntPref("browser.startup.page"));
  },

  restoreLastSession: function ss_restoreLastSession(aBringToFront) {
    let self = this;
    function notifyObservers(aMessage) {
      self._clearCache();
      Services.obs.notifyObservers(null, "sessionstore-windows-restored", aMessage || "");
    }

    // The previous session data has already been renamed to the backup file
    if (!this._sessionFileBackup.exists()) {
      notifyObservers("fail")
      return;
    }

    try {
      let channel = NetUtil.newChannel(this._sessionFileBackup);
      channel.contentType = "application/json";
      NetUtil.asyncFetch(channel, function(aStream, aResult) {
        if (!Components.isSuccessCode(aResult)) {
          Cu.reportError("SessionStore: Could not read from sessionstore.bak file");
          notifyObservers("fail");
          return;
        }

        // Read session state file into a string and let observers modify the state before it's being used
        let state = Cc["@mozilla.org/supports-string;1"].createInstance(Ci.nsISupportsString);
        state.data = NetUtil.readInputStreamToString(aStream, aStream.available(), { charset : "UTF-8" }) || "";
        aStream.close();

        Services.obs.notifyObservers(state, "sessionstore-state-read", "");

        let data = null;
        try {
          data = JSON.parse(state.data);
        } catch (ex) {
          Cu.reportError("SessionStore: Could not parse JSON: " + ex);
        }

        if (!data || data.windows.length == 0) {
          notifyObservers("fail");
          return;
        }

        let window = Services.wm.getMostRecentWindow("navigator:browser");

        if (typeof data.selectedWindow == "number") {
          this._selectedWindow = data.selectedWindow;
        }
        let windowIndex = this._selectedWindow - 1;
        let tabs = data.windows[windowIndex].tabs;
        let selected = data.windows[windowIndex].selected;

        let currentGroupId;
        try {
          currentGroupId = JSON.parse(data.windows[windowIndex].extData["tabview-groups"]).activeGroupId;
        } catch (ex) { /* currentGroupId is undefined if user has no tab groups */ }

        // Move all window data from sessionstore.js to this._windows.
        this._orderedWindows = [];
        for (let i = 0; i < data.windows.length; i++) {
          let SSID;
          if (i != windowIndex) {
            SSID = "window" + gUUIDGenerator.generateUUID().toString();
            this._windows[SSID] = data.windows[i];
          } else {
            SSID = window.__SSID;
            this._windows[SSID].extData = data.windows[i].extData;
            this._windows[SSID]._closedTabs =
              this._windows[SSID]._closedTabs.concat(data.windows[i]._closedTabs);
          }
          this._orderedWindows.push(SSID);
        }

        if (selected > tabs.length) // Clamp the selected index if it's bogus
          selected = 1;

        for (let i=0; i<tabs.length; i++) {
          let tabData = tabs[i];
          let tabGroupId = (typeof currentGroupId == "number") ?
            JSON.parse(tabData.extData["tabview-tab"]).groupID : null;

          if (tabGroupId && tabGroupId != currentGroupId) {
            this._tabsFromOtherGroups.push(tabData);
            continue;
          }

          // We must have selected tabs as soon as possible, so we let all tabs be selected
          // until we get the real selected tab. Then we stop selecting tabs. The end result
          // is that the right tab is selected, but we also don't get a bunch of errors
          let bringToFront = (i + 1 <= selected) && aBringToFront;
          let tab = window.Browser.addTab(tabData.entries[tabData.index - 1].url, bringToFront);

          // Start a real load for the selected tab
          if (i + 1 == selected) {
            let json = {
              uri: tabData.entries[tabData.index - 1].url,
              flags: null,
              entries: tabData.entries,
              index: tabData.index
            };
            tab.browser.messageManager.sendAsyncMessage("WebNavigation:LoadURI", json);
          } else {
            // Make sure the browser has its session data for the delay reload
            tab.browser.__SS_data = tabData;
            tab.browser.__SS_restore = true;

            // Restore current title
            tab.chromeTab.updateTitle(tabData.entries[tabData.index - 1].title);
          }

          tab.browser.__SS_tabFormData = tabData
          tab.browser.__SS_extdata = tabData.extData;
        }

        notifyObservers();
      }.bind(this));
    } catch (ex) {
      Cu.reportError("SessionStore: Could not read from sessionstore.bak file: " + ex);
      notifyObservers("fail");
    }
  }
};

this.NSGetFactory = XPCOMUtils.generateNSGetFactory([SessionStore]);