tor-browser

ext-url-overrides.js (7037B)

---

/* 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 { ExtensionParent } = ChromeUtils.importESModule(
 "resource://gre/modules/ExtensionParent.sys.mjs"
);

ChromeUtils.defineESModuleGetters(this, {
 AboutNewTab: "resource:///modules/AboutNewTab.sys.mjs",
 ExtensionControlledPopup:
   "resource:///modules/ExtensionControlledPopup.sys.mjs",
 ExtensionSettingsStore:
   "resource://gre/modules/ExtensionSettingsStore.sys.mjs",
});

const STORE_TYPE = "url_overrides";
const NEW_TAB_SETTING_NAME = "newTabURL";
const NEW_TAB_CONFIRMED_TYPE = "newTabNotification";
const NEW_TAB_PRIVATE_ALLOWED = "browser.newtab.privateAllowed";
const NEW_TAB_EXTENSION_CONTROLLED = "browser.newtab.extensionControlled";

ChromeUtils.defineLazyGetter(this, "newTabPopup", () => {
 return new ExtensionControlledPopup({
   confirmedType: NEW_TAB_CONFIRMED_TYPE,
   observerTopic: "browser-open-newtab-start",
   popupnotificationId: "extension-new-tab-notification",
   settingType: STORE_TYPE,
   settingKey: NEW_TAB_SETTING_NAME,
   descriptionId: "extension-new-tab-notification-description",
   descriptionMessageId: "newTabControlled.message2",
   learnMoreLink: "extension-home",
   preferencesLocation: "home-newtabOverride",
   preferencesEntrypoint: "addon-manage-newtab-override",
   onObserverAdded() {
     AboutNewTab.willNotifyUser = true;
   },
   onObserverRemoved() {
     AboutNewTab.willNotifyUser = false;
   },
   async beforeDisableAddon(popup, win) {
     // ExtensionControlledPopup will disable the add-on once this function completes.
     // Disabling an add-on should remove the tabs that it has open, but we want
     // to open the new New Tab in this tab (which might get closed).
     //   1. Replace the tab's URL with about:blank
     //   2. Return control to ExtensionControlledPopup once about:blank has loaded
     //   3. Once the New Tab URL has changed, replace the tab's URL with the new New Tab URL
     let gBrowser = win.gBrowser;
     let tab = gBrowser.selectedTab;
     await replaceUrlInTab(gBrowser, tab, Services.io.newURI("about:blank"));
     Services.obs.addObserver(
       {
         async observe() {
           await replaceUrlInTab(
             gBrowser,
             tab,
             Services.io.newURI(AboutNewTab.newTabURL)
           );
           // Now that the New Tab is loading, try to open the popup again. This
           // will only open the popup if a new extension is controlling the New Tab.
           popup.open();
           Services.obs.removeObserver(this, "newtab-url-changed");
         },
       },
       "newtab-url-changed"
     );
   },
 });
});

function setNewTabURL(extensionId, url) {
 if (extensionId) {
   newTabPopup.addObserver(extensionId);
   let policy = ExtensionParent.WebExtensionPolicy.getByID(extensionId);
   Services.prefs.setBoolPref(
     NEW_TAB_PRIVATE_ALLOWED,
     policy && policy.privateBrowsingAllowed
   );
   Services.prefs.setBoolPref(NEW_TAB_EXTENSION_CONTROLLED, true);
 } else {
   newTabPopup.removeObserver();
   Services.prefs.clearUserPref(NEW_TAB_PRIVATE_ALLOWED);
   Services.prefs.clearUserPref(NEW_TAB_EXTENSION_CONTROLLED);
 }
 if (url) {
   AboutNewTab.newTabURL = url;
 }
}

// eslint-disable-next-line mozilla/balanced-listeners
ExtensionParent.apiManager.on(
 "extension-setting-changed",
 async (eventName, setting) => {
   let extensionId, url;
   if (setting.type === STORE_TYPE && setting.key === NEW_TAB_SETTING_NAME) {
     // If the actual setting has changed in some way, we will have
     // setting.item which is what the setting has been changed to.  If
     // we have an item, we always want to update the newTabUrl values.
     let { item } = setting;
     if (item) {
       // If we're resetting, id will be undefined.
       extensionId = item.id;
       url = item.value || item.initialValue;
       setNewTabURL(extensionId, url);
     }
   }
 }
);

async function processSettings(action, id) {
 await ExtensionSettingsStore.initialize();
 if (ExtensionSettingsStore.hasSetting(id, STORE_TYPE, NEW_TAB_SETTING_NAME)) {
   ExtensionSettingsStore[action](id, STORE_TYPE, NEW_TAB_SETTING_NAME);
 }
}

this.urlOverrides = class extends ExtensionAPI {
 static async onDisable(id) {
   newTabPopup.clearConfirmation(id);
   await processSettings("disable", id);
 }

 static async onEnabling(id) {
   await processSettings("enable", id);
 }

 static async onUninstall(id) {
   // TODO: This can be removed once bug 1438364 is fixed and all data is cleaned up.
   newTabPopup.clearConfirmation(id);
   await processSettings("removeSetting", id);
 }

 static async onUpdate(id, manifest) {
   if (
     !manifest.chrome_url_overrides ||
     !manifest.chrome_url_overrides.newtab
   ) {
     await ExtensionSettingsStore.initialize();
     if (
       ExtensionSettingsStore.hasSetting(id, STORE_TYPE, NEW_TAB_SETTING_NAME)
     ) {
       ExtensionSettingsStore.removeSetting(
         id,
         STORE_TYPE,
         NEW_TAB_SETTING_NAME
       );
     }
   }
 }

 async onManifestEntry() {
   let { extension } = this;
   let { manifest } = extension;

   if (manifest.chrome_url_overrides.newtab) {
     let url = extension.baseURI.resolve(manifest.chrome_url_overrides.newtab);

     await ExtensionSettingsStore.initialize();
     let item = await ExtensionSettingsStore.addSetting(
       extension.id,
       STORE_TYPE,
       NEW_TAB_SETTING_NAME,
       url,
       () => AboutNewTab.newTabURL
     );

     // Set the newTabURL to the current value of the setting.
     if (item) {
       setNewTabURL(item.id, item.value || item.initialValue);
     }

     // We need to monitor permission change and update the preferences.
     // eslint-disable-next-line mozilla/balanced-listeners
     extension.on("add-permissions", async (ignoreEvent, permissions) => {
       if (
         permissions.permissions.includes("internal:privateBrowsingAllowed")
       ) {
         let item = await ExtensionSettingsStore.getSetting(
           STORE_TYPE,
           NEW_TAB_SETTING_NAME
         );
         if (item && item.id == extension.id) {
           Services.prefs.setBoolPref(NEW_TAB_PRIVATE_ALLOWED, true);
         }
       }
     });
     // eslint-disable-next-line mozilla/balanced-listeners
     extension.on("remove-permissions", async (ignoreEvent, permissions) => {
       if (
         permissions.permissions.includes("internal:privateBrowsingAllowed")
       ) {
         let item = await ExtensionSettingsStore.getSetting(
           STORE_TYPE,
           NEW_TAB_SETTING_NAME
         );
         if (item && item.id == extension.id) {
           Services.prefs.setBoolPref(NEW_TAB_PRIVATE_ALLOWED, false);
         }
       }
     });
   }
 }
};