mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
Bug 867143 - Cache Session Restore state aggressively. r=ttaubert
This commit is contained in:
David Rajchenbach-Teller
parent
e1ed6aef6e
commit
2b83439124
@ -6,6 +6,8 @@ function debug(msg) {
|
||||
Services.console.logStringMessage("SessionStoreContent: " + msg);
|
||||
}
|
||||
|
||||
Cu.import("resource://gre/modules/XPCOMUtils.jsm", this);
|
||||
|
||||
/**
|
||||
* Listens for and handles content events that we need for the
|
||||
* session store service to be notified of state changes in content.
|
||||
@ -13,7 +15,7 @@ function debug(msg) {
|
||||
let EventListener = {
|
||||
|
||||
DOM_EVENTS: [
|
||||
"pageshow", "change", "input"
|
||||
"pageshow", "change", "input", "MozStorageChanged"
|
||||
],
|
||||
|
||||
init: function () {
|
||||
@ -30,11 +32,46 @@ let EventListener = {
|
||||
case "change":
|
||||
sendAsyncMessage("SessionStore:input");
|
||||
break;
|
||||
case "MozStorageChanged": {
|
||||
let isSessionStorage = true;
|
||||
// We are only interested in sessionStorage events
|
||||
try {
|
||||
if (event.storageArea != content.sessionStorage) {
|
||||
isSessionStorage = false;
|
||||
}
|
||||
} catch (ex) {
|
||||
// This page does not even have sessionStorage
|
||||
// (this is typically the case of about: pages)
|
||||
isSessionStorage = false;
|
||||
}
|
||||
if (isSessionStorage) {
|
||||
sendAsyncMessage("SessionStore:MozStorageChanged");
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
debug("received unknown event '" + event.type + "'");
|
||||
break;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
EventListener.init();
|
||||
|
||||
let ProgressListener = {
|
||||
init: function() {
|
||||
let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
|
||||
.getInterface(Ci.nsIWebProgress);
|
||||
webProgress.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_LOCATION);
|
||||
},
|
||||
onLocationChange: function(aWebProgress, aRequest, aLocation, aFlags) {
|
||||
// We are changing page, so time to invalidate the state of the tab
|
||||
sendAsyncMessage("SessionStore:loadStart");
|
||||
},
|
||||
onStateChange: function(aWebProgress, aRequest, aStateFlags, aStatus) {},
|
||||
onProgressChange: function() {},
|
||||
onStatusChange: function() {},
|
||||
onSecurityChange: function() {},
|
||||
QueryInterface: XPCOMUtils.generateQI([Ci.nsIWebProgressListener,
|
||||
Ci.nsISupportsWeakReference])
|
||||
};
|
||||
ProgressListener.init();
|
||||
|
||||
@ -58,7 +58,15 @@ const MESSAGES = [
|
||||
// The content script has received a pageshow event. This happens when a
|
||||
// page is loaded from bfcache without any network activity, i.e. when
|
||||
// clicking the back or forward button.
|
||||
"SessionStore:pageshow"
|
||||
"SessionStore:pageshow",
|
||||
|
||||
// The content script has received a MozStorageChanged event dealing
|
||||
// with a change in the contents of the sessionStorage.
|
||||
"SessionStore:MozStorageChanged",
|
||||
|
||||
// The content script tells us that a new page just started loading in a
|
||||
// browser.
|
||||
"SessionStore:loadStart"
|
||||
];
|
||||
|
||||
// These are tab events that we listen to.
|
||||
@ -120,9 +128,16 @@ XPCOMUtils.defineLazyServiceGetter(this, "CrashReporter",
|
||||
"@mozilla.org/xre/app-info;1", "nsICrashReporter");
|
||||
#endif
|
||||
|
||||
/**
|
||||
* |true| if we are in debug mode, |false| otherwise.
|
||||
* Debug mode is controlled by preference browser.sessionstore.debug
|
||||
*/
|
||||
let gDebuggingEnabled = false;
|
||||
function debug(aMsg) {
|
||||
aMsg = ("SessionStore: " + aMsg).replace(/\S{80}/g, "$&\n");
|
||||
Services.console.logStringMessage(aMsg);
|
||||
if (gDebuggingEnabled) {
|
||||
aMsg = ("SessionStore: " + aMsg).replace(/\S{80}/g, "$&\n");
|
||||
Services.console.logStringMessage(aMsg);
|
||||
}
|
||||
}
|
||||
|
||||
this.SessionStore = {
|
||||
@ -537,9 +552,13 @@ let SessionStoreInternal = {
|
||||
},
|
||||
|
||||
_initPrefs : function() {
|
||||
XPCOMUtils.defineLazyGetter(this, "_prefBranch", function () {
|
||||
return Services.prefs.getBranch("browser.");
|
||||
});
|
||||
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);
|
||||
|
||||
// minimal interval between two save operations (in milliseconds)
|
||||
XPCOMUtils.defineLazyGetter(this, "_interval", function () {
|
||||
@ -663,6 +682,13 @@ let SessionStoreInternal = {
|
||||
case "SessionStore:input":
|
||||
this.onTabInput(win, browser);
|
||||
break;
|
||||
case "SessionStore:MozStorageChanged":
|
||||
TabStateCache.delete(browser);
|
||||
this.saveStateDelayed(win);
|
||||
break;
|
||||
case "SessionStore:loadStart":
|
||||
TabStateCache.delete(browser);
|
||||
break;
|
||||
default:
|
||||
debug("received unknown message '" + aMessage.name + "'");
|
||||
break;
|
||||
@ -687,6 +713,7 @@ let SessionStoreInternal = {
|
||||
// (form data, scrolling, etc.). This will only happen when a tab is
|
||||
// first restored.
|
||||
let browser = aEvent.currentTarget;
|
||||
TabStateCache.delete(browser);
|
||||
if (browser.__SS_restore_data)
|
||||
this.restoreDocument(win, browser, aEvent);
|
||||
this.onTabLoad(win, browser);
|
||||
@ -710,11 +737,16 @@ let SessionStoreInternal = {
|
||||
this.onTabHide(win, aEvent.originalTarget);
|
||||
break;
|
||||
case "TabPinned":
|
||||
// If possible, update cached data without having to invalidate it
|
||||
TabStateCache.update(aEvent.originalTarget, "pinned", true);
|
||||
this.saveStateDelayed(win);
|
||||
break;
|
||||
case "TabUnpinned":
|
||||
// If possible, update cached data without having to invalidate it
|
||||
TabStateCache.update(aEvent.originalTarget, "pinned", false);
|
||||
this.saveStateDelayed(win);
|
||||
break;
|
||||
}
|
||||
|
||||
this._clearRestoringWindows();
|
||||
},
|
||||
|
||||
@ -1084,6 +1116,7 @@ let SessionStoreInternal = {
|
||||
let openWindows = {};
|
||||
this._forEachBrowserWindow(function(aWindow) {
|
||||
Array.forEach(aWindow.gBrowser.tabs, function(aTab) {
|
||||
TabStateCache.delete(aTab);
|
||||
delete aTab.linkedBrowser.__SS_data;
|
||||
delete aTab.linkedBrowser.__SS_tabStillLoading;
|
||||
delete aTab.linkedBrowser.__SS_formDataSaved;
|
||||
@ -1307,9 +1340,8 @@ let SessionStoreInternal = {
|
||||
return;
|
||||
}
|
||||
|
||||
// make sure that the tab related data is up-to-date
|
||||
var tabState = this._collectTabData(aTab);
|
||||
this._updateTextAndScrollDataForTab(aWindow, aTab.linkedBrowser, tabState);
|
||||
// Get the latest data for this tab (generally, from the cache)
|
||||
let tabState = this._collectTabData(aTab);
|
||||
|
||||
// store closed-tab data for undo
|
||||
if (this._shouldSaveTabState(tabState)) {
|
||||
@ -1330,7 +1362,8 @@ let SessionStoreInternal = {
|
||||
},
|
||||
|
||||
/**
|
||||
* When a tab loads, save state.
|
||||
* When a tab loads, invalidate its cached state, trigger async save.
|
||||
*
|
||||
* @param aWindow
|
||||
* Window reference
|
||||
* @param aBrowser
|
||||
@ -1346,6 +1379,8 @@ let SessionStoreInternal = {
|
||||
return;
|
||||
}
|
||||
|
||||
TabStateCache.delete(aBrowser);
|
||||
|
||||
delete aBrowser.__SS_data;
|
||||
delete aBrowser.__SS_tabStillLoading;
|
||||
delete aBrowser.__SS_formDataSaved;
|
||||
@ -1366,6 +1401,8 @@ let SessionStoreInternal = {
|
||||
// deleting __SS_formDataSaved will cause us to recollect form data
|
||||
delete aBrowser.__SS_formDataSaved;
|
||||
|
||||
TabStateCache.delete(aBrowser);
|
||||
|
||||
this.saveStateDelayed(aWindow, 3000);
|
||||
},
|
||||
|
||||
@ -1402,6 +1439,9 @@ let SessionStoreInternal = {
|
||||
this.restoreNextTab();
|
||||
}
|
||||
|
||||
// If possible, update cached data without having to invalidate it
|
||||
TabStateCache.update(aTab, "hidden", false);
|
||||
|
||||
// Default delay of 2 seconds gives enough time to catch multiple TabShow
|
||||
// events due to changing groups in Panorama.
|
||||
this.saveStateDelayed(aWindow);
|
||||
@ -1414,6 +1454,9 @@ let SessionStoreInternal = {
|
||||
TabRestoreQueue.visibleToHidden(aTab);
|
||||
}
|
||||
|
||||
// If possible, update cached data without having to invalidate it
|
||||
TabStateCache.update(aTab, "hidden", true);
|
||||
|
||||
// Default delay of 2 seconds gives enough time to catch multiple TabHide
|
||||
// events due to changing groups in Panorama.
|
||||
this.saveStateDelayed(aWindow);
|
||||
@ -1489,20 +1532,41 @@ let SessionStoreInternal = {
|
||||
if (!aTab.ownerDocument || !aTab.ownerDocument.defaultView.__SSi)
|
||||
throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
|
||||
|
||||
var tabState = this._collectTabData(aTab);
|
||||
|
||||
var window = aTab.ownerDocument.defaultView;
|
||||
this._updateTextAndScrollDataForTab(window, aTab.linkedBrowser, tabState);
|
||||
let tabState = this._collectTabData(aTab);
|
||||
|
||||
return this._toJSONString(tabState);
|
||||
},
|
||||
|
||||
setTabState: function ssi_setTabState(aTab, aState) {
|
||||
var tabState = JSON.parse(aState);
|
||||
if (!tabState.entries || !aTab.ownerDocument || !aTab.ownerDocument.defaultView.__SSi)
|
||||
// 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 |restoreHistoryPrecursor|.
|
||||
let tabState = JSON.parse(aState);
|
||||
if (!tabState) {
|
||||
debug("Empty state argument");
|
||||
throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
|
||||
}
|
||||
if (typeof tabState != "object") {
|
||||
debug("State argument does not represent an object");
|
||||
throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
|
||||
}
|
||||
if (!("entries" in tabState)) {
|
||||
debug("State argument must contain field 'entries'");
|
||||
throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
|
||||
}
|
||||
if (!aTab.ownerDocument) {
|
||||
debug("Tab argument must have an owner document");
|
||||
throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
|
||||
}
|
||||
|
||||
var window = aTab.ownerDocument.defaultView;
|
||||
let window = aTab.ownerDocument.defaultView;
|
||||
if (!("__SSi" in window)) {
|
||||
debug("Default view of ownerDocument must have a unique identifier");
|
||||
throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
|
||||
}
|
||||
|
||||
TabStateCache.delete(aTab);
|
||||
this._setWindowStateBusy(window);
|
||||
this.restoreHistoryPrecursor(window, [aTab], [tabState], 0, 0, 0);
|
||||
},
|
||||
@ -1512,9 +1576,9 @@ let SessionStoreInternal = {
|
||||
!aWindow.getBrowser)
|
||||
throw (Components.returnCode = Cr.NS_ERROR_INVALID_ARG);
|
||||
|
||||
var tabState = this._collectTabData(aTab, true);
|
||||
var sourceWindow = aTab.ownerDocument.defaultView;
|
||||
this._updateTextAndScrollDataForTab(sourceWindow, aTab.linkedBrowser, tabState, true);
|
||||
// Duplicate the tab state
|
||||
let tabState = this._cloneFullTabData(aTab);
|
||||
|
||||
tabState.index += aDelta;
|
||||
tabState.index = Math.max(1, Math.min(tabState.index, tabState.entries.length));
|
||||
tabState.pinned = false;
|
||||
@ -1684,6 +1748,7 @@ let SessionStoreInternal = {
|
||||
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) {
|
||||
@ -1699,6 +1764,7 @@ let SessionStoreInternal = {
|
||||
},
|
||||
|
||||
setTabValue: function ssi_setTabValue(aTab, aKey, aStringValue) {
|
||||
TabStateCache.delete(aTab);
|
||||
// If the tab hasn't been restored, then set the data there, otherwise we
|
||||
// could lose newly added data.
|
||||
let saveTo;
|
||||
@ -1717,6 +1783,7 @@ let SessionStoreInternal = {
|
||||
},
|
||||
|
||||
deleteTabValue: function ssi_deleteTabValue(aTab, aKey) {
|
||||
TabStateCache.delete(aTab);
|
||||
// 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.
|
||||
@ -1730,10 +1797,12 @@ let SessionStoreInternal = {
|
||||
|
||||
if (deleteFrom && deleteFrom[aKey])
|
||||
delete deleteFrom[aKey];
|
||||
this.saveStateDelayed(aTab.ownerDocument.defaultView);
|
||||
},
|
||||
|
||||
persistTabAttribute: function ssi_persistTabAttribute(aName) {
|
||||
if (TabAttributes.persist(aName)) {
|
||||
TabStateCache.clear();
|
||||
this.saveStateDelayed();
|
||||
}
|
||||
},
|
||||
@ -1907,37 +1976,56 @@ let SessionStoreInternal = {
|
||||
/* ........ Saving Functionality .............. */
|
||||
|
||||
/**
|
||||
* Store all session data for a window
|
||||
* @param aWindow
|
||||
* Window reference
|
||||
* Collect data related to a single tab
|
||||
*
|
||||
* @param aTab
|
||||
* tabbrowser tab
|
||||
*
|
||||
* @returns {TabData} An object with the data for this tab. If the
|
||||
* tab has not been invalidated since the last call to
|
||||
* _collectTabData(aTab), the same object is returned.
|
||||
*/
|
||||
_saveWindowHistory: function ssi_saveWindowHistory(aWindow) {
|
||||
var tabbrowser = aWindow.gBrowser;
|
||||
var tabs = tabbrowser.tabs;
|
||||
var tabsData = this._windows[aWindow.__SSi].tabs = [];
|
||||
|
||||
for (var i = 0; i < tabs.length; i++)
|
||||
tabsData.push(this._collectTabData(tabs[i]));
|
||||
|
||||
this._windows[aWindow.__SSi].selected = tabbrowser.mTabBox.selectedIndex + 1;
|
||||
_collectTabData: function ssi_collectTabData(aTab) {
|
||||
if (!aTab) {
|
||||
throw new TypeError("Expecting a tab");
|
||||
}
|
||||
let tabData;
|
||||
if ((tabData = TabStateCache.get(aTab))) {
|
||||
return tabData;
|
||||
}
|
||||
tabData = new TabData(this._collectBaseTabData(aTab));
|
||||
if (this._updateTextAndScrollDataForTab(aTab, tabData)) {
|
||||
TabStateCache.set(aTab, tabData);
|
||||
}
|
||||
return tabData;
|
||||
},
|
||||
|
||||
/**
|
||||
* Collect data related to a single tab
|
||||
* Collect data related to a single tab, including private data.
|
||||
* Use with caution.
|
||||
*
|
||||
* @param aTab
|
||||
* tabbrowser tab
|
||||
* @param aFullData
|
||||
* always return privacy sensitive data (use with care)
|
||||
* @returns object
|
||||
*
|
||||
* @returns {object} An object with the data for this tab. This object
|
||||
* is recomputed at every call.
|
||||
*/
|
||||
_collectTabData: function ssi_collectTabData(aTab, aFullData) {
|
||||
var tabData = { entries: [], lastAccessed: aTab.lastAccessed };
|
||||
var browser = aTab.linkedBrowser;
|
||||
_cloneFullTabData: function ssi_cloneFullTabData(aTab) {
|
||||
let options = { includePrivateData: true };
|
||||
let tabData = this._collectBaseTabData(aTab, options);
|
||||
this._updateTextAndScrollDataForTab(aTab, tabData, options);
|
||||
return tabData;
|
||||
},
|
||||
|
||||
if (!browser || !browser.currentURI)
|
||||
_collectBaseTabData: function ssi_collectBaseTabData(aTab, aOptions = null) {
|
||||
let includePrivateData = aOptions && aOptions.includePrivateData;
|
||||
let tabData = {entries: [], lastAccessed: aTab.lastAccessed };
|
||||
let browser = aTab.linkedBrowser;
|
||||
if (!browser || !browser.currentURI) {
|
||||
// can happen when calling this function right after .addTab()
|
||||
return tabData;
|
||||
else if (browser.__SS_data && browser.__SS_tabStillLoading) {
|
||||
}
|
||||
if (browser.__SS_data && browser.__SS_tabStillLoading) {
|
||||
// use the data to be restored when the tab hasn't been completely loaded
|
||||
tabData = browser.__SS_data;
|
||||
if (aTab.pinned)
|
||||
@ -1967,7 +2055,7 @@ let SessionStoreInternal = {
|
||||
if (history && browser.__SS_data &&
|
||||
browser.__SS_data.entries[history.index] &&
|
||||
browser.__SS_data.entries[history.index].url == browser.currentURI.spec &&
|
||||
history.index < this._sessionhistory_max_entries - 1 && !aFullData) {
|
||||
history.index < this._sessionhistory_max_entries - 1 && !includePrivateData) {
|
||||
tabData = browser.__SS_data;
|
||||
tabData.index = history.index + 1;
|
||||
}
|
||||
@ -1976,7 +2064,7 @@ let SessionStoreInternal = {
|
||||
try {
|
||||
for (var j = 0; j < history.count; j++) {
|
||||
let entry = this._serializeHistoryEntry(history.getEntryAtIndex(j, false),
|
||||
aFullData, aTab.pinned, browser.__SS_hostSchemeData);
|
||||
includePrivateData, aTab.pinned, browser.__SS_hostSchemeData);
|
||||
tabData.entries.push(entry);
|
||||
}
|
||||
// If we make it through the for loop, then we're ok and we should clear
|
||||
@ -2002,7 +2090,7 @@ let SessionStoreInternal = {
|
||||
tabData.index = history.index + 1;
|
||||
|
||||
// make sure not to cache privacy sensitive data which shouldn't get out
|
||||
if (!aFullData)
|
||||
if (!includePrivateData)
|
||||
browser.__SS_data = tabData;
|
||||
}
|
||||
else if (browser.currentURI.spec != "about:blank" ||
|
||||
@ -2051,7 +2139,7 @@ let SessionStoreInternal = {
|
||||
delete tabData.extData;
|
||||
|
||||
if (history && browser.docShell instanceof Ci.nsIDocShell) {
|
||||
let storageData = SessionStorage.serialize(browser.docShell, aFullData)
|
||||
let storageData = SessionStorage.serialize(browser.docShell, includePrivateData)
|
||||
if (Object.keys(storageData).length)
|
||||
tabData.storage = storageData;
|
||||
}
|
||||
@ -2064,7 +2152,7 @@ let SessionStoreInternal = {
|
||||
* Used for data storage
|
||||
* @param aEntry
|
||||
* nsISHEntry instance
|
||||
* @param aFullData
|
||||
* @param aIncludePrivateData
|
||||
* always return privacy sensitive data (use with care)
|
||||
* @param aIsPinned
|
||||
* the tab is pinned and should be treated differently for privacy
|
||||
@ -2073,7 +2161,7 @@ let SessionStoreInternal = {
|
||||
* @returns object
|
||||
*/
|
||||
_serializeHistoryEntry:
|
||||
function ssi_serializeHistoryEntry(aEntry, aFullData, aIsPinned, aHostSchemeData) {
|
||||
function ssi_serializeHistoryEntry(aEntry, aIncludePrivateData, aIsPinned, aHostSchemeData) {
|
||||
var entry = { url: aEntry.URI.spec };
|
||||
|
||||
try {
|
||||
@ -2124,7 +2212,7 @@ let SessionStoreInternal = {
|
||||
|
||||
try {
|
||||
var prefPostdata = this._prefBranch.getIntPref("sessionstore.postdata");
|
||||
if (aEntry.postData && (aFullData || prefPostdata &&
|
||||
if (aEntry.postData && (aIncludePrivateData || prefPostdata &&
|
||||
this.checkPrivacyLevel(aEntry.URI.schemeIs("https"), aIsPinned))) {
|
||||
aEntry.postData.QueryInterface(Ci.nsISeekableStream).
|
||||
seek(Ci.nsISeekableStream.NS_SEEK_SET, 0);
|
||||
@ -2133,7 +2221,7 @@ let SessionStoreInternal = {
|
||||
stream.setInputStream(aEntry.postData);
|
||||
var postBytes = stream.readByteArray(stream.available());
|
||||
var postdata = String.fromCharCode.apply(null, postBytes);
|
||||
if (aFullData || prefPostdata == -1 ||
|
||||
if (aIncludePrivateData || prefPostdata == -1 ||
|
||||
postdata.replace(/^(Content-.*\r\n)+(\r\n)*/, "").length <=
|
||||
prefPostdata) {
|
||||
// We can stop doing base64 encoding once our serialization into JSON
|
||||
@ -2194,7 +2282,7 @@ let SessionStoreInternal = {
|
||||
break;
|
||||
}
|
||||
|
||||
children.push(this._serializeHistoryEntry(child, aFullData,
|
||||
children.push(this._serializeHistoryEntry(child, aIncludePrivateData,
|
||||
aIsPinned, aHostSchemeData));
|
||||
}
|
||||
}
|
||||
@ -2207,63 +2295,57 @@ let SessionStoreInternal = {
|
||||
},
|
||||
|
||||
/**
|
||||
* go through all tabs and store the current scroll positions
|
||||
* Go through all frames and store the current scroll positions
|
||||
* and innerHTML content of WYSIWYG editors
|
||||
* @param aWindow
|
||||
* Window reference
|
||||
*/
|
||||
_updateTextAndScrollData: function ssi_updateTextAndScrollData(aWindow) {
|
||||
var browsers = aWindow.gBrowser.browsers;
|
||||
this._windows[aWindow.__SSi].tabs.forEach(function (tabData, i) {
|
||||
try {
|
||||
this._updateTextAndScrollDataForTab(aWindow, browsers[i], tabData);
|
||||
}
|
||||
catch (ex) { debug(ex); } // get as much data as possible, ignore failures (might succeed the next time)
|
||||
}, this);
|
||||
},
|
||||
|
||||
/**
|
||||
* go through all frames and store the current scroll positions
|
||||
* and innerHTML content of WYSIWYG editors
|
||||
* @param aWindow
|
||||
* Window reference
|
||||
* @param aBrowser
|
||||
* single browser reference
|
||||
*
|
||||
* @param aTab
|
||||
* tabbrowser tab
|
||||
* @param aTabData
|
||||
* tabData object to add the information to
|
||||
* @param aFullData
|
||||
* always return privacy sensitive data (use with care)
|
||||
* @param options
|
||||
* An optional object that may contain the following field:
|
||||
* - includePrivateData: always return privacy sensitive data
|
||||
* (use with care)
|
||||
* @return false if data should not be cached because the tab
|
||||
* has not been fully initialized yet.
|
||||
*/
|
||||
_updateTextAndScrollDataForTab:
|
||||
function ssi_updateTextAndScrollDataForTab(aWindow, aBrowser, aTabData, aFullData) {
|
||||
function ssi_updateTextAndScrollDataForTab(aTab, aTabData, aOptions = null) {
|
||||
let includePrivateData = aOptions && aOptions.includePrivateData;
|
||||
let window = aTab.ownerDocument.defaultView;
|
||||
let browser = aTab.linkedBrowser;
|
||||
// we shouldn't update data for incompletely initialized tabs
|
||||
if (aBrowser.__SS_data && aBrowser.__SS_tabStillLoading)
|
||||
return;
|
||||
if (!browser.currentURI
|
||||
|| (browser.__SS_data && browser.__SS_tabStillLoading)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
var tabIndex = (aTabData.index || aTabData.entries.length) - 1;
|
||||
let tabIndex = (aTabData.index || aTabData.entries.length) - 1;
|
||||
// entry data needn't exist for tabs just initialized with an incomplete session state
|
||||
if (!aTabData.entries[tabIndex])
|
||||
return;
|
||||
if (!aTabData.entries[tabIndex]) {
|
||||
return false;
|
||||
}
|
||||
|
||||
let selectedPageStyle = aBrowser.markupDocumentViewer.authorStyleDisabled ? "_nostyle" :
|
||||
this._getSelectedPageStyle(aBrowser.contentWindow);
|
||||
let selectedPageStyle = browser.markupDocumentViewer.authorStyleDisabled ? "_nostyle" :
|
||||
this._getSelectedPageStyle(browser.contentWindow);
|
||||
if (selectedPageStyle)
|
||||
aTabData.pageStyle = selectedPageStyle;
|
||||
else if (aTabData.pageStyle)
|
||||
delete aTabData.pageStyle;
|
||||
|
||||
this._updateTextAndScrollDataForFrame(aWindow, aBrowser.contentWindow,
|
||||
this._updateTextAndScrollDataForFrame(window, browser.contentWindow,
|
||||
aTabData.entries[tabIndex],
|
||||
!aBrowser.__SS_formDataSaved, aFullData,
|
||||
!browser.__SS_formDataSaved, includePrivateData,
|
||||
!!aTabData.pinned);
|
||||
aBrowser.__SS_formDataSaved = true;
|
||||
if (aBrowser.currentURI.spec == "about:config")
|
||||
browser.__SS_formDataSaved = true;
|
||||
if (browser.currentURI.spec == "about:config")
|
||||
aTabData.entries[tabIndex].formdata = {
|
||||
id: {
|
||||
"textbox": aBrowser.contentDocument.getElementById("textbox").value
|
||||
"textbox": browser.contentDocument.getElementById("textbox").value
|
||||
},
|
||||
xpath: {}
|
||||
};
|
||||
return true;
|
||||
},
|
||||
|
||||
/**
|
||||
@ -2277,26 +2359,26 @@ let SessionStoreInternal = {
|
||||
* part of a tabData object to add the information to
|
||||
* @param aUpdateFormData
|
||||
* update all form data for this tab
|
||||
* @param aFullData
|
||||
* @param aIncludePrivateData
|
||||
* always return privacy sensitive data (use with care)
|
||||
* @param aIsPinned
|
||||
* the tab is pinned and should be treated differently for privacy
|
||||
*/
|
||||
_updateTextAndScrollDataForFrame:
|
||||
function ssi_updateTextAndScrollDataForFrame(aWindow, aContent, aData,
|
||||
aUpdateFormData, aFullData, aIsPinned) {
|
||||
aUpdateFormData, aIncludePrivateData, aIsPinned) {
|
||||
for (var i = 0; i < aContent.frames.length; i++) {
|
||||
if (aData.children && aData.children[i])
|
||||
this._updateTextAndScrollDataForFrame(aWindow, aContent.frames[i],
|
||||
aData.children[i], aUpdateFormData,
|
||||
aFullData, aIsPinned);
|
||||
aIncludePrivateData, aIsPinned);
|
||||
}
|
||||
var isHTTPS = this._getURIFromString((aContent.parent || aContent).
|
||||
document.location.href).schemeIs("https");
|
||||
let topURL = aContent.top.document.location.href;
|
||||
let isAboutSR = topURL == "about:sessionrestore" || topURL == "about:welcomeback";
|
||||
if (aFullData || this.checkPrivacyLevel(isHTTPS, aIsPinned) || isAboutSR) {
|
||||
if (aFullData || aUpdateFormData) {
|
||||
if (aIncludePrivateData || this.checkPrivacyLevel(isHTTPS, aIsPinned) || isAboutSR) {
|
||||
if (aIncludePrivateData || aUpdateFormData) {
|
||||
let formData = DocumentUtils.getFormData(aContent.document);
|
||||
|
||||
// We want to avoid saving data for about:sessionrestore as a string.
|
||||
@ -2419,28 +2501,6 @@ let SessionStoreInternal = {
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* store all hosts for a URL
|
||||
* @param aWindow
|
||||
* Window reference
|
||||
*/
|
||||
_updateCookieHosts: function ssi_updateCookieHosts(aWindow) {
|
||||
var hosts = this._internalWindows[aWindow.__SSi].hosts = {};
|
||||
|
||||
// Since _updateCookiesHosts is only ever called for open windows during a
|
||||
// session, we can call into _extractHostsForCookiesFromHostScheme directly
|
||||
// using data that is attached to each browser.
|
||||
for (let i = 0; i < aWindow.gBrowser.tabs.length; i++) {
|
||||
let tab = aWindow.gBrowser.tabs[i];
|
||||
let hostSchemeData = tab.linkedBrowser.__SS_hostSchemeData || [];
|
||||
for (let j = 0; j < hostSchemeData.length; j++) {
|
||||
this._extractHostsForCookiesFromHostScheme(hostSchemeData[j].host,
|
||||
hostSchemeData[j].scheme,
|
||||
hosts, true, tab.pinned);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
/**
|
||||
* Serialize cookie data
|
||||
* @param aWindows
|
||||
@ -2678,10 +2738,29 @@ let SessionStoreInternal = {
|
||||
if (!this._isWindowLoaded(aWindow))
|
||||
return;
|
||||
|
||||
let tabbrowser = aWindow.gBrowser;
|
||||
let tabs = tabbrowser.tabs;
|
||||
let winData = this._windows[aWindow.__SSi];
|
||||
let tabsData = winData.tabs = [];
|
||||
let hosts = this._internalWindows[aWindow.__SSi].hosts = {};
|
||||
|
||||
// update the internal state data for this window
|
||||
this._saveWindowHistory(aWindow);
|
||||
this._updateTextAndScrollData(aWindow);
|
||||
this._updateCookieHosts(aWindow);
|
||||
for (let tab of tabs) {
|
||||
tabsData.push(this._collectTabData(tab));
|
||||
|
||||
// Since we are only ever called for open
|
||||
// windows during a session, we can call into
|
||||
// _extractHostsForCookiesFromHostScheme directly using data
|
||||
// that is attached to each browser.
|
||||
let hostSchemeData = tab.linkedBrowser.__SS_hostSchemeData || [];
|
||||
for (let j = 0; j < hostSchemeData.length; j++) {
|
||||
this._extractHostsForCookiesFromHostScheme(hostSchemeData[j].host,
|
||||
hostSchemeData[j].scheme,
|
||||
hosts, true, tab.pinned);
|
||||
}
|
||||
}
|
||||
winData.selected = tabbrowser.mTabBox.selectedIndex + 1;
|
||||
|
||||
this._updateWindowFeatures(aWindow);
|
||||
|
||||
// Make sure we keep __SS_lastSessionWindowID around for cases like entering
|
||||
@ -2815,10 +2894,13 @@ let SessionStoreInternal = {
|
||||
// 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 restoreHistoryPrecursor).
|
||||
// We also want to invalidate any cached information on the tab state.
|
||||
if (aOverwriteTabs) {
|
||||
for (let i = 0; i < tabbrowser.tabs.length; i++) {
|
||||
let tab = tabbrowser.tabs[i];
|
||||
TabStateCache.delete(tab);
|
||||
if (tabbrowser.browsers[i].__SS_restoreState)
|
||||
this._resetTabRestoringState(tabbrowser.tabs[i]);
|
||||
this._resetTabRestoringState(tab);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2980,6 +3062,7 @@ let SessionStoreInternal = {
|
||||
restoreHistoryPrecursor:
|
||||
function ssi_restoreHistoryPrecursor(aWindow, aTabs, aTabData, aSelectTab,
|
||||
aIx, aCount, aRestoreImmediately = false) {
|
||||
|
||||
var tabbrowser = aWindow.gBrowser;
|
||||
|
||||
// make sure that all browsers and their histories are available
|
||||
@ -2995,7 +3078,7 @@ let SessionStoreInternal = {
|
||||
var restoreHistoryFunc = function(self) {
|
||||
self.restoreHistoryPrecursor(aWindow, aTabs, aTabData, aSelectTab,
|
||||
aIx, aCount + 1, aRestoreImmediately);
|
||||
}
|
||||
};
|
||||
aWindow.setTimeout(restoreHistoryFunc, 100, this);
|
||||
return;
|
||||
}
|
||||
@ -3131,7 +3214,6 @@ let SessionStoreInternal = {
|
||||
|
||||
var tab = aTabs.shift();
|
||||
var tabData = aTabData.shift();
|
||||
|
||||
var browser = aWindow.gBrowser.getBrowserForTab(tab);
|
||||
var history = browser.webNavigation.sessionHistory;
|
||||
|
||||
@ -3696,7 +3778,7 @@ let SessionStoreInternal = {
|
||||
* @param aDelay
|
||||
* Milliseconds to delay
|
||||
*/
|
||||
saveStateDelayed: function ssi_saveStateDelayed(aWindow, aDelay) {
|
||||
saveStateDelayed: function ssi_saveStateDelayed(aWindow = null, aDelay = 2000) {
|
||||
if (aWindow) {
|
||||
this._dirtyWindows[aWindow.__SSi] = true;
|
||||
}
|
||||
@ -3706,7 +3788,7 @@ let SessionStoreInternal = {
|
||||
var minimalDelay = this._lastSaveTime + this._interval - Date.now();
|
||||
|
||||
// if we have to wait, set a timer, otherwise saveState directly
|
||||
aDelay = Math.max(minimalDelay, aDelay || 2000);
|
||||
aDelay = Math.max(minimalDelay, aDelay);
|
||||
if (aDelay > 0) {
|
||||
this._saveTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
|
||||
this._saveTimer.init(this, aDelay, Ci.nsITimer.TYPE_ONE_SHOT);
|
||||
@ -3978,6 +4060,7 @@ let SessionStoreInternal = {
|
||||
if (tab.linkedBrowser == aBrowser)
|
||||
return tab;
|
||||
}
|
||||
return undefined;
|
||||
},
|
||||
|
||||
/**
|
||||
@ -4800,11 +4883,25 @@ SessionStoreSHistoryListener.prototype = {
|
||||
Ci.nsISupportsWeakReference
|
||||
]),
|
||||
browser: null,
|
||||
OnHistoryNewEntry: function(aNewURI) { },
|
||||
OnHistoryGoBack: function(aBackURI) { return true; },
|
||||
OnHistoryGoForward: function(aForwardURI) { return true; },
|
||||
OnHistoryGotoIndex: function(aIndex, aGotoURI) { return true; },
|
||||
OnHistoryPurge: function(aNumEntries) { return true; },
|
||||
// The following events (with the exception of OnHistoryPurge)
|
||||
// accompany either a "load" or a "pageshow" which will in turn cause
|
||||
// invalidations.
|
||||
OnHistoryNewEntry: function(aNewURI) {
|
||||
|
||||
},
|
||||
OnHistoryGoBack: function(aBackURI) {
|
||||
return true;
|
||||
},
|
||||
OnHistoryGoForward: function(aForwardURI) {
|
||||
return true;
|
||||
},
|
||||
OnHistoryGotoIndex: function(aIndex, aGotoURI) {
|
||||
return true;
|
||||
},
|
||||
OnHistoryPurge: function(aNumEntries) {
|
||||
TabStateCache.delete(this.tab);
|
||||
return true;
|
||||
},
|
||||
OnHistoryReload: function(aReloadURI, aReloadFlags) {
|
||||
// On reload, we want to make sure that session history loads the right
|
||||
// URI. In order to do that, we will juet call restoreTab. That will remove
|
||||
@ -4827,4 +4924,106 @@ String.prototype.hasRootDomain = function hasRootDomain(aDomain) {
|
||||
let prevChar = this[index - 1];
|
||||
return (index == (this.length - aDomain.length)) &&
|
||||
(prevChar == "." || prevChar == "/");
|
||||
};
|
||||
|
||||
function TabData(obj = null) {
|
||||
if (obj) {
|
||||
if (obj instanceof TabData) {
|
||||
// FIXME: Can we get rid of this?
|
||||
return obj;
|
||||
}
|
||||
for (let [key, value] in Iterator(obj)) {
|
||||
this[key] = value;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* A cache for tabs data.
|
||||
*
|
||||
* This cache implements a weak map from tabs (as XUL elements)
|
||||
* to tab data (as instances of TabData).
|
||||
*
|
||||
* Note that we should never cache private data, as:
|
||||
* - that data is used very seldom by SessionStore;
|
||||
* - caching private data in addition to public data is memory consuming.
|
||||
*/
|
||||
let TabStateCache = {
|
||||
_data: new WeakMap(),
|
||||
|
||||
/**
|
||||
* Add or replace an entry in the cache.
|
||||
*
|
||||
* @param {XULElement} aTab The key, which may be either a tab
|
||||
* or the corresponding browser. The binding will disappear
|
||||
* if the tab/browser is destroyed.
|
||||
* @param {TabData} aValue The data associated to |aTab|.
|
||||
*/
|
||||
set: function(aTab, aValue) {
|
||||
let key = this._normalizeToBrowser(aTab);
|
||||
if (!(aValue instanceof TabData)) {
|
||||
throw new TypeError("Attempting to cache a non TabData");
|
||||
}
|
||||
this._data.set(key, aValue);
|
||||
},
|
||||
|
||||
/**
|
||||
* Return the tab data associated with a tab.
|
||||
*
|
||||
* @param {XULElement} aKey The tab or the associated browser.
|
||||
*
|
||||
* @return {TabData|undefined} The data if available, |undefined|
|
||||
* otherwise.
|
||||
*/
|
||||
get: function(aKey) {
|
||||
let key = this._normalizeToBrowser(aKey);
|
||||
return this._data.get(key);
|
||||
},
|
||||
|
||||
/**
|
||||
* Delete the tab data associated with a tab.
|
||||
*
|
||||
* @param {XULElement} aKey The tab or the associated browser.
|
||||
*
|
||||
* Noop of there is no tab data associated with the tab.
|
||||
*/
|
||||
delete: function(aKey) {
|
||||
let key = this._normalizeToBrowser(aKey);
|
||||
this._data.delete(key);
|
||||
},
|
||||
|
||||
/**
|
||||
* Delete all tab data.
|
||||
*/
|
||||
clear: function() {
|
||||
this._data.clear();
|
||||
},
|
||||
|
||||
/**
|
||||
* Update in place a piece of data.
|
||||
*
|
||||
* @param {XULElement} aKey The tab or the associated browser.
|
||||
* If the tab/browser is not present, do nothing.
|
||||
* @param {string} aField The field to update.
|
||||
* @param {*} aValue The new value to place in the field.
|
||||
*/
|
||||
update: function(aKey, aField, aValue) {
|
||||
let key = this._normalizeToBrowser(aKey);
|
||||
let data = this._data.get(key);
|
||||
if (data) {
|
||||
data[aField] = aValue;
|
||||
}
|
||||
},
|
||||
|
||||
_normalizeToBrowser: function(aKey) {
|
||||
let nodeName = aKey.localName;
|
||||
if (nodeName == "tab") {
|
||||
return aKey.linkedBrowser;
|
||||
}
|
||||
if (nodeName == "browser") {
|
||||
return aKey;
|
||||
}
|
||||
throw new TypeError("Key is neither a tab nor a browser: " + nodeName);
|
||||
}
|
||||
};
|
||||
|
||||
Loading…
Reference in New Issue
Block a user