/* 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 = [ "browser-window-before-show", "domwindowclosed", "quit-application-requested", "quit-application-granted", "browser-lastwindow-close-granted", "quit-application", "browser:purge-session-history", "browser:purge-domain-data", "gather-telemetry", "idle-daily", ]; // 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 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 () { TelemetryStopwatch.start("FX_SESSION_RESTORE_STARTUP_INIT_SESSION_MS"); let state; let ss = gSessionStartup; if (ss.doRestore() || ss.sessionType == Ci.nsISessionStartup.DEFER_SESSION) { state = ss.state; } if (state) { try { // If we're doing a DEFERRED session, then we want to pull pinned tabs // out so they can be restored. if (ss.sessionType == 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); TelemetryStopwatch.finish("FX_SESSION_RESTORE_STARTUP_INIT_SESSION_MS"); return state; }, _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 "browser-window-before-show": // catch new windows this.onBeforeBrowserWindowShown(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; case "idle-daily": this.onIdleDaily(); 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 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.getGroupMessageManager("browsers"); 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); }, /** * Called right before a new browser window is shown. * @param aWindow * Window reference */ onBeforeBrowserWindowShown: function (aWindow) { // Just call onLoad() directly if we're initialized already. 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; TelemetryStopwatch.start("FX_SESSION_RESTORE_STARTUP_ONLOAD_INITIAL_WINDOW_MS"); this.onLoad(aWindow, initialState); TelemetryStopwatch.finish("FX_SESSION_RESTORE_STARTUP_ONLOAD_INITIAL_WINDOW_MS"); // Let everyone know we're done. this._deferredInitialized.resolve(); } }, console.error); }, /** * 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.getGroupMessageManager("browsers"); 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); }, // Clean up data that has been closed a long time ago. // Do not reschedule a save. This will wait for the next regular // save. onIdleDaily: function() { // Remove old closed windows this._cleanupOldData([this._closedWindows]); // Remove closed tabs of closed windows this._cleanupOldData([winData._closedTabs for (winData of this._closedWindows)]); // Remove closed tabs of open windows this._cleanupOldData([this._windows[key]._closedTabs for (key of Object.keys(this._windows))]); }, // Remove "old" data from an array _cleanupOldData: function(targets) { const TIME_TO_LIVE = this._prefBranch.getIntPref("sessionstore.cleanup.forget_closed_after"); const now = Date.now(); for (let array of targets) { for (let i = array.length - 1; i >= 0; --i) { let data = array[i]; // Make sure that we have a timestamp to tell us when the target // has been closed. If we don't have a timestamp, default to a // safe timestamp: just now. data.closedAt = data.closedAt || now; if (now - data.closedAt > TIME_TO_LIVE) { array.splice(i, 1); } } } }, /* ........ 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.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); } 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.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) }; delete state.windows[0].closedAt; // Window is now open. 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 }; let state = { windows: total, selectedWindow: ix + 1, _closedWindows: lastClosedWindowsCopy, session: session, global: this._globalState.getState() }; if (Cu.isModuleLoaded("resource:///modules/devtools/scratchpad-manager.jsm")) { // get open Scratchpad window states too let scratchpads = ScratchpadManager.getSessionState(); if (scratchpads && scratchpads.length) { state.scratchpads = scratchpads; } } // 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(); }, /** * Manage history restoration for a window * @param aWindow * Window to restore the tabs into * @param aTabs * Array of tab references * @param aTabData * Array of tab data * @param aSelectTab * Index of the tab to select. This is a 1-based index where "1" * indicates the first tab should be selected, and "0" indicates that * the currently selected tab will not be changed. * @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; } // If provided, set the selected tab. if (aSelectTab > 0 && aSelectTab <= aTabs.length) { tabbrowser.selectedTab = aTabs[aSelectTab - 1]; } // 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; } delete tabData.closedAt; // Tab is now open. // 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.updateBrowserRemotenessByURL(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.entries[0].url == "about:privatebrowsing") && !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 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 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); } } };