mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
3571e0740d
--HG-- rename : browser/components/sessionstore/src/ContentRestore.jsm => browser/components/sessionstore/ContentRestore.jsm rename : browser/components/sessionstore/src/DocShellCapabilities.jsm => browser/components/sessionstore/DocShellCapabilities.jsm rename : browser/components/sessionstore/src/FrameTree.jsm => browser/components/sessionstore/FrameTree.jsm rename : browser/components/sessionstore/src/GlobalState.jsm => browser/components/sessionstore/GlobalState.jsm rename : browser/components/sessionstore/src/PageStyle.jsm => browser/components/sessionstore/PageStyle.jsm rename : browser/components/sessionstore/src/PrivacyFilter.jsm => browser/components/sessionstore/PrivacyFilter.jsm rename : browser/components/sessionstore/src/PrivacyLevel.jsm => browser/components/sessionstore/PrivacyLevel.jsm rename : browser/components/sessionstore/src/RecentlyClosedTabsAndWindowsMenuUtils.jsm => browser/components/sessionstore/RecentlyClosedTabsAndWindowsMenuUtils.jsm rename : browser/components/sessionstore/src/SessionCookies.jsm => browser/components/sessionstore/SessionCookies.jsm rename : browser/components/sessionstore/src/SessionFile.jsm => browser/components/sessionstore/SessionFile.jsm rename : browser/components/sessionstore/src/SessionHistory.jsm => browser/components/sessionstore/SessionHistory.jsm rename : browser/components/sessionstore/src/SessionMigration.jsm => browser/components/sessionstore/SessionMigration.jsm rename : browser/components/sessionstore/src/SessionSaver.jsm => browser/components/sessionstore/SessionSaver.jsm rename : browser/components/sessionstore/src/SessionStorage.jsm => browser/components/sessionstore/SessionStorage.jsm rename : browser/components/sessionstore/src/SessionStore.jsm => browser/components/sessionstore/SessionStore.jsm rename : browser/components/sessionstore/src/SessionWorker.js => browser/components/sessionstore/SessionWorker.js rename : browser/components/sessionstore/src/SessionWorker.jsm => browser/components/sessionstore/SessionWorker.jsm rename : browser/components/sessionstore/src/TabAttributes.jsm => browser/components/sessionstore/TabAttributes.jsm rename : browser/components/sessionstore/src/TabState.jsm => browser/components/sessionstore/TabState.jsm rename : browser/components/sessionstore/src/TabStateCache.jsm => browser/components/sessionstore/TabStateCache.jsm rename : browser/components/sessionstore/src/Utils.jsm => browser/components/sessionstore/Utils.jsm rename : browser/components/sessionstore/src/nsSessionStartup.js => browser/components/sessionstore/nsSessionStartup.js rename : browser/components/sessionstore/src/nsSessionStore.js => browser/components/sessionstore/nsSessionStore.js rename : browser/components/sessionstore/src/nsSessionStore.manifest => browser/components/sessionstore/nsSessionStore.manifest
3607 lines
123 KiB
JavaScript
3607 lines
123 KiB
JavaScript
/* 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 <browser> element being restored, records the current epoch.
|
|
_browserEpochs: new WeakMap(),
|
|
|
|
// whether a setBrowserState call is in progress
|
|
_browserSetState: false,
|
|
|
|
// time in milliseconds when the session was started (saved across sessions),
|
|
// defaults to now if no session was restored or timestamp doesn't exist
|
|
_sessionStartTime: Date.now(),
|
|
|
|
// states for all currently opened windows
|
|
_windows: {},
|
|
|
|
// counter for creating unique window IDs
|
|
_nextWindowID: 0,
|
|
|
|
// states for all recently closed windows
|
|
_closedWindows: [],
|
|
|
|
// collection of session states yet to be restored
|
|
_statesToRestore: {},
|
|
|
|
// counts the number of crashes since the last clean start
|
|
_recentCrashes: 0,
|
|
|
|
// whether the last window was closed and should be restored
|
|
_restoreLastWindow: false,
|
|
|
|
// number of tabs currently restoring
|
|
_tabsRestoringCount: 0,
|
|
|
|
// When starting Firefox with a single private window, this is the place
|
|
// where we keep the session we actually wanted to restore in case the user
|
|
// decides to later open a non-private window as well.
|
|
_deferredInitialState: null,
|
|
|
|
// A promise resolved once initialization is complete
|
|
_deferredInitialized: Promise.defer(),
|
|
|
|
// Whether session has been initialized
|
|
_sessionInitialized: false,
|
|
|
|
// Promise that is resolved when we're ready to initialize
|
|
// and restore the session.
|
|
_promiseReadyForInitialization: null,
|
|
|
|
/**
|
|
* A promise fulfilled once initialization is complete.
|
|
*/
|
|
get promiseInitialized() {
|
|
return this._deferredInitialized.promise;
|
|
},
|
|
|
|
get canRestoreLastSession() {
|
|
return LastSession.canRestore;
|
|
},
|
|
|
|
set canRestoreLastSession(val) {
|
|
// Cheat a bit; only allow false.
|
|
if (!val) {
|
|
LastSession.clear();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Initialize the sessionstore service.
|
|
*/
|
|
init: function () {
|
|
if (this._initialized) {
|
|
throw new Error("SessionStore.init() must only be called once!");
|
|
}
|
|
|
|
TelemetryTimestamps.add("sessionRestoreInitialized");
|
|
OBSERVING.forEach(function(aTopic) {
|
|
Services.obs.addObserver(this, aTopic, true);
|
|
}, this);
|
|
|
|
this._initPrefs();
|
|
this._initialized = true;
|
|
},
|
|
|
|
/**
|
|
* Initialize the session using the state provided by SessionStartup
|
|
*/
|
|
initSession: function () {
|
|
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 <browser> elements that are not tabs.
|
|
return;
|
|
}
|
|
|
|
switch (aMessage.name) {
|
|
case "SessionStore:setupSyncHandler":
|
|
TabState.setSyncHandler(browser, aMessage.objects.handler);
|
|
break;
|
|
case "SessionStore:update":
|
|
this.recordTelemetry(aMessage.data.telemetry);
|
|
TabState.update(browser, aMessage.data);
|
|
this.saveStateDelayed(win);
|
|
break;
|
|
case "SessionStore:restoreHistoryComplete":
|
|
if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
|
|
// Notify the tabbrowser that the tab chrome has been restored.
|
|
let tabData = browser.__SS_data;
|
|
|
|
// wall-paper fix for bug 439675: make sure that the URL to be loaded
|
|
// is always visible in the address bar
|
|
let activePageData = tabData.entries[tabData.index - 1] || null;
|
|
let uri = activePageData ? activePageData.url || null : null;
|
|
browser.userTypedValue = uri;
|
|
|
|
// If the page has a title, set it.
|
|
if (activePageData) {
|
|
if (activePageData.title) {
|
|
tab.label = activePageData.title;
|
|
tab.crop = "end";
|
|
} else if (activePageData.url != "about:blank") {
|
|
tab.label = activePageData.url;
|
|
tab.crop = "center";
|
|
}
|
|
}
|
|
|
|
// Restore the tab icon.
|
|
if ("image" in tabData) {
|
|
win.gBrowser.setIcon(tab, tabData.image);
|
|
}
|
|
|
|
let event = win.document.createEvent("Events");
|
|
event.initEvent("SSTabRestoring", true, false);
|
|
tab.dispatchEvent(event);
|
|
}
|
|
break;
|
|
case "SessionStore:restoreTabContentStarted":
|
|
if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
|
|
// If the user was typing into the URL bar when we crashed, but hadn't hit
|
|
// enter yet, then we just need to write that value to the URL bar without
|
|
// loading anything. This must happen after the load, since it will clear
|
|
// userTypedValue.
|
|
let tabData = browser.__SS_data;
|
|
if (tabData.userTypedValue && !tabData.userTypedClear) {
|
|
browser.userTypedValue = tabData.userTypedValue;
|
|
win.URLBarSetURI();
|
|
}
|
|
}
|
|
break;
|
|
case "SessionStore:restoreTabContentComplete":
|
|
if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
|
|
// This callback is used exclusively by tests that want to
|
|
// monitor the progress of network loads.
|
|
if (gDebuggingEnabled) {
|
|
Services.obs.notifyObservers(browser, NOTIFY_TAB_RESTORED, null);
|
|
}
|
|
|
|
if (tab) {
|
|
SessionStoreInternal._resetLocalTabRestoringState(tab);
|
|
SessionStoreInternal.restoreNextTab();
|
|
}
|
|
}
|
|
break;
|
|
case "SessionStore:restoreDocumentComplete":
|
|
if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
|
|
// Document has been restored. Delete all the state associated
|
|
// with it and trigger SSTabRestored.
|
|
let tab = browser.__SS_restore_tab;
|
|
|
|
delete browser.__SS_restore_data;
|
|
delete browser.__SS_restore_tab;
|
|
delete browser.__SS_data;
|
|
|
|
this._sendTabRestoredNotification(tab);
|
|
}
|
|
break;
|
|
case "SessionStore:reloadPendingTab":
|
|
if (this.isCurrentEpoch(browser, aMessage.data.epoch)) {
|
|
if (tab && browser.__SS_restoreState == TAB_STATE_NEEDS_RESTORE) {
|
|
this.restoreTabContent(tab);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
debug("received unknown message '" + aMessage.name + "'");
|
|
break;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Record telemetry measurements stored in an object.
|
|
* @param telemetry
|
|
* {histogramID: value, ...} An object mapping histogramIDs to the
|
|
* value to be recorded for that ID,
|
|
*/
|
|
recordTelemetry: function (telemetry) {
|
|
for (let histogramId in telemetry){
|
|
Telemetry.getHistogramById(histogramId).add(telemetry[histogramId]);
|
|
}
|
|
},
|
|
|
|
/* ........ Window Event Handlers .............. */
|
|
|
|
/**
|
|
* Implement nsIDOMEventListener for handling various window and tab events
|
|
*/
|
|
handleEvent: function ssi_handleEvent(aEvent) {
|
|
var win = aEvent.currentTarget.ownerDocument.defaultView;
|
|
let browser;
|
|
switch (aEvent.type) {
|
|
case "TabOpen":
|
|
this.onTabAdd(win, aEvent.originalTarget);
|
|
break;
|
|
case "TabClose":
|
|
// aEvent.detail determines if the tab was closed by moving to a different window
|
|
if (!aEvent.detail)
|
|
this.onTabClose(win, aEvent.originalTarget);
|
|
this.onTabRemove(win, aEvent.originalTarget);
|
|
break;
|
|
case "TabSelect":
|
|
this.onTabSelect(win);
|
|
break;
|
|
case "TabShow":
|
|
this.onTabShow(win, aEvent.originalTarget);
|
|
break;
|
|
case "TabHide":
|
|
this.onTabHide(win, aEvent.originalTarget);
|
|
break;
|
|
case "TabPinned":
|
|
case "TabUnpinned":
|
|
this.saveStateDelayed(win);
|
|
break;
|
|
}
|
|
this._clearRestoringWindows();
|
|
},
|
|
|
|
/**
|
|
* Generate a unique window identifier
|
|
* @return string
|
|
* A unique string to identify a window
|
|
*/
|
|
_generateWindowID: function ssi_generateWindowID() {
|
|
return "window" + (this._nextWindowID++);
|
|
},
|
|
|
|
/**
|
|
* If it's the first window load since app start...
|
|
* - determine if we're reloading after a crash or a forced-restart
|
|
* - restore window state
|
|
* - restart downloads
|
|
* Set up event listeners for this window's tabs
|
|
* @param aWindow
|
|
* Window reference
|
|
* @param aInitialState
|
|
* The initial state to be loaded after startup (optional)
|
|
*/
|
|
onLoad: function ssi_onLoad(aWindow, aInitialState = null) {
|
|
// return if window has already been initialized
|
|
if (aWindow && aWindow.__SSi && this._windows[aWindow.__SSi])
|
|
return;
|
|
|
|
// ignore windows opened while shutting down
|
|
if (this._loadState == STATE_QUITTING)
|
|
return;
|
|
|
|
// Assign the window a unique identifier we can use to reference
|
|
// internal data about the window.
|
|
aWindow.__SSi = this._generateWindowID();
|
|
|
|
let mm = aWindow.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 <browser> element is restored, we increment its "epoch". To
|
|
* check if a message from content-sessionStore.js is out of date, we can
|
|
* compare the epoch received with the message to the <browser> element's
|
|
* epoch. This function does that, and returns true if |epoch| is up-to-date
|
|
* with respect to |browser|.
|
|
*/
|
|
isCurrentEpoch: function (browser, epoch) {
|
|
return (this._browserEpochs.get(browser.permanentKey) || 0) == epoch;
|
|
},
|
|
|
|
};
|
|
|
|
/**
|
|
* Priority queue that keeps track of a list of tabs to restore and returns
|
|
* the tab we should restore next, based on priority rules. We decide between
|
|
* pinned, visible and hidden tabs in that and FIFO order. Hidden tabs are only
|
|
* restored with restore_hidden_tabs=true.
|
|
*/
|
|
let TabRestoreQueue = {
|
|
// The separate buckets used to store tabs.
|
|
tabs: {priority: [], visible: [], hidden: []},
|
|
|
|
// Preferences used by the TabRestoreQueue to determine which tabs
|
|
// are restored automatically and which tabs will be on-demand.
|
|
prefs: {
|
|
// Lazy getter that returns whether tabs are restored on demand.
|
|
get restoreOnDemand() {
|
|
let updateValue = () => {
|
|
let value = Services.prefs.getBoolPref(PREF);
|
|
let definition = {value: value, configurable: true};
|
|
Object.defineProperty(this, "restoreOnDemand", definition);
|
|
return value;
|
|
}
|
|
|
|
const PREF = "browser.sessionstore.restore_on_demand";
|
|
Services.prefs.addObserver(PREF, updateValue, false);
|
|
return updateValue();
|
|
},
|
|
|
|
// Lazy getter that returns whether pinned tabs are restored on demand.
|
|
get restorePinnedTabsOnDemand() {
|
|
let updateValue = () => {
|
|
let value = Services.prefs.getBoolPref(PREF);
|
|
let definition = {value: value, configurable: true};
|
|
Object.defineProperty(this, "restorePinnedTabsOnDemand", definition);
|
|
return value;
|
|
}
|
|
|
|
const PREF = "browser.sessionstore.restore_pinned_tabs_on_demand";
|
|
Services.prefs.addObserver(PREF, updateValue, false);
|
|
return updateValue();
|
|
},
|
|
|
|
// Lazy getter that returns whether we should restore hidden tabs.
|
|
get restoreHiddenTabs() {
|
|
let updateValue = () => {
|
|
let value = Services.prefs.getBoolPref(PREF);
|
|
let definition = {value: value, configurable: true};
|
|
Object.defineProperty(this, "restoreHiddenTabs", definition);
|
|
return value;
|
|
}
|
|
|
|
const PREF = "browser.sessionstore.restore_hidden_tabs";
|
|
Services.prefs.addObserver(PREF, updateValue, false);
|
|
return updateValue();
|
|
}
|
|
},
|
|
|
|
// Resets the queue and removes all tabs.
|
|
reset: function () {
|
|
this.tabs = {priority: [], visible: [], hidden: []};
|
|
},
|
|
|
|
// Adds a tab to the queue and determines its priority bucket.
|
|
add: function (tab) {
|
|
let {priority, hidden, visible} = this.tabs;
|
|
|
|
if (tab.pinned) {
|
|
priority.push(tab);
|
|
} else if (tab.hidden) {
|
|
hidden.push(tab);
|
|
} else {
|
|
visible.push(tab);
|
|
}
|
|
},
|
|
|
|
// Removes a given tab from the queue, if it's in there.
|
|
remove: function (tab) {
|
|
let {priority, hidden, visible} = this.tabs;
|
|
|
|
// We'll always check priority first since we don't
|
|
// have an indicator if a tab will be there or not.
|
|
let set = priority;
|
|
let index = set.indexOf(tab);
|
|
|
|
if (index == -1) {
|
|
set = tab.hidden ? hidden : visible;
|
|
index = set.indexOf(tab);
|
|
}
|
|
|
|
if (index > -1) {
|
|
set.splice(index, 1);
|
|
}
|
|
},
|
|
|
|
// Returns and removes the tab with the highest priority.
|
|
shift: function () {
|
|
let set;
|
|
let {priority, hidden, visible} = this.tabs;
|
|
|
|
let {restoreOnDemand, restorePinnedTabsOnDemand} = this.prefs;
|
|
let restorePinned = !(restoreOnDemand && restorePinnedTabsOnDemand);
|
|
if (restorePinned && priority.length) {
|
|
set = priority;
|
|
} else if (!restoreOnDemand) {
|
|
if (visible.length) {
|
|
set = visible;
|
|
} else if (this.prefs.restoreHiddenTabs && hidden.length) {
|
|
set = hidden;
|
|
}
|
|
}
|
|
|
|
return set && set.shift();
|
|
},
|
|
|
|
// Moves a given tab from the 'hidden' to the 'visible' bucket.
|
|
hiddenToVisible: function (tab) {
|
|
let {hidden, visible} = this.tabs;
|
|
let index = hidden.indexOf(tab);
|
|
|
|
if (index > -1) {
|
|
hidden.splice(index, 1);
|
|
visible.push(tab);
|
|
} else {
|
|
throw new Error("restore queue: hidden tab not found");
|
|
}
|
|
},
|
|
|
|
// Moves a given tab from the 'visible' to the 'hidden' bucket.
|
|
visibleToHidden: function (tab) {
|
|
let {visible, hidden} = this.tabs;
|
|
let index = visible.indexOf(tab);
|
|
|
|
if (index > -1) {
|
|
visible.splice(index, 1);
|
|
hidden.push(tab);
|
|
} else {
|
|
throw new Error("restore queue: visible tab not found");
|
|
}
|
|
}
|
|
};
|
|
|
|
// A map storing a closed window's state data until it goes aways (is GC'ed).
|
|
// This ensures that API clients can still read (but not write) states of
|
|
// windows they still hold a reference to but we don't.
|
|
let DyingWindowCache = {
|
|
_data: new WeakMap(),
|
|
|
|
has: function (window) {
|
|
return this._data.has(window);
|
|
},
|
|
|
|
get: function (window) {
|
|
return this._data.get(window);
|
|
},
|
|
|
|
set: function (window, data) {
|
|
this._data.set(window, data);
|
|
},
|
|
|
|
remove: function (window) {
|
|
this._data.delete(window);
|
|
}
|
|
};
|
|
|
|
// A weak set of dirty windows. We use it to determine which windows we need to
|
|
// recollect data for when getCurrentState() is called.
|
|
let DirtyWindows = {
|
|
_data: new WeakMap(),
|
|
|
|
has: function (window) {
|
|
return this._data.has(window);
|
|
},
|
|
|
|
add: function (window) {
|
|
return this._data.set(window, true);
|
|
},
|
|
|
|
remove: function (window) {
|
|
this._data.delete(window);
|
|
},
|
|
|
|
clear: function (window) {
|
|
this._data.clear();
|
|
}
|
|
};
|
|
|
|
// The state from the previous session (after restoring pinned tabs). This
|
|
// state is persisted and passed through to the next session during an app
|
|
// restart to make the third party add-on warning not trash the deferred
|
|
// session
|
|
let LastSession = {
|
|
_state: null,
|
|
|
|
get canRestore() {
|
|
return !!this._state;
|
|
},
|
|
|
|
getState: function () {
|
|
return this._state;
|
|
},
|
|
|
|
setState: function (state) {
|
|
this._state = state;
|
|
},
|
|
|
|
clear: function () {
|
|
if (this._state) {
|
|
this._state = null;
|
|
Services.obs.notifyObservers(null, NOTIFY_LAST_SESSION_CLEARED, null);
|
|
}
|
|
}
|
|
};
|