Bug 1853013 - Merge in scripting API and es module webcompat addon updates; r=denschub,webcompat-reviewers

Differential Revision: https://phabricator.services.mozilla.com/D188119

browser/extensions/webcompat/about-compat/AboutCompat.sys.mjs

@@ -2,21 +2,14 @@
  * 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 EXPORTED_SYMBOLS = ["AboutCompat"];
-
-const Services =
-  globalThis.Services ||
-  ChromeUtils.import("resource://gre/modules/Services.jsm").Services;
-
 const addonID = "webcompat@mozilla.org";
 const addonPageRelativeURL = "/about-compat/aboutCompat.html";
 
-function AboutCompat() {
+export function AboutCompat() {
   this.chromeURL =
     WebExtensionPolicy.getByID(addonID).getURL(addonPageRelativeURL);
 }
+
 AboutCompat.prototype = {
   QueryInterface: ChromeUtils.generateQI(["nsIAboutModule"]),
   getURIFlags() {

browser/extensions/webcompat/about-compat/aboutPage.js

@@ -4,11 +4,7 @@
 
 "use strict";
 
-/* global ExtensionAPI, XPCOMUtils */
-
-const Services =
-  globalThis.Services ||
-  ChromeUtils.import("resource://gre/modules/Services.jsm").Services;
+/* global ExtensionAPI, XPCOMUtils, Services */
 
 XPCOMUtils.defineLazyServiceGetter(
   this,

browser/extensions/webcompat/about-compat/aboutPageProcessScript.js

@@ -19,8 +19,8 @@ if (!Cm.isCIDRegistered(classID)) {
   );
 
   const factory = ComponentUtils.generateSingletonFactory(function () {
-    const { AboutCompat } = ChromeUtils.import(
-      "resource://webcompat/AboutCompat.jsm"
+    const { AboutCompat } = ChromeUtils.importESModule(
+      "resource://webcompat/AboutCompat.sys.mjs"
     );
     return new AboutCompat();
   });

browser/extensions/webcompat/components.conf

@@ -11,7 +11,7 @@ Classes = [
     {
         'cid': '{97bf9550-2a7b-11e9-b56e-0800200c9a66}',
         'contract_ids': ['@mozilla.org/network/protocol/about;1?what=compat'],
-        'jsm': 'resource://webcompat/AboutCompat.jsm',
+        'esModule': 'resource://webcompat/AboutCompat.sys.mjs',
         'constructor': 'AboutCompat',
     },
 ]

browser/extensions/webcompat/data/shims.js

@@ -589,7 +589,6 @@ const AVAILABLE_SHIMS = [
     ],
     contentScripts: [
       {
-        cookieStoreId: "firefox-private",
         js: "firebase.js",
         runAt: "document_start",
         matches: [

browser/extensions/webcompat/data/ua_overrides.js

@@ -486,7 +486,7 @@ const AVAILABLE_UA_OVERRIDES = [
     domain: "granbluefantasy.jp",
     bug: "1722954",
     config: {
-      matches: ["*://*.granbluefantasy.jp/*"],
+      matches: ["*://*.granbluefantasy.jp/*", "*://*.gbf.game.mbga.jp/*"],
       uaTransformer: originalUA => {
         return originalUA + " iPhone OS 12_0 like Mac OS X";
       },

browser/extensions/webcompat/lib/injections.js

@@ -13,7 +13,7 @@ class Injections {
     this._injectionsEnabled = true;
 
     this._availableInjections = availableInjections;
-    this._activeInjections = new Map();
+    this._activeInjections = new Set();
     this._customFunctions = customFunctions;
   }
 
@@ -48,6 +48,33 @@ class Injections {
     return this._injectionsEnabled;
   }
 
+  async getPromiseRegisteredScriptIds(scriptIds) {
+    let registeredScriptIds = [];
+
+    // Try to avoid re-registering scripts already registered
+    // (e.g. if the webcompat background page is restarted
+    // after an extension process crash, after having registered
+    // the content scripts already once), but do not prevent
+    // to try registering them again if the getRegisteredContentScripts
+    // method returns an unexpected rejection.
+    try {
+      const registeredScripts =
+        await browser.scripting.getRegisteredContentScripts({
+          // By default only look for script ids that belongs to Injections
+          // (and ignore the ones that may belong to Shims).
+          ids: scriptIds ?? this._availableInjections.map(inj => inj.id),
+        });
+      registeredScriptIds = registeredScripts.map(script => script.id);
+    } catch (ex) {
+      console.error(
+        "Retrieve WebCompat GoFaster registered content scripts failed: ",
+        ex
+      );
+    }
+
+    return registeredScriptIds;
+  }
+
   async registerContentScripts() {
     const platformInfo = await browser.runtime.getPlatformInfo();
     const platformMatches = [
@@ -55,10 +82,13 @@ class Injections {
       platformInfo.os,
       platformInfo.os == "android" ? "android" : "desktop",
     ];
+
+    let registeredScriptIds = await this.getPromiseRegisteredScriptIds();
+
     for (const injection of this._availableInjections) {
       if (platformMatches.includes(injection.platform)) {
         injection.availableOnPlatform = true;
-        await this.enableInjection(injection);
+        await this.enableInjection(injection, registeredScriptIds);
       }
     }
 
@@ -70,17 +100,39 @@ class Injections {
     });
   }
 
-  assignContentScriptDefaults(contentScripts) {
+  buildContentScriptRegistrations(contentScripts) {
     let finalConfig = Object.assign({}, contentScripts);
 
+    // Don't persist the content scripts across browser restarts
+    // (at least not yet, we would need to apply some more changes
+    // to adjust webcompat for accounting for the scripts to be
+    // already registered).
+    //
+    // NOTE: scripting API has been introduced in Gecko 102,
+    // prior to Gecko 105 persistAcrossSessions option was required
+    // and only accepted false persistAcrossSessions, after Gecko 105
+    // is optional and defaults to true.
+    finalConfig.persistAcrossSessions = false;
+
     if (!finalConfig.runAt) {
       finalConfig.runAt = "document_start";
     }
 
+    // Convert js/css from contentScripts.register API method
+    // format to scripting.registerContentScripts API method
+    // format.
+    if (Array.isArray(finalConfig.js)) {
+      finalConfig.js = finalConfig.js.map(e => e.file);
+    }
+
+    if (Array.isArray(finalConfig.css)) {
+      finalConfig.css = finalConfig.css.map(e => e.file);
+    }
+
     return finalConfig;
   }
 
-  async enableInjection(injection) {
+  async enableInjection(injection, registeredScriptIds) {
     if (injection.active) {
       return undefined;
     }
@@ -89,7 +141,7 @@ class Injections {
       return this.enableCustomInjection(injection);
     }
 
-    return this.enableContentScripts(injection);
+    return this.enableContentScripts(injection, registeredScriptIds);
   }
 
   enableCustomInjection(injection) {
@@ -103,16 +155,31 @@ class Injections {
     }
   }
 
-  async enableContentScripts(injection) {
+  async enableContentScripts(injection, registeredScriptIds) {
+    let injectProps;
     try {
-      const handle = await browser.contentScripts.register(
-        this.assignContentScriptDefaults(injection.contentScripts)
+      const { id } = injection;
+      // enableContentScripts receives a registeredScriptIds already
+      // pre-computed once from registerContentScripts to register all
+      // the injection, whereas it does not expect to receive one when
+      // it is called from the AboutCompatBroker to re-enable one specific
+      // injection.
+      let activeScriptIds = Array.isArray(registeredScriptIds)
+        ? registeredScriptIds
+        : await this.getPromiseRegisteredScriptIds([id]);
+      injectProps = this.buildContentScriptRegistrations(
+        injection.contentScripts
       );
-      this._activeInjections.set(injection, handle);
+      injectProps.id = id;
+      if (!activeScriptIds.includes(id)) {
+        await browser.scripting.registerContentScripts([injectProps]);
+      }
+      this._activeInjections.add(id);
       injection.active = true;
     } catch (ex) {
       console.error(
         "Registering WebCompat GoFaster content scripts failed: ",
+        { injection, injectProps },
         ex
       );
     }
@@ -155,9 +222,10 @@ class Injections {
   }
 
   async disableContentScripts(injection) {
-    const contentScript = this._activeInjections.get(injection);
-    await contentScript.unregister();
+    if (this._activeInjections.has(injection.id)) {
+      await browser.scripting.unregisterContentScripts({ ids: [injection.id] });
       this._activeInjections.delete(injection);
+    }
     injection.active = false;
   }
 }

browser/extensions/webcompat/lib/shims.js

@@ -80,10 +80,10 @@ class Shim {
     this.contentScripts = contentScripts || [];
     for (const script of this.contentScripts) {
       if (typeof script.css === "string") {
-        script.css = [{ file: `/shims/${script.css}` }];
+        script.css = [`/shims/${script.css}`];
       }
       if (typeof script.js === "string") {
-        script.js = [{ file: `/shims/${script.js}` }];
+        script.js = [`/shims/${script.js}`];
       }
     }
 
@@ -244,10 +244,47 @@ class Shim {
       !this._contentScriptRegistrations.length
     ) {
       const matches = [];
+      let idx = 0;
       for (const options of this.contentScripts) {
         matches.push(options.matches);
-        const reg = await browser.contentScripts.register(options);
-        this._contentScriptRegistrations.push(reg);
+        // Some shims includes more than one script (e.g. Blogger one contains
+        // a content script to be run on document_start and one to be run
+        // on document_end.
+        options.id = `shim-${this.id}-${idx++}`;
+        options.persistAcrossSessions = false;
+        // Having to call getRegisteredContentScripts each time we are going to
+        // register a Shim content script is suboptimal, but avoiding that
+        // may require a bit more changes (e.g. rework both Injections, Shim and Shims
+        // classes to more easily register all content scripts with a single
+        // call to the scripting API methods when the background script page is loading
+        // and one per injection or shim being enabled from the AboutCompatBroker).
+        // In the short term we call getRegisteredContentScripts and restrict it to
+        // the script id we are about to register.
+        let isAlreadyRegistered = false;
+        try {
+          const registeredScripts =
+            await browser.scripting.getRegisteredContentScripts({
+              ids: [options.id],
+            });
+          isAlreadyRegistered = !!registeredScripts.length;
+        } catch (ex) {
+          console.error(
+            "Retrieve WebCompat GoFaster registered content scripts failed: ",
+            ex
+          );
+        }
+        try {
+          if (!isAlreadyRegistered) {
+            await browser.scripting.registerContentScripts([options]);
+          }
+          this._contentScriptRegistrations.push(options.id);
+        } catch (ex) {
+          console.error(
+            "Registering WebCompat Shim content scripts failed: ",
+            options,
+            ex
+          );
+        }
       }
       const urls = Array.from(new Set(matches.flat()));
       debug("Enabling content scripts for these URLs:", urls);
@@ -255,9 +292,8 @@ class Shim {
   }
 
   async _unregisterContentScripts() {
-    for (const registration of this._contentScriptRegistrations) {
-      registration.unregister();
-    }
+    const ids = this._contentScriptRegistrations;
+    await browser.scripting.unregisterContentScripts({ ids });
     this._contentScriptRegistrations = [];
   }
 

browser/extensions/webcompat/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 2,
   "name": "Web Compatibility Interventions",
   "description": "Urgent post-release fixes for web compatibility.",
-  "version": "118.1.0",
+  "version": "118.2.0",
   "browser_specific_settings": {
     "gecko": {
       "id": "webcompat@mozilla.org",
@@ -65,6 +65,7 @@
 
   "permissions": [
     "mozillaAddons",
+    "scripting",
     "tabs",
     "webNavigation",
     "webRequest",

browser/extensions/webcompat/moz.build

@@ -16,7 +16,7 @@ FINAL_TARGET_FILES.features["webcompat@mozilla.org"]["about-compat"] += [
     "about-compat/aboutCompat.css",
     "about-compat/aboutCompat.html",
     "about-compat/aboutCompat.js",
-    "about-compat/AboutCompat.jsm",
+    "about-compat/AboutCompat.sys.mjs",
     "about-compat/aboutPage.js",
     "about-compat/aboutPage.json",
     "about-compat/aboutPageProcessScript.js",