From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- .../components/sessionstore/SessionSaver.sys.mjs | 405 +++++++++++++++++++++ 1 file changed, 405 insertions(+) create mode 100644 browser/components/sessionstore/SessionSaver.sys.mjs (limited to 'browser/components/sessionstore/SessionSaver.sys.mjs') diff --git a/browser/components/sessionstore/SessionSaver.sys.mjs b/browser/components/sessionstore/SessionSaver.sys.mjs new file mode 100644 index 0000000000..2f08bb2243 --- /dev/null +++ b/browser/components/sessionstore/SessionSaver.sys.mjs @@ -0,0 +1,405 @@ +/* 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/. */ + +import { + cancelIdleCallback, + clearTimeout, + requestIdleCallback, + setTimeout, +} from "resource://gre/modules/Timer.sys.mjs"; +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; +import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + PrivacyFilter: "resource://gre/modules/sessionstore/PrivacyFilter.sys.mjs", + PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs", + RunState: "resource:///modules/sessionstore/RunState.sys.mjs", + SessionFile: "resource:///modules/sessionstore/SessionFile.sys.mjs", + SessionStore: "resource:///modules/sessionstore/SessionStore.sys.mjs", +}); + +/* + * Minimal interval between two save operations (in milliseconds). + * + * To save system resources, we generally do not save changes immediately when + * a change is detected. Rather, we wait a little to see if this change is + * followed by other changes, in which case only the last write is necessary. + * This delay is defined by "browser.sessionstore.interval". + * + * Furthermore, when the user is not actively using the computer, webpages + * may still perform changes that require (re)writing to sessionstore, e.g. + * updating Session Cookies or DOM Session Storage, or refreshing, etc. We + * expect that these changes are much less critical to the user and do not + * need to be saved as often. In such cases, we increase the delay to + * "browser.sessionstore.interval.idle". + * + * When the user returns to the computer, if a save is pending, we reschedule + * it to happen soon, with "browser.sessionstore.interval". + */ +const PREF_INTERVAL_ACTIVE = "browser.sessionstore.interval"; +const PREF_INTERVAL_IDLE = "browser.sessionstore.interval.idle"; +const PREF_IDLE_DELAY = "browser.sessionstore.idleDelay"; + +// Notify observers about a given topic with a given subject. +function notify(subject, topic) { + Services.obs.notifyObservers(subject, topic); +} + +// TelemetryStopwatch helper functions. +function stopWatch(method) { + return function (...histograms) { + for (let hist of histograms) { + TelemetryStopwatch[method]("FX_SESSION_RESTORE_" + hist); + } + }; +} + +var stopWatchStart = stopWatch("start"); +var stopWatchFinish = stopWatch("finish"); + +/** + * The external API implemented by the SessionSaver module. + */ +export var SessionSaver = Object.freeze({ + /** + * Immediately saves the current session to disk. + */ + run() { + return SessionSaverInternal.run(); + }, + + /** + * Saves the current session to disk delayed by a given amount of time. Should + * another delayed run be scheduled already, we will ignore the given delay + * and state saving may occur a little earlier. + */ + runDelayed() { + SessionSaverInternal.runDelayed(); + }, + + /** + * Sets the last save time to the current time. This will cause us to wait for + * at least the configured interval when runDelayed() is called next. + */ + updateLastSaveTime() { + SessionSaverInternal.updateLastSaveTime(); + }, + + /** + * Cancels all pending session saves. + */ + cancel() { + SessionSaverInternal.cancel(); + }, +}); + +/** + * The internal API. + */ +var SessionSaverInternal = { + /** + * The timeout ID referencing an active timer for a delayed save. When no + * save is pending, this is null. + */ + _timeoutID: null, + + /** + * The idle callback ID referencing an active idle callback. When no idle + * callback is pending, this is null. + * */ + _idleCallbackID: null, + + /** + * A timestamp that keeps track of when we saved the session last. We will + * this to determine the correct interval between delayed saves to not deceed + * the configured session write interval. + */ + _lastSaveTime: 0, + + /** + * `true` if the user has been idle for at least + * `SessionSaverInternal._intervalWhileIdle` ms. Idleness is computed + * with `nsIUserIdleService`. + */ + _isIdle: false, + + /** + * `true` if the user was idle when we last scheduled a delayed save. + * See `_isIdle` for details on idleness. + */ + _wasIdle: false, + + /** + * Minimal interval between two save operations (in ms), while the user + * is active. + */ + _intervalWhileActive: null, + + /** + * Minimal interval between two save operations (in ms), while the user + * is idle. + */ + _intervalWhileIdle: null, + + /** + * How long before we assume that the user is idle (ms). + */ + _idleDelay: null, + + /** + * Immediately saves the current session to disk. + */ + run() { + return this._saveState(true /* force-update all windows */); + }, + + /** + * Saves the current session to disk delayed by a given amount of time. Should + * another delayed run be scheduled already, we will ignore the given delay + * and state saving may occur a little earlier. + * + * @param delay (optional) + * The minimum delay in milliseconds to wait for until we collect and + * save the current session. + */ + runDelayed(delay = 2000) { + // Bail out if there's a pending run. + if (this._timeoutID) { + return; + } + + // Interval until the next disk operation is allowed. + let interval = this._isIdle + ? this._intervalWhileIdle + : this._intervalWhileActive; + delay = Math.max(this._lastSaveTime + interval - Date.now(), delay, 0); + + // Schedule a state save. + this._wasIdle = this._isIdle; + this._timeoutID = setTimeout(() => { + // Execute _saveStateAsync when we have idle time. + let saveStateAsyncWhenIdle = () => { + this._saveStateAsync(); + }; + + this._idleCallbackID = requestIdleCallback(saveStateAsyncWhenIdle); + }, delay); + }, + + /** + * Sets the last save time to the current time. This will cause us to wait for + * at least the configured interval when runDelayed() is called next. + */ + updateLastSaveTime() { + this._lastSaveTime = Date.now(); + }, + + /** + * Cancels all pending session saves. + */ + cancel() { + clearTimeout(this._timeoutID); + this._timeoutID = null; + cancelIdleCallback(this._idleCallbackID); + this._idleCallbackID = null; + }, + + /** + * Observe idle/ active notifications. + */ + observe(subject, topic, data) { + switch (topic) { + case "idle": + this._isIdle = true; + break; + case "active": + this._isIdle = false; + if (this._timeoutID && this._wasIdle) { + // A state save has been scheduled while we were idle. + // Replace it by an active save. + clearTimeout(this._timeoutID); + this._timeoutID = null; + this.runDelayed(); + } + break; + default: + throw new Error(`Unexpected change value ${topic}`); + } + }, + + /** + * Saves the current session state. Collects data and writes to disk. + * + * @param forceUpdateAllWindows (optional) + * Forces us to recollect data for all windows and will bypass and + * update the corresponding caches. + */ + _saveState(forceUpdateAllWindows = false) { + // Cancel any pending timeouts. + this.cancel(); + + if (lazy.PrivateBrowsingUtils.permanentPrivateBrowsing) { + // Don't save (or even collect) anything in permanent private + // browsing mode + + this.updateLastSaveTime(); + return Promise.resolve(); + } + + stopWatchStart("COLLECT_DATA_MS"); + let state = lazy.SessionStore.getCurrentState(forceUpdateAllWindows); + lazy.PrivacyFilter.filterPrivateWindowsAndTabs(state); + + // Make sure we only write worth saving tabs to disk. + lazy.SessionStore.keepOnlyWorthSavingTabs(state); + + // Make sure that we keep the previous session if we started with a single + // private window and no non-private windows have been opened, yet. + if (state.deferredInitialState) { + state.windows = state.deferredInitialState.windows || []; + delete state.deferredInitialState; + } + + if (AppConstants.platform != "macosx") { + // We want to restore closed windows that are marked with _shouldRestore. + // We're doing this here because we want to control this only when saving + // the file. + while (state._closedWindows.length) { + let i = state._closedWindows.length - 1; + + if (!state._closedWindows[i]._shouldRestore) { + // We only need to go until _shouldRestore + // is falsy since we're going in reverse. + break; + } + + delete state._closedWindows[i]._shouldRestore; + state.windows.unshift(state._closedWindows.pop()); + } + } + + // Clear cookies and storage on clean shutdown. + this._maybeClearCookiesAndStorage(state); + + stopWatchFinish("COLLECT_DATA_MS"); + return this._writeState(state); + }, + + /** + * Purges cookies and DOMSessionStorage data from the session on clean + * shutdown, only if requested by the user's preferences. + */ + _maybeClearCookiesAndStorage(state) { + // Only do this on shutdown. + if (!lazy.RunState.isClosing) { + return; + } + + // Don't clear when restarting. + if ( + Services.prefs.getBoolPref("browser.sessionstore.resume_session_once") + ) { + return; + } + let sanitizeCookies = + Services.prefs.getBoolPref("privacy.sanitize.sanitizeOnShutdown") && + Services.prefs.getBoolPref("privacy.clearOnShutdown.cookies"); + + if (sanitizeCookies) { + // Remove cookies. + delete state.cookies; + + // Remove DOMSessionStorage data. + for (let window of state.windows) { + for (let tab of window.tabs) { + delete tab.storage; + } + } + } + }, + + /** + * Saves the current session state. Collects data asynchronously and calls + * _saveState() to collect data again (with a cache hit rate of hopefully + * 100%) and write to disk afterwards. + */ + _saveStateAsync() { + // Allow scheduling delayed saves again. + this._timeoutID = null; + + // Write to disk. + this._saveState(); + }, + + /** + * Write the given state object to disk. + */ + _writeState(state) { + // We update the time stamp before writing so that we don't write again + // too soon, if saving is requested before the write completes. Without + // this update we may save repeatedly if actions cause a runDelayed + // before writing has completed. See Bug 902280 + this.updateLastSaveTime(); + + // Write (atomically) to a session file, using a tmp file. Once the session + // file is successfully updated, save the time stamp of the last save and + // notify the observers. + return lazy.SessionFile.write(state).then(() => { + this.updateLastSaveTime(); + notify(null, "sessionstore-state-write-complete"); + }, console.error); + }, +}; + +XPCOMUtils.defineLazyPreferenceGetter( + SessionSaverInternal, + "_intervalWhileActive", + PREF_INTERVAL_ACTIVE, + 15000 /* 15 seconds */, + () => { + // Cancel any pending runs and call runDelayed() with + // zero to apply the newly configured interval. + SessionSaverInternal.cancel(); + SessionSaverInternal.runDelayed(0); + } +); + +XPCOMUtils.defineLazyPreferenceGetter( + SessionSaverInternal, + "_intervalWhileIdle", + PREF_INTERVAL_IDLE, + 3600000 /* 1 h */ +); + +XPCOMUtils.defineLazyPreferenceGetter( + SessionSaverInternal, + "_idleDelay", + PREF_IDLE_DELAY, + 180 /* 3 minutes */, + (key, previous, latest) => { + // Update the idle observer for the new `PREF_IDLE_DELAY` value. Here we need + // to re-fetch the service instead of the original one in use; This is for a + // case that the Mock service in the unit test needs to be fetched to + // replace the original one. + var idleService = Cc["@mozilla.org/widget/useridleservice;1"].getService( + Ci.nsIUserIdleService + ); + if (previous != undefined) { + idleService.removeIdleObserver(SessionSaverInternal, previous); + } + if (latest != undefined) { + idleService.addIdleObserver(SessionSaverInternal, latest); + } + } +); + +var idleService = Cc["@mozilla.org/widget/useridleservice;1"].getService( + Ci.nsIUserIdleService +); +idleService.addIdleObserver( + SessionSaverInternal, + SessionSaverInternal._idleDelay +); -- cgit v1.2.3