The Tor Browser: comparison browser/components/sessionstore/src/SessionWorker.js

comparison: browser/components/sessionstore/src/SessionWorker.js

browser/components/sessionstore/src/SessionWorker.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:568c165ca49b
+/* 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/. */
+/**
+* A worker dedicated to handle I/O for Session Store.
+*/
+"use strict";
+importScripts("resource://gre/modules/osfile.jsm");
+let File = OS.File;
+let Encoder = new TextEncoder();
+let Decoder = new TextDecoder();
+/**
+* Communications with the controller.
+*
+* Accepts messages:
+* {fun:function_name, args:array_of_arguments_or_null, id: custom_id}
+*
+* Sends messages:
+* {ok: result, id: custom_id, telemetry: {}} /
+* {fail: serialized_form_of_OS.File.Error, id: custom_id}
+*/
+self.onmessage = function (msg) {
+let data = msg.data;
+if (!(data.fun in Agent)) {
+throw new Error("Cannot find method " + data.fun);
+}
+let result;
+let id = data.id;
+try {
+result = Agent[data.fun].apply(Agent, data.args) || {};
+} catch (ex if ex instanceof OS.File.Error) {
+// Instances of OS.File.Error know how to serialize themselves
+// (deserialization ensures that we end up with OS-specific
+// instances of |OS.File.Error|)
+self.postMessage({fail: OS.File.Error.toMsg(ex), id: id});
+return;
+}
+// Other exceptions do not, and should be propagated through DOM's
+// built-in mechanism for uncaught errors, although this mechanism
+// may lose interesting information.
+self.postMessage({
+ok: result.result,
+id: id,
+telemetry: result.telemetry || {}
+});
+};
+let Agent = {
+// Boolean that tells whether we already made a
+// call to write(). We will only attempt to move
+// sessionstore.js to sessionstore.bak on the
+// first write.
+hasWrittenState: false,
+// The path to sessionstore.js
+path: OS.Path.join(OS.Constants.Path.profileDir, "sessionstore.js"),
+// The path to sessionstore.bak
+backupPath: OS.Path.join(OS.Constants.Path.profileDir, "sessionstore.bak"),
+/**
+* NO-OP to start the worker.
+*/
+init: function () {
+return {result: true};
+},
+/**
+* Write the session to disk.
+*/
+write: function (stateString) {
+let exn;
+let telemetry = {};
+if (!this.hasWrittenState) {
+try {
+let startMs = Date.now();
+File.move(this.path, this.backupPath);
+telemetry.FX_SESSION_RESTORE_BACKUP_FILE_MS = Date.now() - startMs;
+} catch (ex if isNoSuchFileEx(ex)) {
+// Ignore exceptions about non-existent files.
+} catch (ex) {
+// Throw the exception after we wrote the state to disk
+// so that the backup can't interfere with the actual write.
+exn = ex;
+}
+this.hasWrittenState = true;
+}
+let ret = this._write(stateString, telemetry);
+if (exn) {
+throw exn;
+}
+return ret;
+},
+/**
+* Extract all sorts of useful statistics from a state string,
+* for use with Telemetry.
+*
+* @return {object}
+*/
+gatherTelemetry: function (stateString) {
+return Statistics.collect(stateString);
+},
+/**
+* Write a stateString to disk
+*/
+_write: function (stateString, telemetry = {}) {
+let bytes = Encoder.encode(stateString);
+let startMs = Date.now();
+let result = File.writeAtomic(this.path, bytes, {tmpPath: this.path + ".tmp"});
+telemetry.FX_SESSION_RESTORE_WRITE_FILE_MS = Date.now() - startMs;
+telemetry.FX_SESSION_RESTORE_FILE_SIZE_BYTES = bytes.byteLength;
+return {result: result, telemetry: telemetry};
+},
+/**
+* Creates a copy of sessionstore.js.
+*/
+createBackupCopy: function (ext) {
+try {
+return {result: File.copy(this.path, this.backupPath + ext)};
+} catch (ex if isNoSuchFileEx(ex)) {
+// Ignore exceptions about non-existent files.
+return {result: true};
+}
+},
+/**
+* Removes a backup copy.
+*/
+removeBackupCopy: function (ext) {
+try {
+return {result: File.remove(this.backupPath + ext)};
+} catch (ex if isNoSuchFileEx(ex)) {
+// Ignore exceptions about non-existent files.
+return {result: true};
+}
+},
+/**
+* Wipes all files holding session data from disk.
+*/
+wipe: function () {
+let exn;
+// Erase session state file
+try {
+File.remove(this.path);
+} catch (ex if isNoSuchFileEx(ex)) {
+// Ignore exceptions about non-existent files.
+} catch (ex) {
+// Don't stop immediately.
+exn = ex;
+}
+// Erase any backup, any file named "sessionstore.bak[-buildID]".
+let iter = new File.DirectoryIterator(OS.Constants.Path.profileDir);
+for (let entry in iter) {
+if (!entry.isDir && entry.path.startsWith(this.backupPath)) {
+try {
+File.remove(entry.path);
+} catch (ex) {
+// Don't stop immediately.
+exn = exn || ex;
+}
+}
+}
+if (exn) {
+throw exn;
+}
+return {result: true};
+}
+};
+function isNoSuchFileEx(aReason) {
+return aReason instanceof OS.File.Error && aReason.becauseNoSuchFile;
+}
+/**
+* Estimate the number of bytes that a data structure will use on disk
+* once serialized.
+*/
+function getByteLength(str) {
+return Encoder.encode(JSON.stringify(str)).byteLength;
+}
+/**
+* Tools for gathering statistics on a state string.
+*/
+let Statistics = {
+collect: function(stateString) {
+let start = Date.now();
+let TOTAL_PREFIX = "FX_SESSION_RESTORE_TOTAL_";
+let INDIVIDUAL_PREFIX = "FX_SESSION_RESTORE_INDIVIDUAL_";
+let SIZE_SUFFIX = "_SIZE_BYTES";
+let state = JSON.parse(stateString);
+// Gather all data
+let subsets = {};
+this.gatherSimpleData(state, subsets);
+this.gatherComplexData(state, subsets);
+// Extract telemetry
+let telemetry = {};
+for (let k of Object.keys(subsets)) {
+let obj = subsets[k];
+telemetry[TOTAL_PREFIX + k + SIZE_SUFFIX] = getByteLength(obj);
+if (Array.isArray(obj)) {
+let size = obj.map(getByteLength);
+telemetry[INDIVIDUAL_PREFIX + k + SIZE_SUFFIX] = size;
+}
+}
+let stop = Date.now();
+telemetry["FX_SESSION_RESTORE_EXTRACTING_STATISTICS_DURATION_MS"] = stop - start;
+return {
+telemetry: telemetry
+};
+},
+/**
+* Collect data that doesn't require a recursive walk through the
+* data structure.
+*/
+gatherSimpleData: function(state, subsets) {
+// The subset of sessionstore.js dealing with open windows
+subsets.OPEN_WINDOWS = state.windows;
+// The subset of sessionstore.js dealing with closed windows
+subsets.CLOSED_WINDOWS = state._closedWindows;
+// The subset of sessionstore.js dealing with closed tabs
+// in open windows
+subsets.CLOSED_TABS_IN_OPEN_WINDOWS = [];
+// The subset of sessionstore.js dealing with cookies
+// in both open and closed windows
+subsets.COOKIES = [];
+for (let winData of state.windows) {
+let closedTabs = winData._closedTabs || [];
+subsets.CLOSED_TABS_IN_OPEN_WINDOWS.push(...closedTabs);
+let cookies = winData.cookies || [];
+subsets.COOKIES.push(...cookies);
+}
+for (let winData of state._closedWindows) {
+let cookies = winData.cookies || [];
+subsets.COOKIES.push(...cookies);
+}
+},
+/**
+* Walk through a data structure, recursively.
+*
+* @param {object} root The object from which to start walking.
+* @param {function(key, value)} cb Callback, called for each
+* item except the root. Returns |true| to walk the subtree rooted
+* at |value|, |false| otherwise   */
+walk: function(root, cb) {
+if (!root || typeof root !== "object") {
+return;
+}
+for (let k of Object.keys(root)) {
+let obj = root[k];
+let stepIn = cb(k, obj);
+if (stepIn) {
+this.walk(obj, cb);
+}
+}
+},
+/**
+* Collect data that requires walking through the data structure
+*/
+gatherComplexData: function(state, subsets) {
+// The subset of sessionstore.js dealing with DOM storage
+subsets.DOM_STORAGE = [];
+// The subset of sessionstore.js storing form data
+subsets.FORMDATA = [];
+// The subset of sessionstore.js storing history
+subsets.HISTORY = [];
+this.walk(state, function(k, value) {
+let dest;
+switch (k) {
+case "entries":
+subsets.HISTORY.push(value);
+return true;
+case "storage":
+subsets.DOM_STORAGE.push(value);
+// Never visit storage, it's full of weird stuff
+return false;
+case "formdata":
+subsets.FORMDATA.push(value);
+// Never visit formdata, it's full of weird stuff
+return false;
+case "cookies": // Don't visit these places, they are full of weird stuff
+case "extData":
+return false;
+default:
+return true;
+}
+});
+return subsets;
+},
+};