The Tor Browser: comparison browser/devtools/framework/ToolboxProcess.jsm

--1:000000000000
+:e70699ec94d9
+/* -*- Mode: javascript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ft=javascript ts=2 et sw=2 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";
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
+const DBG_XUL = "chrome://browser/content/devtools/framework/toolbox-process-window.xul";
+const CHROME_DEBUGGER_PROFILE_NAME = "-chrome-debugger";
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource:///modules/devtools/ViewHelpers.jsm");
+Cu.import("resource://gre/modules/devtools/Loader.jsm");
+let require = devtools.require;
+let Telemetry = require("devtools/shared/telemetry");
+let EventEmitter = require("devtools/toolkit/event-emitter");
+const { Promise: promise } = Cu.import("resource://gre/modules/Promise.jsm", {});
+this.EXPORTED_SYMBOLS = ["BrowserToolboxProcess"];
+let processes = Set();
+/**
+* Constructor for creating a process that will hold a chrome toolbox.
+*
+* @param function aOnClose [optional]
+*        A function called when the process stops running.
+* @param function aOnRun [optional]
+*        A function called when the process starts running.
+* @param object aOptions [optional]
+*        An object with properties for configuring BrowserToolboxProcess.
+*/
+this.BrowserToolboxProcess = function BrowserToolboxProcess(aOnClose, aOnRun, aOptions) {
+let emitter = new EventEmitter();
+this.on = emitter.on.bind(emitter);
+this.off = emitter.off.bind(emitter);
+this.once = emitter.once.bind(emitter);
+// Forward any events to the shared emitter.
+this.emit = function(...args) {
+emitter.emit(...args);
+BrowserToolboxProcess.emit(...args);
+}
+// If first argument is an object, use those properties instead of
+// all three arguments
+if (typeof aOnClose === "object") {
+if (aOnClose.onClose) {
+this.on("close", aOnClose.onClose);
+}
+if (aOnClose.onRun) {
+this.on("run", aOnClose.onRun);
+}
+this._options = aOnClose;
+} else {
+if (aOnClose) {
+this.on("close", aOnClose);
+}
+if (aOnRun) {
+this.on("run", aOnRun);
+}
+this._options = aOptions || {};
+}
+this._telemetry = new Telemetry();
+this.close = this.close.bind(this);
+Services.obs.addObserver(this.close, "quit-application", false);
+this._initServer();
+this._initProfile();
+this._create();
+processes.add(this);
+};
+EventEmitter.decorate(BrowserToolboxProcess);
+/**
+* Initializes and starts a chrome toolbox process.
+* @return object
+*/
+BrowserToolboxProcess.init = function(aOnClose, aOnRun, aOptions) {
+return new BrowserToolboxProcess(aOnClose, aOnRun, aOptions);
+};
+/**
+* Passes a set of options to the BrowserAddonActors for the given ID.
+*
+* @param aId string
+*        The ID of the add-on to pass the options to
+* @param aOptions object
+*        The options.
+* @return a promise that will be resolved when complete.
+*/
+BrowserToolboxProcess.setAddonOptions = function DSC_setAddonOptions(aId, aOptions) {
+let promises = [];
+for (let process of processes.values()) {
+promises.push(process.debuggerServer.setAddonOptions(aId, aOptions));
+}
+return promise.all(promises);
+};
+BrowserToolboxProcess.prototype = {
+/**
+* Initializes the debugger server.
+*/
+_initServer: function() {
+dumpn("Initializing the chrome toolbox server.");
+if (!this.loader) {
+// Create a separate loader instance, so that we can be sure to receive a
+// separate instance of the DebuggingServer from the rest of the devtools.
+// This allows us to safely use the tools against even the actors and
+// DebuggingServer itself, especially since we can mark this loader as
+// invisible to the debugger (unlike the usual loader settings).
+this.loader = new DevToolsLoader();
+this.loader.invisibleToDebugger = true;
+this.loader.main("devtools/server/main");
+this.debuggerServer = this.loader.DebuggerServer;
+dumpn("Created a separate loader instance for the DebuggerServer.");
+// Forward interesting events.
+this.debuggerServer.on("connectionchange", this.emit.bind(this));
+}
+if (!this.debuggerServer.initialized) {
+this.debuggerServer.init();
+this.debuggerServer.addBrowserActors();
+dumpn("initialized and added the browser actors for the DebuggerServer.");
+}
+this.debuggerServer.openListener(Prefs.chromeDebuggingPort);
+dumpn("Finished initializing the chrome toolbox server.");
+dumpn("Started listening on port: " + Prefs.chromeDebuggingPort);
+},
+/**
+* Initializes a profile for the remote debugger process.
+*/
+_initProfile: function() {
+dumpn("Initializing the chrome toolbox user profile.");
+let profileService = Cc["@mozilla.org/toolkit/profile-service;1"]
+.createInstance(Ci.nsIToolkitProfileService);
+let profileName;
+try {
+// Attempt to get the required chrome debugging profile name string.
+profileName = profileService.selectedProfile.name + CHROME_DEBUGGER_PROFILE_NAME;
+dumpn("Using chrome toolbox profile name: " + profileName);
+} catch (e) {
+// Requested profile string could not be retrieved.
+profileName = CHROME_DEBUGGER_PROFILE_NAME;
+let msg = "Querying the current profile failed. " + e.name + ": " + e.message;
+dumpn(msg);
+Cu.reportError(msg);
+}
+let profileObject;
+try {
+// Attempt to get the required chrome debugging profile toolkit object.
+profileObject = profileService.getProfileByName(profileName);
+dumpn("Using chrome toolbox profile object: " + profileObject);
+// The profile exists but the corresponding folder may have been deleted.
+var enumerator = Services.dirsvc.get("ProfD", Ci.nsIFile).parent.directoryEntries;
+while (enumerator.hasMoreElements()) {
+let profileDir = enumerator.getNext().QueryInterface(Ci.nsIFile);
+if (profileDir.leafName.contains(profileName)) {
+// Requested profile was found and the folder exists.
+this._dbgProfile = profileObject;
+return;
+}
+}
+// Requested profile was found but the folder was deleted. Cleanup needed.
+profileObject.remove(true);
+dumpn("The already existing chrome toolbox profile was invalid.");
+} catch (e) {
+// Requested profile object was not found.
+let msg = "Creating a profile failed. " + e.name + ": " + e.message;
+dumpn(msg);
+Cu.reportError(msg);
+}
+// Create a new chrome debugging profile.
+this._dbgProfile = profileService.createProfile(null, profileName);
+profileService.flush();
+dumpn("Finished creating the chrome toolbox user profile.");
+dumpn("Flushed profile service with: " + profileName);
+},
+/**
+* Creates and initializes the profile & process for the remote debugger.
+*/
+_create: function() {
+dumpn("Initializing chrome debugging process.");
+let process = this._dbgProcess = Cc["@mozilla.org/process/util;1"].createInstance(Ci.nsIProcess);
+process.init(Services.dirsvc.get("XREExeF", Ci.nsIFile));
+let xulURI = DBG_XUL;
+if (this._options.addonID) {
+xulURI += "?addonID=" + this._options.addonID;
+}
+dumpn("Running chrome debugging process.");
+let args = ["-no-remote", "-foreground", "-P", this._dbgProfile.name, "-chrome", xulURI];
+process.runwAsync(args, args.length, { observe: () => this.close() });
+this._telemetry.toolOpened("jsbrowserdebugger");
+dumpn("Chrome toolbox is now running...");
+this.emit("run", this);
+},
+/**
+* Closes the remote debugging server and kills the toolbox process.
+*/
+close: function() {
+if (this.closed) {
+return;
+}
+dumpn("Cleaning up the chrome debugging process.");
+Services.obs.removeObserver(this.close, "quit-application");
+if (this._dbgProcess.isRunning) {
+this._dbgProcess.kill();
+}
+this._telemetry.toolClosed("jsbrowserdebugger");
+if (this.debuggerServer) {
+this.debuggerServer.destroy();
+}
+dumpn("Chrome toolbox is now closed...");
+this.closed = true;
+this.emit("close", this);
+processes.delete(this);
+}
+};
+/**
+* Shortcuts for accessing various debugger preferences.
+*/
+let Prefs = new ViewHelpers.Prefs("devtools.debugger", {
+chromeDebuggingHost: ["Char", "chrome-debugging-host"],
+chromeDebuggingPort: ["Int", "chrome-debugging-port"]
+});
+/**
+* Helper method for debugging.
+* @param string
+*/
+function dumpn(str) {
+if (wantLogging) {
+dump("DBG-FRONTEND: " + str + "\n");
+}
+}
+let wantLogging = Services.prefs.getBoolPref("devtools.debugger.log");
+Services.prefs.addObserver("devtools.debugger.log", {
+observe: (...args) => wantLogging = Services.prefs.getBoolPref(args.pop())
+}, false);

The Tor Browser / file comparison

comparison: browser/devtools/framework/ToolboxProcess.jsm

browser/devtools/framework/ToolboxProcess.jsm