tor-browser

Marionette.sys.mjs (9552B)

---

/* 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/. */

const lazy = {};

ChromeUtils.defineESModuleGetters(lazy, {
 Deferred: "chrome://remote/content/shared/Sync.sys.mjs",
 EnvironmentPrefs: "chrome://remote/content/marionette/prefs.sys.mjs",
 Log: "chrome://remote/content/shared/Log.sys.mjs",
 MarionettePrefs: "chrome://remote/content/marionette/prefs.sys.mjs",
 RecommendedPreferences:
   "chrome://remote/content/shared/RecommendedPreferences.sys.mjs",
 TCPListener: "chrome://remote/content/marionette/server.sys.mjs",
});

ChromeUtils.defineLazyGetter(lazy, "logger", () =>
 lazy.Log.get(lazy.Log.TYPES.MARIONETTE)
);

ChromeUtils.defineLazyGetter(lazy, "textEncoder", () => new TextEncoder());

const NOTIFY_LISTENING = "marionette-listening";
const SHARED_DATA_ACTIVE_KEY = "Marionette:Active";

// Complements -marionette flag for starting the Marionette server.
// We also set this if Marionette is running in order to start the server
// again after a Firefox restart.
const ENV_ENABLED = "MOZ_MARIONETTE";

// Besides starting based on existing prefs in a profile and a command
// line flag, we also support inheriting prefs out of an env var, and to
// start Marionette that way.
//
// This allows marionette prefs to persist when we do a restart into
// a different profile in order to test things like Firefox refresh.
// The environment variable itself, if present, is interpreted as a
// JSON structure, with the keys mapping to preference names in the
// "marionette." branch, and the values to the values of those prefs. So
// something like {"port": 4444} would result in the marionette.port
// pref being set to 4444.
const ENV_PRESERVE_PREFS = "MOZ_MARIONETTE_PREF_STATE_ACROSS_RESTARTS";

const isRemote =
 Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT;

class MarionetteParentProcess {
 #browserStartupFinished;

 constructor() {
   this.server = null;
   this._activePortPath;

   // Initially set the enabled state based on the environment variable.
   this.enabled = Services.env.exists(ENV_ENABLED);

   this.#browserStartupFinished = lazy.Deferred();
 }

 /**
  * A promise that resolves when the initial application window has been opened.
  *
  * @returns {Promise}
  *     Promise that resolves when the initial application window is open.
  */
 get browserStartupFinished() {
   return this.#browserStartupFinished.promise;
 }

 get enabled() {
   return this._enabled;
 }

 set enabled(value) {
   // Return early if Marionette is already marked as being enabled.
   // There is also no possibility to disable Marionette once it got enabled.
   if (this._enabled || !value) {
     return;
   }

   this._enabled = value;
   lazy.logger.info(`Marionette enabled`);
 }

 get running() {
   return !!this.server && this.server.alive;
 }

 /**
  * Syncs the Marionette active flag with the web content processes.
  *
  * @param {boolean} value - Flag indicating if Marionette is active or not.
  */
 updateWebdriverActiveFlag(value) {
   Services.ppmm.sharedData.set(SHARED_DATA_ACTIVE_KEY, value);
   Services.ppmm.sharedData.flush();
 }

 handle(cmdLine) {
   // `handle` is called too late in certain cases (eg safe mode, see comment
   // above "command-line-startup"). So the marionette command line argument
   // will always be processed in `observe`.
   // However it still needs to be consumed by the command-line-handler API,
   // to avoid issues on macos.
   // TODO: remove after Bug 1724251 is fixed.
   cmdLine.handleFlag("marionette", false);
 }

