From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- testing/marionette/components/marionette.js | 237 ++++++++++++++++++++++ testing/marionette/components/marionette.manifest | 4 + testing/marionette/components/moz.build | 9 + 3 files changed, 250 insertions(+) create mode 100644 testing/marionette/components/marionette.js create mode 100644 testing/marionette/components/marionette.manifest create mode 100644 testing/marionette/components/moz.build (limited to 'testing/marionette/components') diff --git a/testing/marionette/components/marionette.js b/testing/marionette/components/marionette.js new file mode 100644 index 000000000..252252823 --- /dev/null +++ b/testing/marionette/components/marionette.js @@ -0,0 +1,237 @@ +/* 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"; + +const {Constructor: CC, interfaces: Ci, utils: Cu, classes: Cc} = Components; + +const MARIONETTE_CONTRACTID = "@mozilla.org/marionette;1"; +const MARIONETTE_CID = Components.ID("{786a1369-dca5-4adc-8486-33d23c88010a}"); + +const DEFAULT_PORT = 2828; +const ENABLED_PREF = "marionette.defaultPrefs.enabled"; +const PORT_PREF = "marionette.defaultPrefs.port"; +const FORCELOCAL_PREF = "marionette.force-local"; +const LOG_PREF = "marionette.logging"; + +/** + * Besides starting based on existing prefs in a profile and a commandline 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 env var 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 {"defaultPrefs.enabled": true} + * in the env var would result in the marionette.defaultPrefs.enabled pref being + * set to true, thus triggering marionette being enabled for that startup. + */ +const ENV_PREF_VAR = "MOZ_MARIONETTE_PREF_STATE_ACROSS_RESTARTS"; + +const ServerSocket = CC("@mozilla.org/network/server-socket;1", + "nsIServerSocket", + "initSpecialConnection"); + +Cu.import("resource://gre/modules/Log.jsm"); +Cu.import("resource://gre/modules/Preferences.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +function MarionetteComponent() { + this.loaded_ = false; + this.observerService = Services.obs; + this.logger = this.setupLogger_(this.determineLoggingLevel_()); +} + +MarionetteComponent.prototype = { + classDescription: "Marionette component", + classID: MARIONETTE_CID, + contractID: MARIONETTE_CONTRACTID, + QueryInterface: XPCOMUtils.generateQI([Ci.nsICommandLineHandler, Ci.nsIObserver]), + _xpcom_categories: [ + {category: "command-line-handler", entry: "b-marionette"}, + {category: "profile-after-change", service: true} + ], + enabled: false, + finalUiStartup: false, + server: null, +}; + +MarionetteComponent.prototype.setupLogger_ = function (level) { + let log = Log.repository.getLogger("Marionette"); + log.level = level; + log.addAppender(new Log.DumpAppender()); + return log; +}; + +MarionetteComponent.prototype.determineLoggingLevel_ = function() { + let level = Log.Level.Info; + + // marionette.logging pref can override default + // with an entry from the Log.Level enum + if (Preferences.has(LOG_PREF)) { + let p = Preferences.get(LOG_PREF); + + switch (typeof p) { + // Gecko >= 46 + case "string": + let s = p.toLowerCase(); + s = s.charAt(0).toUpperCase() + s.slice(1); + level = Log.Level[s]; + break; + + // Gecko <= 45 + case "boolean": + if (p) { + level = Log.Level.Trace; + } + break; + } + } + + return level; +}; + +MarionetteComponent.prototype.onSocketAccepted = function( + socket, transport) { + this.logger.info("onSocketAccepted for Marionette dummy socket"); +}; + +MarionetteComponent.prototype.onStopListening = function (socket, status) { + this.logger.info(`onStopListening for Marionette dummy socket, code ${status}`); + socket.close(); +}; + +/** Check cmdLine argument for {@code --marionette}. */ +MarionetteComponent.prototype.handle = function (cmdLine) { + // if the CLI is there then lets do work otherwise nothing to see + if (cmdLine.handleFlag("marionette", false)) { + this.enabled = true; + this.logger.debug("Marionette enabled via command-line flag"); + this.init(); + } +}; + +MarionetteComponent.prototype.observe = function (subj, topic, data) { + switch (topic) { + case "profile-after-change": + this.maybeReadPrefsFromEnvironment(); + // Using final-ui-startup as the xpcom category doesn't seem to work, + // so we wait for that by adding an observer here. + this.observerService.addObserver(this, "final-ui-startup", false); +#ifdef ENABLE_MARIONETTE + this.enabled = Preferences.get(ENABLED_PREF, false); + if (this.enabled) { + this.logger.debug("Marionette enabled via build flag and pref"); + + // We want to suppress the modal dialog that's shown + // when starting up in safe-mode to enable testing. + if (Services.appinfo.inSafeMode) { + this.observerService.addObserver(this, "domwindowopened", false); + } + } +#endif + break; + + case "final-ui-startup": + this.finalUiStartup = true; + this.observerService.removeObserver(this, topic); + this.observerService.addObserver(this, "xpcom-shutdown", false); + this.init(); + break; + + case "domwindowopened": + this.observerService.removeObserver(this, topic); + this.suppressSafeModeDialog_(subj); + break; + + case "xpcom-shutdown": + this.observerService.removeObserver(this, "xpcom-shutdown"); + this.uninit(); + break; + } +}; + +MarionetteComponent.prototype.maybeReadPrefsFromEnvironment = function() { + let env = Cc["@mozilla.org/process/environment;1"].getService(Ci.nsIEnvironment); + if (env.exists(ENV_PREF_VAR)) { + let prefStr = env.get(ENV_PREF_VAR); + let prefs; + try { + prefs = JSON.parse(prefStr); + } catch (ex) { + Cu.reportError("Invalid marionette prefs in environment; prefs won't have been applied."); + Cu.reportError(ex); + } + if (prefs) { + for (let prefName of Object.keys(prefs)) { + Preferences.set("marionette." + prefName, prefs[prefName]); + } + } + } +} + +MarionetteComponent.prototype.suppressSafeModeDialog_ = function (win) { + // Wait for the modal dialog to finish loading. + win.addEventListener("load", function onload() { + win.removeEventListener("load", onload); + + if (win.document.getElementById("safeModeDialog")) { + // Accept the dialog to start in safe-mode + win.setTimeout(() => { + win.document.documentElement.getButton("accept").click(); + }); + } + }); +}; + +MarionetteComponent.prototype.init = function() { + if (this.loaded_ || !this.enabled || !this.finalUiStartup) { + return; + } + + this.loaded_ = true; + + let forceLocal = Preferences.get(FORCELOCAL_PREF, + Services.appinfo.name == "B2G" ? false : true); + Preferences.set(FORCELOCAL_PREF, forceLocal); + + if (!forceLocal) { + // See bug 800138. Because the first socket that opens with + // force-local=false fails, we open a dummy socket that will fail. + // keepWhenOffline=true so that it still work when offline (local). + // This allows the following attempt by Marionette to open a socket + // to succeed. + let insaneSacrificialGoat = + new ServerSocket(666, Ci.nsIServerSocket.KeepWhenOffline, 4); + insaneSacrificialGoat.asyncListen(this); + } + + let port = Preferences.get(PORT_PREF, DEFAULT_PORT); + + let s; + try { + Cu.import("chrome://marionette/content/server.js"); + s = new MarionetteServer(port, forceLocal); + s.start(); + this.logger.info(`Listening on port ${s.port}`); + } catch (e) { + this.logger.error(`Error on starting server: ${e}`); + dump(e.toString() + "\n" + e.stack + "\n"); + } finally { + if (s) { + this.server = s; + } + } +}; + +MarionetteComponent.prototype.uninit = function() { + if (!this.loaded_) { + return; + } + this.server.stop(); + this.loaded_ = false; +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([MarionetteComponent]); diff --git a/testing/marionette/components/marionette.manifest b/testing/marionette/components/marionette.manifest new file mode 100644 index 000000000..ebe904960 --- /dev/null +++ b/testing/marionette/components/marionette.manifest @@ -0,0 +1,4 @@ +component {786a1369-dca5-4adc-8486-33d23c88010a} marionette.js +contract @mozilla.org/marionette;1 {786a1369-dca5-4adc-8486-33d23c88010a} +category command-line-handler b-marionette @mozilla.org/marionette;1 +category profile-after-change Marionette @mozilla.org/marionette;1 diff --git a/testing/marionette/components/moz.build b/testing/marionette/components/moz.build new file mode 100644 index 000000000..7fc4113a5 --- /dev/null +++ b/testing/marionette/components/moz.build @@ -0,0 +1,9 @@ +# 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/. + +EXTRA_COMPONENTS += ["marionette.manifest"] +EXTRA_PP_COMPONENTS += ["marionette.js"] + +if CONFIG["ENABLE_MARIONETTE"]: + DEFINES["ENABLE_MARIONETTE"] = 1 -- cgit v1.2.3