tor-browser

ext-sessions.js (9993B)

---

/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set sts=2 sw=2 et tw=80: */
/* 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";

var { ExtensionError, promiseObserved } = ExtensionUtils;

ChromeUtils.defineESModuleGetters(this, {
 AddonManagerPrivate: "resource://gre/modules/AddonManager.sys.mjs",
 SessionStore: "resource:///modules/sessionstore/SessionStore.sys.mjs",
});

const SS_ON_CLOSED_OBJECTS_CHANGED = "sessionstore-closed-objects-changed";

const getRecentlyClosed = (maxResults, extension) => {
 let recentlyClosed = [];

 // Get closed windows
 // Closed private windows are not stored in sessionstore, we do
 // not need to check access for that.
 let closedWindowData = SessionStore.getClosedWindowData();
 for (let window of closedWindowData) {
   recentlyClosed.push({
     lastModified: window.closedAt,
     window: Window.convertFromSessionStoreClosedData(extension, window),
   });
 }

 // Get closed tabs
 // Private closed tabs are in sessionstore if the owning window is still open .
 for (let window of windowTracker.browserWindows()) {
   if (!extension.canAccessWindow(window)) {
     continue;
   }
   let closedTabData = SessionStore.getClosedTabDataForWindow(window);
   for (let tab of closedTabData) {
     recentlyClosed.push({
       lastModified: tab.closedAt,
       tab: Tab.convertFromSessionStoreClosedData(extension, tab, window),
     });
   }
 }

 // Sort windows and tabs
 recentlyClosed.sort((a, b) => b.lastModified - a.lastModified);
 return recentlyClosed.slice(0, maxResults);
};

const createSession = async function createSession(
 restored,
 extension,
 sessionId
) {
 if (!restored) {
   throw new ExtensionError(
     `Could not restore object using sessionId ${sessionId}.`
   );
 }
 let sessionObj = { lastModified: Date.now() };
 if (restored.isChromeWindow) {
   await promiseObserved(
     "sessionstore-single-window-restored",
     subject => subject == restored
   );
   sessionObj.window = extension.windowManager.convert(restored, {
     populate: true,
   });
   return sessionObj;
 }
 sessionObj.tab = extension.tabManager.convert(restored);
 return sessionObj;
};

const getEncodedKey = function getEncodedKey(extensionId, key) {
 // Throw if using a temporary extension id.
 if (AddonManagerPrivate.isTemporaryInstallID(extensionId)) {
   let message =
     "Sessions API storage methods will not work with a temporary addon ID. " +
     "Please add an explicit addon ID to your manifest.";
   throw new ExtensionError(message);
 }

 return `extension:${extensionId}:${key}`;
};

this.sessions = class extends ExtensionAPIPersistent {
 PERSISTENT_EVENTS = {
   onChanged({ fire }) {
     let observer = () => {
       fire.async();
     };

     Services.obs.addObserver(observer, SS_ON_CLOSED_OBJECTS_CHANGED);
     return {
       unregister() {
         Services.obs.removeObserver(observer, SS_ON_CLOSED_OBJECTS_CHANGED);
       },
       convert(_fire) {
         fire = _fire;
       },
     };
   },
 };

 getAPI(context) {
   let { extension } = context;

   function getTabParams(key, id) {
     let encodedKey = getEncodedKey(extension.id, key);
     let tab = tabTracker.getTab(id);
     if (!context.canAccessWindow(tab.ownerGlobal)) {
       throw new ExtensionError(`Invalid tab ID: ${id}`);
     }
     return { encodedKey, tab };
   }

   function getWindowParams(key, id) {
     let encodedKey = getEncodedKey(extension.id, key);
     let win = windowTracker.getWindow(id, context);
     return { encodedKey, win };
   }

   function getClosedIdFromSessionId(sessionId) {
     // sessionId is a string, but internally closedId values are integers.
     // convertFromSessionStoreClosedData in ext-browser.js does the opposite conversion.
     let closedId = parseInt(sessionId, 10);
     if (Number.isInteger(closedId)) {
       return closedId;
     }
     throw new ExtensionError(`Invalid sessionId: ${sessionId}.`);
   }

   return {
     sessions: {
       async getRecentlyClosed(filter) {
         await SessionStore.promiseInitialized;
         let maxResults =
           filter.maxResults == undefined
             ? this.MAX_SESSION_RESULTS
             : filter.maxResults;
         return getRecentlyClosed(maxResults, extension);
       },

       async forgetClosedTab(windowId, sessionId) {
         await SessionStore.promiseInitialized;
         let window = windowTracker.getWindow(windowId, context);
         let closedTabData = SessionStore.getClosedTabDataForWindow(window);
         let closedId = getClosedIdFromSessionId(sessionId);

         let closedTabIndex = closedTabData.findIndex(closedTab => {
           return closedTab.closedId === closedId;
         });

         if (closedTabIndex < 0) {
           throw new ExtensionError(
             `Could not find closed tab using sessionId ${sessionId}.`
           );
         }

         SessionStore.forgetClosedTab(window, closedTabIndex);
       },

       async forgetClosedWindow(sessionId) {
         await SessionStore.promiseInitialized;
         let closedWindowData = SessionStore.getClosedWindowData();
         let closedId = getClosedIdFromSessionId(sessionId);
         let closedWindowIndex = closedWindowData.findIndex(closedWindow => {
           return closedWindow.closedId === closedId;
         });

         if (closedWindowIndex < 0) {
           throw new ExtensionError(
             `Could not find closed window using sessionId ${sessionId}.`
           );
         }

         SessionStore.forgetClosedWindow(closedWindowIndex);
       },

       async restore(sessionId) {
         await SessionStore.promiseInitialized;
         let session;
         let closedId;
         if (sessionId) {
           closedId = getClosedIdFromSessionId(sessionId);
         }
         let targetWindow;

         // closedId is internally represented as an integer and could be 0.
         if (closedId !== undefined) {
           if (SessionStore.getObjectTypeForClosedId(closedId) == "tab") {
             // we want to restore the tab to the original window is was closed from
             targetWindow = SessionStore.getWindowForTabClosedId(
               closedId,
               extension.privateBrowsingAllowed
             );
           }
           session = SessionStore.undoCloseById(
             closedId,
             extension.privateBrowsingAllowed,
             targetWindow // ignored if we are restoring a window
           );
         } else if (SessionStore.lastClosedObjectType == "window") {
           // If the most recently closed object is a window, just undo closing the most recent window.
           session = SessionStore.undoCloseWindow(0);
         } else {
           // It is a tab, and we cannot call SessionStore.undoCloseTab without a window,
           // so we must find the tab in which case we can just use its closedId.
           let recentlyClosedTabs = [];
           for (let window of windowTracker.browserWindows()) {
             let closedTabData =
               SessionStore.getClosedTabDataForWindow(window);
             for (let tab of closedTabData) {
               recentlyClosedTabs.push(tab);
             }
           }

           if (recentlyClosedTabs.length) {
             // Sort the tabs.
             recentlyClosedTabs.sort((a, b) => b.closedAt - a.closedAt);

             // Use the closedId of the most recently closed tab to restore it.
             closedId = recentlyClosedTabs[0].closedId;
             // we want the tab to be re-opened into the same window it was closed from
             targetWindow = SessionStore.getWindowForTabClosedId(
               closedId,
               extension.privateBrowsingAllowed
             );
             session = SessionStore.undoCloseById(
               closedId,
               extension.privateBrowsingAllowed,
               targetWindow
             );
           }
         }
         return createSession(session, extension, closedId);
       },

       setTabValue(tabId, key, value) {
         let { tab, encodedKey } = getTabParams(key, tabId);

         SessionStore.setCustomTabValue(
           tab,
           encodedKey,
           JSON.stringify(value)
         );
       },

       async getTabValue(tabId, key) {
         let { tab, encodedKey } = getTabParams(key, tabId);

         let value = SessionStore.getCustomTabValue(tab, encodedKey);
         if (value) {
           return JSON.parse(value);
         }

         return undefined;
       },

       removeTabValue(tabId, key) {
         let { tab, encodedKey } = getTabParams(key, tabId);

         SessionStore.deleteCustomTabValue(tab, encodedKey);
       },

       setWindowValue(windowId, key, value) {
         let { win, encodedKey } = getWindowParams(key, windowId);

         SessionStore.setCustomWindowValue(
           win,
           encodedKey,
           JSON.stringify(value)
         );
       },

       async getWindowValue(windowId, key) {
         let { win, encodedKey } = getWindowParams(key, windowId);

         let value = SessionStore.getCustomWindowValue(win, encodedKey);
         if (value) {
           return JSON.parse(value);
         }

         return undefined;
       },

       removeWindowValue(windowId, key) {
         let { win, encodedKey } = getWindowParams(key, windowId);

         SessionStore.deleteCustomWindowValue(win, encodedKey);
       },

       onChanged: new EventManager({
         context,
         module: "sessions",
         event: "onChanged",
         extensionApi: this,
       }).api(),
     },
   };
 }
};