 async observe(subject, topic) {
   if (this.enabled) {
     lazy.logger.trace(`Received observer notification ${topic}`);
   }

   switch (topic) {
     case "profile-after-change":
       Services.obs.addObserver(this, "command-line-startup");
       break;

     // In safe mode the command line handlers are getting parsed after the
     // safe mode dialog has been closed. To allow Marionette to start
     // earlier, use the CLI startup observer notification for
     // special-cased handlers, which gets fired before the dialog appears.
     case "command-line-startup":
       Services.obs.removeObserver(this, topic);

       this.enabled = subject.handleFlag("marionette", false);

       if (this.enabled) {
         // Add annotation to crash report to indicate whether
         // Marionette was active.
         Services.appinfo.annotateCrashReport("Marionette", true);

         // Marionette needs to be initialized before any window is shown.
         Services.obs.addObserver(this, "final-ui-startup");

         // We want to suppress the modal dialog that's shown
         // when starting up in safe-mode to enable testing.
         if (Services.appinfo.inSafeMode) {
           Services.obs.addObserver(this, "domwindowopened");
         }

         lazy.RecommendedPreferences.applyPreferences();

         // Only set preferences to preserve in a new profile
         // when Marionette is enabled.
         for (let [pref, value] of lazy.EnvironmentPrefs.from(
           ENV_PRESERVE_PREFS
         )) {
           switch (typeof value) {
             case "string":
               Services.prefs.setStringPref(pref, value);
               break;
             case "boolean":
               Services.prefs.setBoolPref(pref, value);
               break;
             case "number":
               Services.prefs.setIntPref(pref, value);
               break;
             default:
               throw new TypeError(`Invalid preference type: ${typeof value}`);
           }
         }
       }
       break;

     case "domwindowopened":
       Services.obs.removeObserver(this, topic);
       this.suppressSafeModeDialog(subject);
       break;

     case "final-ui-startup":
       Services.obs.removeObserver(this, topic);

       Services.obs.addObserver(this, "browser-idle-startup-tasks-finished");
       Services.obs.addObserver(this, "mail-idle-startup-tasks-finished");
       Services.obs.addObserver(this, "quit-application");

       await this.init();
       break;

     // Used to wait until the initial application window has been opened.
     case "browser-idle-startup-tasks-finished":
     case "mail-idle-startup-tasks-finished":
       Services.obs.removeObserver(
         this,
         "browser-idle-startup-tasks-finished"
       );
       Services.obs.removeObserver(this, "mail-idle-startup-tasks-finished");
       this.#browserStartupFinished.resolve();
       break;

     case "quit-application":
       Services.obs.removeObserver(this, topic);
       await this.uninit();
       break;
   }
 }

 suppressSafeModeDialog(win) {
   win.addEventListener(
     "load",
     () => {
       let dialog = win.document.getElementById("safeModeDialog");
       if (dialog) {
         // accept the dialog to start in safe-mode
         lazy.logger.trace("Safe mode detected, suppressing dialog");
         win.setTimeout(() => {
           dialog.getButton("accept").click();
         });
       }
     },
     { once: true }
   );
 }

 async init() {
   if (!this.enabled || this.running) {
     lazy.logger.debug(
       `Init aborted (enabled=${this.enabled}, running=${this.running})`
     );
     return;
   }

   try {
     this.server = new lazy.TCPListener(lazy.MarionettePrefs.port);
     await this.server.start();
   } catch (e) {
     lazy.logger.fatal("Marionette server failed to start", e);
     Services.startup.quit(Ci.nsIAppStartup.eForceQuit);
     return;
   }

   this.updateWebdriverActiveFlag(true);

   Services.env.set(ENV_ENABLED, "1");
   Services.obs.notifyObservers(this, NOTIFY_LISTENING, true);
   lazy.logger.debug("Marionette is listening");

   // Write Marionette port to MarionetteActivePort file within the profile.
   this._activePortPath = PathUtils.join(
     PathUtils.profileDir,
     "MarionetteActivePort"
   );

   const data = `${this.server.port}`;
   try {
     await IOUtils.write(this._activePortPath, lazy.textEncoder.encode(data));
   } catch (e) {
     lazy.logger.warn(
       `Failed to create ${this._activePortPath} (${e.message})`
     );
   }
 }

 async uninit() {
   if (this.running) {
     await this.server.stop();
     this.updateWebdriverActiveFlag(false);

     Services.obs.notifyObservers(this, NOTIFY_LISTENING);

     try {
       await IOUtils.remove(this._activePortPath);
     } catch (e) {
       lazy.logger.warn(
         `Failed to remove ${this._activePortPath} (${e.message})`
       );
     }

     lazy.logger.debug("Marionette stopped listening");
   }
 }

 // XPCOM

 helpInfo = "  --marionette       Enable remote control server.\n";

 QueryInterface = ChromeUtils.generateQI([
   "nsICommandLineHandler",
   "nsIMarionette",
   "nsIObserver",
 ]);
}

class MarionetteContentProcess {
 get running() {
   return Services.cpmm.sharedData.get(SHARED_DATA_ACTIVE_KEY) ?? false;
 }

 // XPCOM

 QueryInterface = ChromeUtils.generateQI(["nsIMarionette"]);
}

export var Marionette;
if (isRemote) {
 Marionette = new MarionetteContentProcess();
} else {
 Marionette = new MarionetteParentProcess();
}

// This is used by the XPCOM codepath which expects a constructor
export const MarionetteFactory = function () {
 return Marionette;
};