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

--1:000000000000
+:af3292c1d297
+/* 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";
+this.EXPORTED_SYMBOLS = [ "gDevTools", "DevTools", "gDevToolsBrowser" ];
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/devtools/event-emitter.js");
+Cu.import("resource://gre/modules/devtools/Loader.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "promise", "resource://gre/modules/Promise.jsm", "Promise");
+const FORBIDDEN_IDS = new Set(["toolbox", ""]);
+const MAX_ORDINAL = 99;
+/**
+* DevTools is a class that represents a set of developer tools, it holds a
+* set of tools and keeps track of open toolboxes in the browser.
+*/
+this.DevTools = function DevTools() {
+this._tools = new Map();     // Map<toolId, tool>
+this._toolboxes = new Map(); // Map<target, toolbox>
+// destroy() is an observer's handler so we need to preserve context.
+this.destroy = this.destroy.bind(this);
+this._teardown = this._teardown.bind(this);
+this._testing = false;
+EventEmitter.decorate(this);
+Services.obs.addObserver(this._teardown, "devtools-unloaded", false);
+Services.obs.addObserver(this.destroy, "quit-application", false);
+}
+DevTools.prototype = {
+/**
+* When the testing flag is set we take appropriate action to prevent race
+* conditions in our testing environment. This means setting
+* dom.send_after_paint_to_content to false to prevent infinite MozAfterPaint
+* loops and not autohiding the highlighter.
+*/
+get testing() {
+return this._testing;
+},
+set testing(state) {
+this._testing = state;
+if (state) {
+// dom.send_after_paint_to_content is set to true (non-default) in
+// testing/profiles/prefs_general.js so lets set it to the same as it is
+// in a default browser profile for the duration of the test.
+Services.prefs.setBoolPref("dom.send_after_paint_to_content", false);
+} else {
+Services.prefs.setBoolPref("dom.send_after_paint_to_content", true);
+}
+},
+/**
+* Register a new developer tool.
+*
+* A definition is a light object that holds different information about a
+* developer tool. This object is not supposed to have any operational code.
+* See it as a "manifest".
+* The only actual code lives in the build() function, which will be used to
+* start an instance of this tool.
+*
+* Each toolDefinition has the following properties:
+* - id: Unique identifier for this tool (string|required)
+* - visibilityswitch: Property name to allow us to hide this tool from the
+*                     DevTools Toolbox.
+*                     A falsy value indicates that it cannot be hidden.
+* - icon: URL pointing to a graphic which will be used as the src for an
+*         16x16 img tag (string|required)
+* - invertIconForLightTheme: The icon can automatically have an inversion
+*         filter applied (default is false).  All builtin tools are true, but
+*         addons may omit this to prevent unwanted changes to the `icon`
+*         image. See browser/themes/shared/devtools/filters.svg#invert for
+*         the filter being applied to the images (boolean|optional)
+* - url: URL pointing to a XUL/XHTML document containing the user interface
+*        (string|required)
+* - label: Localized name for the tool to be displayed to the user
+*          (string|required)
+* - build: Function that takes an iframe, which has been populated with the
+*          markup from |url|, and also the toolbox containing the panel.
+*          And returns an instance of ToolPanel (function|required)
+*/
+registerTool: function DT_registerTool(toolDefinition) {
+let toolId = toolDefinition.id;
+if (!toolId || FORBIDDEN_IDS.has(toolId)) {
+throw new Error("Invalid definition.id");
+}
+// Make sure that additional tools will always be able to be hidden.
+// When being called from main.js, defaultTools has not yet been exported.
+// But, we can assume that in this case, it is a default tool.
+if (devtools.defaultTools && devtools.defaultTools.indexOf(toolDefinition) == -1) {
+toolDefinition.visibilityswitch = "devtools." + toolId + ".enabled";
+}
+this._tools.set(toolId, toolDefinition);
+this.emit("tool-registered", toolId);
+},
+/**
+* Removes all tools that match the given |toolId|
+* Needed so that add-ons can remove themselves when they are deactivated
+*
+* @param {string|object} tool
+*        Definition or the id of the tool to unregister. Passing the
+*        tool id should be avoided as it is a temporary measure.
+* @param {boolean} isQuitApplication
+*        true to indicate that the call is due to app quit, so we should not
+*        cause a cascade of costly events
+*/
+unregisterTool: function DT_unregisterTool(tool, isQuitApplication) {
+let toolId = null;
+if (typeof tool == "string") {
+toolId = tool;
+tool = this._tools.get(tool);
+}
+else {
+toolId = tool.id;
+}
+this._tools.delete(toolId);
+if (!isQuitApplication) {
+this.emit("tool-unregistered", tool);
+}
+},
+/**
+* Sorting function used for sorting tools based on their ordinals.
+*/
+ordinalSort: function DT_ordinalSort(d1, d2) {
+let o1 = (typeof d1.ordinal == "number") ? d1.ordinal : MAX_ORDINAL;
+let o2 = (typeof d2.ordinal == "number") ? d2.ordinal : MAX_ORDINAL;
+return o1 - o2;
+},
+getDefaultTools: function DT_getDefaultTools() {
+return devtools.defaultTools.sort(this.ordinalSort);
+},
+getAdditionalTools: function DT_getAdditionalTools() {
+let tools = [];
+for (let [key, value] of this._tools) {
+if (devtools.defaultTools.indexOf(value) == -1) {
+tools.push(value);
+}
+}
+return tools.sort(this.ordinalSort);
+},
+/**
+* Get a tool definition if it exists and is enabled.
+*
+* @param {string} toolId
+*        The id of the tool to show
+*
+* @return {ToolDefinition|null} tool
+*         The ToolDefinition for the id or null.
+*/
+getToolDefinition: function DT_getToolDefinition(toolId) {
+let tool = this._tools.get(toolId);
+if (!tool) {
+return null;
+} else if (!tool.visibilityswitch) {
+return tool;
+}
+let enabled;
+try {
+enabled = Services.prefs.getBoolPref(tool.visibilityswitch);
+} catch (e) {
+enabled = true;
+}
+return enabled ? tool : null;
+},
+/**
+* Allow ToolBoxes to get at the list of tools that they should populate
+* themselves with.
+*
+* @return {Map} tools
+*         A map of the the tool definitions registered in this instance
+*/
+getToolDefinitionMap: function DT_getToolDefinitionMap() {
+let tools = new Map();
+for (let [id, definition] of this._tools) {
+if (this.getToolDefinition(id)) {
+tools.set(id, definition);
+}
+}
+return tools;
+},
+/**
+* Tools have an inherent ordering that can't be represented in a Map so
+* getToolDefinitionArray provides an alternative representation of the
+* definitions sorted by ordinal value.
+*
+* @return {Array} tools
+*         A sorted array of the tool definitions registered in this instance
+*/
+getToolDefinitionArray: function DT_getToolDefinitionArray() {
+let definitions = [];
+for (let [id, definition] of this._tools) {
+if (this.getToolDefinition(id)) {
+definitions.push(definition);
+}
+}
+return definitions.sort(this.ordinalSort);
+},
+/**
+* Show a Toolbox for a target (either by creating a new one, or if a toolbox
+* already exists for the target, by bring to the front the existing one)
+* If |toolId| is specified then the displayed toolbox will have the
+* specified tool selected.
+* If |hostType| is specified then the toolbox will be displayed using the
+* specified HostType.
+*
+* @param {Target} target
+*         The target the toolbox will debug
+* @param {string} toolId
+*        The id of the tool to show
+* @param {Toolbox.HostType} hostType
+*        The type of host (bottom, window, side)
+* @param {object} hostOptions
+*        Options for host specifically
+*
+* @return {Toolbox} toolbox
+*        The toolbox that was opened
+*/
+showToolbox: function(target, toolId, hostType, hostOptions) {
+let deferred = promise.defer();
+let toolbox = this._toolboxes.get(target);
+if (toolbox) {
+let hostPromise = (hostType != null && toolbox.hostType != hostType) ?
+toolbox.switchHost(hostType) :
+promise.resolve(null);
+if (toolId != null && toolbox.currentToolId != toolId) {
+hostPromise = hostPromise.then(function() {
+return toolbox.selectTool(toolId);
+});
+}
+return hostPromise.then(function() {
+toolbox.raise();
+return toolbox;
+});
+}
+else {
+// No toolbox for target, create one
+toolbox = new devtools.Toolbox(target, toolId, hostType, hostOptions);
+this._toolboxes.set(target, toolbox);
+toolbox.once("destroyed", function() {
+this._toolboxes.delete(target);
+this.emit("toolbox-destroyed", target);
+}.bind(this));
+// If we were asked for a specific tool then we need to wait for the
+// tool to be ready, otherwise we can just wait for toolbox open
+if (toolId != null) {
+toolbox.once(toolId + "-ready", function(event, panel) {
+this.emit("toolbox-ready", toolbox);
+deferred.resolve(toolbox);
+}.bind(this));
+toolbox.open();
+}
+else {
+toolbox.open().then(function() {
+deferred.resolve(toolbox);
+this.emit("toolbox-ready", toolbox);
+}.bind(this));
+}
+}
+return deferred.promise;
+},
+/**
+* Return the toolbox for a given target.
+*
+* @param  {object} target
+*         Target value e.g. the target that owns this toolbox
+*
+* @return {Toolbox} toolbox
+*         The toobox that is debugging the given target
+*/
+getToolbox: function DT_getToolbox(target) {
+return this._toolboxes.get(target);
+},
+/**
+* Close the toolbox for a given target
+*
+* @return promise
+*         This promise will resolve to false if no toolbox was found
+*         associated to the target. true, if the toolbox was successfuly
+*         closed.
+*/
+closeToolbox: function DT_closeToolbox(target) {
+let toolbox = this._toolboxes.get(target);
+if (toolbox == null) {
+return promise.resolve(false);
+}
+return toolbox.destroy().then(() => true);
+},
+/**
+* Called to tear down a tools provider.
+*/
+_teardown: function DT_teardown() {
+for (let [target, toolbox] of this._toolboxes) {
+toolbox.destroy();
+}
+},
+/**
+* All browser windows have been closed, tidy up remaining objects.
+*/
+destroy: function() {
+Services.obs.removeObserver(this.destroy, "quit-application");
+Services.obs.removeObserver(this._teardown, "devtools-unloaded");
+for (let [key, tool] of this.getToolDefinitionMap()) {
+this.unregisterTool(key, true);
+}
+// Cleaning down the toolboxes: i.e.
+//   for (let [target, toolbox] of this._toolboxes) toolbox.destroy();
+// Is taken care of by the gDevToolsBrowser.forgetBrowserWindow
+},
+/**
+* Iterator that yields each of the toolboxes.
+*/
+'@@iterator': function*() {
+for (let toolbox of this._toolboxes) {
+yield toolbox;
+}
+}
+};
+/**
+* gDevTools is a singleton that controls the Firefox Developer Tools.
+*
+* It is an instance of a DevTools class that holds a set of tools. It has the
+* same lifetime as the browser.
+*/
+let gDevTools = new DevTools();
+this.gDevTools = gDevTools;
+/**
+* gDevToolsBrowser exposes functions to connect the gDevTools instance with a
+* Firefox instance.
+*/
+let gDevToolsBrowser = {
+/**
+* A record of the windows whose menus we altered, so we can undo the changes
+* as the window is closed
+*/
+_trackedBrowserWindows: new Set(),
+/**
+* This function is for the benefit of Tools:DevToolbox in
+* browser/base/content/browser-sets.inc and should not be used outside
+* of there
+*/
+toggleToolboxCommand: function(gBrowser) {
+let target = devtools.TargetFactory.forTab(gBrowser.selectedTab);
+let toolbox = gDevTools.getToolbox(target);
+toolbox ? toolbox.destroy() : gDevTools.showToolbox(target);
+},
+toggleBrowserToolboxCommand: function(gBrowser) {
+let target = devtools.TargetFactory.forWindow(gBrowser.ownerDocument.defaultView);
+let toolbox = gDevTools.getToolbox(target);
+toolbox ? toolbox.destroy()
+: gDevTools.showToolbox(target, "inspector", Toolbox.HostType.WINDOW);
+},
+/**
+* This function ensures the right commands are enabled in a window,
+* depending on their relevant prefs. It gets run when a window is registered,
+* or when any of the devtools prefs change.
+*/
+updateCommandAvailability: function(win) {
+let doc = win.document;
+function toggleCmd(id, isEnabled) {
+let cmd = doc.getElementById(id);
+if (isEnabled) {
+cmd.removeAttribute("disabled");
+cmd.removeAttribute("hidden");
+} else {
+cmd.setAttribute("disabled", "true");
+cmd.setAttribute("hidden", "true");
+}
+};
+// Enable developer toolbar?
+let devToolbarEnabled = Services.prefs.getBoolPref("devtools.toolbar.enabled");
+toggleCmd("Tools:DevToolbar", devToolbarEnabled);
+let focusEl = doc.getElementById("Tools:DevToolbarFocus");
+if (devToolbarEnabled) {
+focusEl.removeAttribute("disabled");
+} else {
+focusEl.setAttribute("disabled", "true");
+}
+if (devToolbarEnabled && Services.prefs.getBoolPref("devtools.toolbar.visible")) {
+win.DeveloperToolbar.show(false);
+}
+// Enable App Manager?
+let appMgrEnabled = Services.prefs.getBoolPref("devtools.appmanager.enabled");
+toggleCmd("Tools:DevAppMgr", appMgrEnabled);
+// Enable Browser Toolbox?
+let chromeEnabled = Services.prefs.getBoolPref("devtools.chrome.enabled");
+let devtoolsRemoteEnabled = Services.prefs.getBoolPref("devtools.debugger.remote-enabled");
+let remoteEnabled = chromeEnabled && devtoolsRemoteEnabled &&
+Services.prefs.getBoolPref("devtools.debugger.chrome-enabled");
+toggleCmd("Tools:BrowserToolbox", remoteEnabled);
+// Enable Error Console?
+let consoleEnabled = Services.prefs.getBoolPref("devtools.errorconsole.enabled");
+toggleCmd("Tools:ErrorConsole", consoleEnabled);
+// Enable DevTools connection screen, if the preference allows this.
+toggleCmd("Tools:DevToolsConnect", devtoolsRemoteEnabled);
+},
+observe: function(subject, topic, prefName) {
+if (prefName.endsWith("enabled")) {
+for (let win of this._trackedBrowserWindows) {
+this.updateCommandAvailability(win);
+}
+}
+},
+_prefObserverRegistered: false,
+ensurePrefObserver: function() {
+if (!this._prefObserverRegistered) {
+this._prefObserverRegistered = true;
+Services.prefs.addObserver("devtools.", this, false);
+}
+},
+/**
+* This function is for the benefit of Tools:{toolId} commands,
+* triggered from the WebDeveloper menu and keyboard shortcuts.
+*
+* selectToolCommand's behavior:
+* - if the toolbox is closed,
+*   we open the toolbox and select the tool
+* - if the toolbox is open, and the targetted tool is not selected,
+*   we select it
+* - if the toolbox is open, and the targetted tool is selected,
+*   and the host is NOT a window, we close the toolbox
+* - if the toolbox is open, and the targetted tool is selected,
+*   and the host is a window, we raise the toolbox window
+*/
+selectToolCommand: function(gBrowser, toolId) {
+let target = devtools.TargetFactory.forTab(gBrowser.selectedTab);
+let toolbox = gDevTools.getToolbox(target);
+let toolDefinition = gDevTools.getToolDefinition(toolId);
+if (toolbox &&
+(toolbox.currentToolId == toolId ||
+(toolId == "webconsole" && toolbox.splitConsole)))
+{
+toolbox.fireCustomKey(toolId);
+if (toolDefinition.preventClosingOnKey || toolbox.hostType == devtools.Toolbox.HostType.WINDOW) {
+toolbox.raise();
+} else {
+toolbox.destroy();
+}
+} else {
+gDevTools.showToolbox(target, toolId).then(() => {
+let target = devtools.TargetFactory.forTab(gBrowser.selectedTab);
+let toolbox = gDevTools.getToolbox(target);
+toolbox.fireCustomKey(toolId);
+});
+}
+},
+/**
+* Open a tab to allow connects to a remote browser
+*/
+openConnectScreen: function(gBrowser) {
+gBrowser.selectedTab = gBrowser.addTab("chrome://browser/content/devtools/connect.xhtml");
+},
+/**
+* Open the App Manager
+*/
+openAppManager: function(gBrowser) {
+gBrowser.selectedTab = gBrowser.addTab("about:app-manager");
+},
+/**
+* Add this DevTools's presence to a browser window's document
+*
+* @param {XULDocument} doc
+*        The document to which menuitems and handlers are to be added
+*/
+registerBrowserWindow: function DT_registerBrowserWindow(win) {
+this.updateCommandAvailability(win);
+this.ensurePrefObserver();
+gDevToolsBrowser._trackedBrowserWindows.add(win);
+gDevToolsBrowser._addAllToolsToMenu(win.document);
+if (this._isFirebugInstalled()) {
+let broadcaster = win.document.getElementById("devtoolsMenuBroadcaster_DevToolbox");
+broadcaster.removeAttribute("key");
+}
+let tabContainer = win.document.getElementById("tabbrowser-tabs")
+tabContainer.addEventListener("TabSelect",
+gDevToolsBrowser._updateMenuCheckbox, false);
+},
+/**
+* Add a <key> to <keyset id="devtoolsKeyset">.
+* Appending a <key> element is not always enough. The <keyset> needs
+* to be detached and reattached to make sure the <key> is taken into
+* account (see bug 832984).
+*
+* @param {XULDocument} doc
+*        The document to which keys are to be added
+* @param {XULElement} or {DocumentFragment} keys
+*        Keys to add
+*/
+attachKeybindingsToBrowser: function DT_attachKeybindingsToBrowser(doc, keys) {
+let devtoolsKeyset = doc.getElementById("devtoolsKeyset");
+if (!devtoolsKeyset) {
+devtoolsKeyset = doc.createElement("keyset");
+devtoolsKeyset.setAttribute("id", "devtoolsKeyset");
+}
+devtoolsKeyset.appendChild(keys);
+let mainKeyset = doc.getElementById("mainKeyset");
+mainKeyset.parentNode.insertBefore(devtoolsKeyset, mainKeyset);
+},
+/**
+* Detect the presence of a Firebug.
+*
+* @return promise
+*/
+_isFirebugInstalled: function DT_isFirebugInstalled() {
+let bootstrappedAddons = Services.prefs.getCharPref("extensions.bootstrappedAddons");
+return bootstrappedAddons.indexOf("firebug@software.joehewitt.com") != -1;
+},
+/**
+* Add the menuitem for a tool to all open browser windows.
+*
+* @param {object} toolDefinition
+*        properties of the tool to add
+*/
+_addToolToWindows: function DT_addToolToWindows(toolDefinition) {
+// No menu item or global shortcut is required for options panel.
+if (!toolDefinition.inMenu) {
+return;
+}
+// Skip if the tool is disabled.
+try {
+if (toolDefinition.visibilityswitch &&
+!Services.prefs.getBoolPref(toolDefinition.visibilityswitch)) {
+return;
+}
+} catch(e) {}
+// We need to insert the new tool in the right place, which means knowing
+// the tool that comes before the tool that we're trying to add
+let allDefs = gDevTools.getToolDefinitionArray();
+let prevDef;
+for (let def of allDefs) {
+if (!def.inMenu) {
+continue;
+}
+if (def === toolDefinition) {
+break;
+}
+prevDef = def;
+}
+for (let win of gDevToolsBrowser._trackedBrowserWindows) {
+let doc = win.document;
+let elements = gDevToolsBrowser._createToolMenuElements(toolDefinition, doc);
+doc.getElementById("mainCommandSet").appendChild(elements.cmd);
+if (elements.key) {
+this.attachKeybindingsToBrowser(doc, elements.key);
+}
+doc.getElementById("mainBroadcasterSet").appendChild(elements.bc);
+let amp = doc.getElementById("appmenu_webDeveloper_popup");
+if (amp) {
+let ref;
+if (prevDef != null) {
+let menuitem = doc.getElementById("appmenuitem_" + prevDef.id);
+ref = menuitem && menuitem.nextSibling ? menuitem.nextSibling : null;
+} else {
+ref = doc.getElementById("appmenu_devtools_separator");
+}
+if (ref) {
+amp.insertBefore(elements.appmenuitem, ref);
+}
+}
+let mp = doc.getElementById("menuWebDeveloperPopup");
+if (mp) {
+let ref;
+if (prevDef != null) {
+let menuitem = doc.getElementById("menuitem_" + prevDef.id);
+ref = menuitem && menuitem.nextSibling ? menuitem.nextSibling : null;
+} else {
+ref = doc.getElementById("menu_devtools_separator");
+}
+if (ref) {
+mp.insertBefore(elements.menuitem, ref);
+}
+}
+}
+},
+/**
+* Add all tools to the developer tools menu of a window.
+*
+* @param {XULDocument} doc
+*        The document to which the tool items are to be added.
+*/
+_addAllToolsToMenu: function DT_addAllToolsToMenu(doc) {
+let fragCommands = doc.createDocumentFragment();
+let fragKeys = doc.createDocumentFragment();
+let fragBroadcasters = doc.createDocumentFragment();
+let fragAppMenuItems = doc.createDocumentFragment();
+let fragMenuItems = doc.createDocumentFragment();
+for (let toolDefinition of gDevTools.getToolDefinitionArray()) {
+if (!toolDefinition.inMenu) {
+continue;
+}
+let elements = gDevToolsBrowser._createToolMenuElements(toolDefinition, doc);
+if (!elements) {
+return;
+}
+fragCommands.appendChild(elements.cmd);
+if (elements.key) {
+fragKeys.appendChild(elements.key);
+}
+fragBroadcasters.appendChild(elements.bc);
+fragAppMenuItems.appendChild(elements.appmenuitem);
+fragMenuItems.appendChild(elements.menuitem);
+}
+let mcs = doc.getElementById("mainCommandSet");
+mcs.appendChild(fragCommands);
+this.attachKeybindingsToBrowser(doc, fragKeys);
+let mbs = doc.getElementById("mainBroadcasterSet");
+mbs.appendChild(fragBroadcasters);
+let amp = doc.getElementById("appmenu_webDeveloper_popup");
+if (amp) {
+let amps = doc.getElementById("appmenu_devtools_separator");
+amp.insertBefore(fragAppMenuItems, amps);
+}
+let mp = doc.getElementById("menuWebDeveloperPopup");
+let mps = doc.getElementById("menu_devtools_separator");
+mp.insertBefore(fragMenuItems, mps);
+},
+/**
+* Add a menu entry for a tool definition
+*
+* @param {string} toolDefinition
+*        Tool definition of the tool to add a menu entry.
+* @param {XULDocument} doc
+*        The document to which the tool menu item is to be added.
+*/
+_createToolMenuElements: function DT_createToolMenuElements(toolDefinition, doc) {
+let id = toolDefinition.id;
+// Prevent multiple entries for the same tool.
+if (doc.getElementById("Tools:" + id)) {
+return;
+}
+let cmd = doc.createElement("command");
+cmd.id = "Tools:" + id;
+cmd.setAttribute("oncommand",
+'gDevToolsBrowser.selectToolCommand(gBrowser, "' + id + '");');
+let key = null;
+if (toolDefinition.key) {
+key = doc.createElement("key");
+key.id = "key_" + id;
+if (toolDefinition.key.startsWith("VK_")) {
+key.setAttribute("keycode", toolDefinition.key);
+} else {
+key.setAttribute("key", toolDefinition.key);
+}
+key.setAttribute("command", cmd.id);
+key.setAttribute("modifiers", toolDefinition.modifiers);
+}
+let bc = doc.createElement("broadcaster");
+bc.id = "devtoolsMenuBroadcaster_" + id;
+bc.setAttribute("label", toolDefinition.menuLabel || toolDefinition.label);
+bc.setAttribute("command", cmd.id);
+if (key) {
+bc.setAttribute("key", "key_" + id);
+}
+let appmenuitem = doc.createElement("menuitem");
+appmenuitem.id = "appmenuitem_" + id;
+appmenuitem.setAttribute("observes", "devtoolsMenuBroadcaster_" + id);
+let menuitem = doc.createElement("menuitem");
+menuitem.id = "menuitem_" + id;
+menuitem.setAttribute("observes", "devtoolsMenuBroadcaster_" + id);
+if (toolDefinition.accesskey) {
+menuitem.setAttribute("accesskey", toolDefinition.accesskey);
+}
+return {
+cmd: cmd,
+key: key,
+bc: bc,
+appmenuitem: appmenuitem,
+menuitem: menuitem
+};
+},
+/**
+* Update the "Toggle Tools" checkbox in the developer tools menu. This is
+* called when a toolbox is created or destroyed.
+*/
+_updateMenuCheckbox: function DT_updateMenuCheckbox() {
+for (let win of gDevToolsBrowser._trackedBrowserWindows) {
+let hasToolbox = false;
+if (devtools.TargetFactory.isKnownTab(win.gBrowser.selectedTab)) {
+let target = devtools.TargetFactory.forTab(win.gBrowser.selectedTab);
+if (gDevTools._toolboxes.has(target)) {
+hasToolbox = true;
+}
+}
+let broadcaster = win.document.getElementById("devtoolsMenuBroadcaster_DevToolbox");
+if (hasToolbox) {
+broadcaster.setAttribute("checked", "true");
+} else {
+broadcaster.removeAttribute("checked");
+}
+}
+},
+/**
+* Connects to the SPS profiler when the developer tools are open.
+*/
+_connectToProfiler: function DT_connectToProfiler() {
+let ProfilerController = devtools.require("devtools/profiler/controller");
+for (let win of gDevToolsBrowser._trackedBrowserWindows) {
+if (devtools.TargetFactory.isKnownTab(win.gBrowser.selectedTab)) {
+let target = devtools.TargetFactory.forTab(win.gBrowser.selectedTab);
+if (gDevTools._toolboxes.has(target)) {
+target.makeRemote().then(() => {
+let profiler = new ProfilerController(target);
+profiler.connect();
+}).then(null, Cu.reportError);
+return;
+}
+}
+}
+},
+/**
+* Remove the menuitem for a tool to all open browser windows.
+*
+* @param {string} toolId
+*        id of the tool to remove
+*/
+_removeToolFromWindows: function DT_removeToolFromWindows(toolId) {
+for (let win of gDevToolsBrowser._trackedBrowserWindows) {
+gDevToolsBrowser._removeToolFromMenu(toolId, win.document);
+}
+},
+/**
+* Remove a tool's menuitem from a window
+*
+* @param {string} toolId
+*        Id of the tool to add a menu entry for
+* @param {XULDocument} doc
+*        The document to which the tool menu item is to be removed from
+*/
+_removeToolFromMenu: function DT_removeToolFromMenu(toolId, doc) {
+let command = doc.getElementById("Tools:" + toolId);
+if (command) {
+command.parentNode.removeChild(command);
+}
+let key = doc.getElementById("key_" + toolId);
+if (key) {
+key.parentNode.removeChild(key);
+}
+let bc = doc.getElementById("devtoolsMenuBroadcaster_" + toolId);
+if (bc) {
+bc.parentNode.removeChild(bc);
+}
+let appmenuitem = doc.getElementById("appmenuitem_" + toolId);
+if (appmenuitem) {
+appmenuitem.parentNode.removeChild(appmenuitem);
+}
+let menuitem = doc.getElementById("menuitem_" + toolId);
+if (menuitem) {
+menuitem.parentNode.removeChild(menuitem);
+}
+},
+/**
+* Called on browser unload to remove menu entries, toolboxes and event
+* listeners from the closed browser window.
+*
+* @param  {XULWindow} win
+*         The window containing the menu entry
+*/
+forgetBrowserWindow: function DT_forgetBrowserWindow(win) {
+gDevToolsBrowser._trackedBrowserWindows.delete(win);
+// Destroy toolboxes for closed window
+for (let [target, toolbox] of gDevTools._toolboxes) {
+if (toolbox.frame && toolbox.frame.ownerDocument.defaultView == win) {
+toolbox.destroy();
+}
+}
+let tabContainer = win.document.getElementById("tabbrowser-tabs")
+tabContainer.removeEventListener("TabSelect",
+gDevToolsBrowser._updateMenuCheckbox, false);
+},
+/**
+* All browser windows have been closed, tidy up remaining objects.
+*/
+destroy: function() {
+gDevTools.off("toolbox-ready", gDevToolsBrowser._connectToProfiler);
+Services.prefs.removeObserver("devtools.", gDevToolsBrowser);
+Services.obs.removeObserver(gDevToolsBrowser.destroy, "quit-application");
+},
+}
+this.gDevToolsBrowser = gDevToolsBrowser;
+gDevTools.on("tool-registered", function(ev, toolId) {
+let toolDefinition = gDevTools._tools.get(toolId);
+gDevToolsBrowser._addToolToWindows(toolDefinition);
+});
+gDevTools.on("tool-unregistered", function(ev, toolId) {
+if (typeof toolId != "string") {
+toolId = toolId.id;
+}
+gDevToolsBrowser._removeToolFromWindows(toolId);
+});
+gDevTools.on("toolbox-ready", gDevToolsBrowser._updateMenuCheckbox);
+gDevTools.on("toolbox-ready", gDevToolsBrowser._connectToProfiler);
+gDevTools.on("toolbox-destroyed", gDevToolsBrowser._updateMenuCheckbox);
+Services.obs.addObserver(gDevToolsBrowser.destroy, "quit-application", false);
+// Load the browser devtools main module as the loader's main module.
+devtools.main("main");

The Tor Browser / file comparison

comparison: browser/devtools/framework/gDevTools.jsm

browser/devtools/framework/gDevTools.jsm