Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 4716 insertions, 0 deletions

diff --git a/devtools/client/framework/toolbox.js b/devtools/client/framework/toolbox.js
new file mode 100644
index 0000000000..f4f7167f88
--- /dev/null
+++ b/devtools/client/framework/toolbox.js
@@ -0,0 +1,4716 @@
+/* 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 MAX_ORDINAL = 99;
+const SPLITCONSOLE_ENABLED_PREF = "devtools.toolbox.splitconsoleEnabled";
+const SPLITCONSOLE_HEIGHT_PREF = "devtools.toolbox.splitconsoleHeight";
+const DEVTOOLS_ALWAYS_ON_TOP = "devtools.toolbox.alwaysOnTop";
+const DISABLE_AUTOHIDE_PREF = "ui.popup.disable_autohide";
+const PSEUDO_LOCALE_PREF = "intl.l10n.pseudo";
+const HOST_HISTOGRAM = "DEVTOOLS_TOOLBOX_HOST";
+const CURRENT_THEME_SCALAR = "devtools.current_theme";
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+const REGEX_4XX_5XX = /^[4,5]\d\d$/;
+
+const BROWSERTOOLBOX_SCOPE_PREF = "devtools.browsertoolbox.scope";
+const BROWSERTOOLBOX_SCOPE_EVERYTHING = "everything";
+const BROWSERTOOLBOX_SCOPE_PARENTPROCESS = "parent-process";
+
+const { debounce } = require("resource://devtools/shared/debounce.js");
+const { throttle } = require("resource://devtools/shared/throttle.js");
+const {
+  safeAsyncMethod,
+} = require("resource://devtools/shared/async-utils.js");
+var { gDevTools } = require("resource://devtools/client/framework/devtools.js");
+var EventEmitter = require("resource://devtools/shared/event-emitter.js");
+const Selection = require("resource://devtools/client/framework/selection.js");
+var Telemetry = require("resource://devtools/client/shared/telemetry.js");
+const {
+  getUnicodeUrl,
+} = require("resource://devtools/client/shared/unicode-url.js");
+var { DOMHelpers } = require("resource://devtools/shared/dom-helpers.js");
+const { KeyCodes } = require("resource://devtools/client/shared/keycodes.js");
+const {
+  FluentL10n,
+} = require("resource://devtools/client/shared/fluent-l10n/fluent-l10n.js");
+
+var Startup = Cc["@mozilla.org/devtools/startup-clh;1"].getService(
+  Ci.nsISupports
+).wrappedJSObject;
+
+const { BrowserLoader } = ChromeUtils.import(
+  "resource://devtools/shared/loader/browser-loader.js"
+);
+
+const {
+  MultiLocalizationHelper,
+} = require("resource://devtools/shared/l10n.js");
+const L10N = new MultiLocalizationHelper(
+  "devtools/client/locales/toolbox.properties",
+  "chrome://branding/locale/brand.properties"
+);
+
+loader.lazyRequireGetter(
+  this,
+  "registerStoreObserver",
+  "resource://devtools/client/shared/redux/subscriber.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "createToolboxStore",
+  "resource://devtools/client/framework/store.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  ["registerWalkerListeners"],
+  "resource://devtools/client/framework/actions/index.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  ["selectTarget"],
+  "resource://devtools/shared/commands/target/actions/targets.js",
+  true
+);
+
+const lazy = {};
+ChromeUtils.defineESModuleGetters(lazy, {
+  AppConstants: "resource://gre/modules/AppConstants.sys.mjs",
+});
+loader.lazyRequireGetter(this, "flags", "resource://devtools/shared/flags.js");
+loader.lazyRequireGetter(
+  this,
+  "KeyShortcuts",
+  "resource://devtools/client/shared/key-shortcuts.js"
+);
+loader.lazyRequireGetter(
+  this,
+  "ZoomKeys",
+  "resource://devtools/client/shared/zoom-keys.js"
+);
+loader.lazyRequireGetter(
+  this,
+  "ToolboxButtons",
+  "resource://devtools/client/definitions.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "SourceMapURLService",
+  "resource://devtools/client/framework/source-map-url-service.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "BrowserConsoleManager",
+  "resource://devtools/client/webconsole/browser-console-manager.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "viewSource",
+  "resource://devtools/client/shared/view-source.js"
+);
+loader.lazyRequireGetter(
+  this,
+  "buildHarLog",
+  "resource://devtools/client/netmonitor/src/har/har-builder-utils.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "NetMonitorAPI",
+  "resource://devtools/client/netmonitor/src/api.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "sortPanelDefinitions",
+  "resource://devtools/client/framework/toolbox-tabs-order-manager.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "createEditContextMenu",
+  "resource://devtools/client/framework/toolbox-context-menu.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "getSelectedTarget",
+  "resource://devtools/shared/commands/target/selectors/targets.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "remoteClientManager",
+  "resource://devtools/client/shared/remote-debugging/remote-client-manager.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "ResponsiveUIManager",
+  "resource://devtools/client/responsive/manager.js"
+);
+loader.lazyRequireGetter(
+  this,
+  "DevToolsUtils",
+  "resource://devtools/shared/DevToolsUtils.js"
+);
+loader.lazyRequireGetter(
+  this,
+  "NodePicker",
+  "resource://devtools/client/inspector/node-picker.js"
+);
+
+loader.lazyGetter(this, "domNodeConstants", () => {
+  return require("resource://devtools/shared/dom-node-constants.js");
+});
+
+loader.lazyRequireGetter(
+  this,
+  "NodeFront",
+  "resource://devtools/client/fronts/node.js",
+  true
+);
+
+loader.lazyRequireGetter(
+  this,
+  "PICKER_TYPES",
+  "resource://devtools/shared/picker-constants.js"
+);
+
+loader.lazyRequireGetter(
+  this,
+  "HarAutomation",
+  "resource://devtools/client/netmonitor/src/har/har-automation.js",
+  true
+);
+
+loader.lazyRequireGetter(
+  this,
+  "getThreadOptions",
+  "resource://devtools/client/shared/thread-utils.js",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "SourceMapLoader",
+  "resource://devtools/client/shared/source-map-loader/index.js",
+  true
+);
+
+/**
+ * A "Toolbox" is the component that holds all the tools for one specific
+ * target. Visually, it's a document that includes the tools tabs and all
+ * the iframes where the tool panels will be living in.
+ *
+ * @param {object} commands
+ *        The context to inspect identified by this commands.
+ * @param {string} selectedTool
+ *        Tool to select initially
+ * @param {Toolbox.HostType} hostType
+ *        Type of host that will host the toolbox (e.g. sidebar, window)
+ * @param {DOMWindow} contentWindow
+ *        The window object of the toolbox document
+ * @param {string} frameId
+ *        A unique identifier to differentiate toolbox documents from the
+ *        chrome codebase when passing DOM messages
+ */
+function Toolbox(commands, selectedTool, hostType, contentWindow, frameId) {
+  this._win = contentWindow;
+  this.frameId = frameId;
+  this.selection = new Selection();
+  this.telemetry = new Telemetry({ useSessionId: true });
+  // This attribute helps identify one particular toolbox instance.
+  this.sessionId = this.telemetry.sessionId;
+
+  // This attribute is meant to be a public attribute on the Toolbox object
+  // It exposes commands modules listed in devtools/shared/commands/index.js
+  // which are an abstraction on top of RDP methods.
+  // See devtools/shared/commands/README.md
+  this.commands = commands;
+  this._descriptorFront = commands.descriptorFront;
+
+  // Map of the available DevTools WebExtensions:
+  //   Map<extensionUUID, extensionName>
+  this._webExtensions = new Map();
+
+  this._toolPanels = new Map();
+  this._inspectorExtensionSidebars = new Map();
+
+  this._netMonitorAPI = null;
+
+  // Map of frames (id => frame-info) and currently selected frame id.
+  this.frameMap = new Map();
+  this.selectedFrameId = null;
+
+  // Number of targets currently paused
+  this._pausedTargets = 0;
+
+  /**
+   * KeyShortcuts instance specific to WINDOW host type.
+   * This is the key shortcuts that are only register when the toolbox
+   * is loaded in its own window. Otherwise, these shortcuts are typically
+   * registered by devtools-startup.js module.
+   */
+  this._windowHostShortcuts = null;
+
+  this._toolRegistered = this._toolRegistered.bind(this);
+  this._toolUnregistered = this._toolUnregistered.bind(this);
+  this._refreshHostTitle = this._refreshHostTitle.bind(this);
+  this.toggleNoAutohide = this.toggleNoAutohide.bind(this);
+  this.toggleAlwaysOnTop = this.toggleAlwaysOnTop.bind(this);
+  this.disablePseudoLocale = () => this.changePseudoLocale("none");
+  this.enableAccentedPseudoLocale = () => this.changePseudoLocale("accented");
+  this.enableBidiPseudoLocale = () => this.changePseudoLocale("bidi");
+  this._updateFrames = this._updateFrames.bind(this);
+  this._splitConsoleOnKeypress = this._splitConsoleOnKeypress.bind(this);
+  this.closeToolbox = this.closeToolbox.bind(this);
+  this.destroy = this.destroy.bind(this);
+  this._applyCacheSettings = this._applyCacheSettings.bind(this);
+  this._applyCustomFormatterSetting =
+    this._applyCustomFormatterSetting.bind(this);
+  this._applyServiceWorkersTestingSettings =
+    this._applyServiceWorkersTestingSettings.bind(this);
+  this._applySimpleHighlightersSettings =
+    this._applySimpleHighlightersSettings.bind(this);
+  this._saveSplitConsoleHeight = this._saveSplitConsoleHeight.bind(this);
+  this._onFocus = this._onFocus.bind(this);
+  this._onBlur = this._onBlur.bind(this);
+  this._onBrowserMessage = this._onBrowserMessage.bind(this);
+  this._onTabsOrderUpdated = this._onTabsOrderUpdated.bind(this);
+  this._onToolbarFocus = this._onToolbarFocus.bind(this);
+  this._onToolbarArrowKeypress = this._onToolbarArrowKeypress.bind(this);
+  this._onPickerClick = this._onPickerClick.bind(this);
+  this._onPickerKeypress = this._onPickerKeypress.bind(this);
+  this._onPickerStarting = this._onPickerStarting.bind(this);
+  this._onPickerStarted = this._onPickerStarted.bind(this);
+  this._onPickerStopped = this._onPickerStopped.bind(this);
+  this._onPickerCanceled = this._onPickerCanceled.bind(this);
+  this._onPickerPicked = this._onPickerPicked.bind(this);
+  this._onPickerPreviewed = this._onPickerPreviewed.bind(this);
+  this._onInspectObject = this._onInspectObject.bind(this);
+  this._onNewSelectedNodeFront = this._onNewSelectedNodeFront.bind(this);
+  this._onToolSelected = this._onToolSelected.bind(this);
+  this._onContextMenu = this._onContextMenu.bind(this);
+  this._onMouseDown = this._onMouseDown.bind(this);
+  this.updateToolboxButtonsVisibility =
+    this.updateToolboxButtonsVisibility.bind(this);
+  this.updateToolboxButtons = this.updateToolboxButtons.bind(this);
+  this.selectTool = this.selectTool.bind(this);
+  this._pingTelemetrySelectTool = this._pingTelemetrySelectTool.bind(this);
+  this.toggleSplitConsole = this.toggleSplitConsole.bind(this);
+  this.toggleOptions = this.toggleOptions.bind(this);
+  this._onTargetAvailable = this._onTargetAvailable.bind(this);
+  this._onTargetDestroyed = this._onTargetDestroyed.bind(this);
+  this._onTargetSelected = this._onTargetSelected.bind(this);
+  this._onResourceAvailable = this._onResourceAvailable.bind(this);
+  this._onResourceUpdated = this._onResourceUpdated.bind(this);
+  this._onToolSelectedStopPicker = this._onToolSelectedStopPicker.bind(this);
+
+  // `component` might be null if the toolbox was destroying during the throttling
+  this._throttledSetToolboxButtons = throttle(
+    () => this.component?.setToolboxButtons(this.toolbarButtons),
+    500,
+    this
+  );
+
+  this._debounceUpdateFocusedState = debounce(
+    () => {
+      this.component?.setFocusedState(this._isToolboxFocused);
+    },
+    500,
+    this
+  );
+
+  if (!selectedTool) {
+    selectedTool = Services.prefs.getCharPref(this._prefs.LAST_TOOL);
+  }
+  this._defaultToolId = selectedTool;
+
+  this._hostType = hostType;
+
+  this.isOpen = new Promise(
+    function (resolve) {
+      this._resolveIsOpen = resolve;
+    }.bind(this)
+  );
+
+  EventEmitter.decorate(this);
+
+  this.on("host-changed", this._refreshHostTitle);
+  this.on("select", this._onToolSelected);
+
+  this.selection.on("new-node-front", this._onNewSelectedNodeFront);
+
+  gDevTools.on("tool-registered", this._toolRegistered);
+  gDevTools.on("tool-unregistered", this._toolUnregistered);
+
+  /**
+   * Get text direction for the current locale direction.
+   *
+   * `getComputedStyle` forces a synchronous reflow, so use a lazy getter in order to
+   * call it only once.
+   */
+  loader.lazyGetter(this, "direction", () => {
+    const { documentElement } = this.doc;
+    const isRtl =
+      this.win.getComputedStyle(documentElement).direction === "rtl";
+    return isRtl ? "rtl" : "ltr";
+  });
+}
+exports.Toolbox = Toolbox;
+
+/**
+ * The toolbox can be 'hosted' either embedded in a browser window
+ * or in a separate window.
+ */
+Toolbox.HostType = {
+  BOTTOM: "bottom",
+  RIGHT: "right",
+  LEFT: "left",
+  WINDOW: "window",
+  BROWSERTOOLBOX: "browsertoolbox",
+  // This is typically used by `about:debugging`, when opening toolbox in a new tab,
+  // via `about:devtools-toolbox` URLs.
+  PAGE: "page",
+};
+
+Toolbox.prototype = {
+  _URL: "about:devtools-toolbox",
+
+  _prefs: {
+    LAST_TOOL: "devtools.toolbox.selectedTool",
+  },
+
+  get nodePicker() {
+    if (!this._nodePicker) {
+      this._nodePicker = new NodePicker(this.commands, this.selection);
+      this._nodePicker.on("picker-starting", this._onPickerStarting);
+      this._nodePicker.on("picker-started", this._onPickerStarted);
+      this._nodePicker.on("picker-stopped", this._onPickerStopped);
+      this._nodePicker.on("picker-node-canceled", this._onPickerCanceled);
+      this._nodePicker.on("picker-node-picked", this._onPickerPicked);
+      this._nodePicker.on("picker-node-previewed", this._onPickerPreviewed);
+    }
+
+    return this._nodePicker;
+  },
+
+  get store() {
+    if (!this._store) {
+      this._store = createToolboxStore();
+    }
+    return this._store;
+  },
+
+  get currentToolId() {
+    return this._currentToolId;
+  },
+
+  set currentToolId(id) {
+    this._currentToolId = id;
+    this.component.setCurrentToolId(id);
+  },
+
+  get defaultToolId() {
+    return this._defaultToolId;
+  },
+
+  get panelDefinitions() {
+    return this._panelDefinitions;
+  },
+
+  set panelDefinitions(definitions) {
+    this._panelDefinitions = definitions;
+    this._combineAndSortPanelDefinitions();
+  },
+
+  get visibleAdditionalTools() {
+    if (!this._visibleAdditionalTools) {
+      this._visibleAdditionalTools = [];
+    }
+
+    return this._visibleAdditionalTools;
+  },
+
+  set visibleAdditionalTools(tools) {
+    this._visibleAdditionalTools = tools;
+    if (this.isReady) {
+      this._combineAndSortPanelDefinitions();
+    }
+  },
+
+  /**
+   * Combines the built-in panel definitions and the additional tool definitions that
+   * can be set by add-ons.
+   */
+  _combineAndSortPanelDefinitions() {
+    let definitions = [
+      ...this._panelDefinitions,
+      ...this.getVisibleAdditionalTools(),
+    ];
+    definitions = sortPanelDefinitions(definitions);
+    this.component.setPanelDefinitions(definitions);
+  },
+
+  lastUsedToolId: null,
+
+  /**
+   * Returns a *copy* of the _toolPanels collection.
+   *
+   * @return {Map} panels
+   *         All the running panels in the toolbox
+   */
+  getToolPanels() {
+    return new Map(this._toolPanels);
+  },
+
+  /**
+   * Access the panel for a given tool
+   */
+  getPanel(id) {
+    return this._toolPanels.get(id);
+  },
+
+  /**
+   * Get the panel instance for a given tool once it is ready.
+   * If the tool is already opened, the promise will resolve immediately,
+   * otherwise it will wait until the tool has been opened before resolving.
+   *
+   * Note that this does not open the tool, use selectTool if you'd
+   * like to select the tool right away.
+   *
+   * @param  {String} id
+   *         The id of the panel, for example "jsdebugger".
+   * @returns Promise
+   *          A promise that resolves once the panel is ready.
+   */
+  getPanelWhenReady(id) {
+    const panel = this.getPanel(id);
+    return new Promise(resolve => {
+      if (panel) {
+        resolve(panel);
+      } else {
+        this.on(id + "-ready", initializedPanel => {
+          resolve(initializedPanel);
+        });
+      }
+    });
+  },
+
+  /**
+   * This is a shortcut for getPanel(currentToolId) because it is much more
+   * likely that we're going to want to get the panel that we've just made
+   * visible
+   */
+  getCurrentPanel() {
+    return this._toolPanels.get(this.currentToolId);
+  },
+
+  /**
+   * Get the current top level target the toolbox is debugging.
+   *
+   * This will only be defined *after* calling Toolbox.open(),
+   * after it has called `targetCommands.startListening`.
+   */
+  get target() {
+    return this.commands.targetCommand.targetFront;
+  },
+
+  get threadFront() {
+    return this.commands.targetCommand.targetFront.threadFront;
+  },
+
+  /**
+   * Get/alter the host of a Toolbox, i.e. is it in browser or in a separate
+   * tab. See HostType for more details.
+   */
+  get hostType() {
+    return this._hostType;
+  },
+
+  /**
+   * Shortcut to the window containing the toolbox UI
+   */
+  get win() {
+    return this._win;
+  },
+
+  /**
+   * When the toolbox is loaded in a frame with type="content", win.parent will not return
+   * the parent Chrome window. This getter should return the parent Chrome window
+   * regardless of the frame type. See Bug 1539979.
+   */
+  get topWindow() {
+    return DevToolsUtils.getTopWindow(this.win);
+  },
+
+  get topDoc() {
+    return this.topWindow.document;
+  },
+
+  /**
+   * Shortcut to the document containing the toolbox UI
+   */
+  get doc() {
+    return this.win.document;
+  },
+
+  /**
+   * Get the toggled state of the split console
+   */
+  get splitConsole() {
+    return this._splitConsole;
+  },
+
+  /**
+   * Get the focused state of the split console
+   */
+  isSplitConsoleFocused() {
+    if (!this._splitConsole) {
+      return false;
+    }
+    const focusedWin = Services.focus.focusedWindow;
+    return (
+      focusedWin &&
+      focusedWin ===
+        this.doc.querySelector("#toolbox-panel-iframe-webconsole").contentWindow
+    );
+  },
+
+  get isBrowserToolbox() {
+    return this.hostType === Toolbox.HostType.BROWSERTOOLBOX;
+  },
+
+  get isMultiProcessBrowserToolbox() {
+    return this.isBrowserToolbox;
+  },
+
+  /**
+   * Set a given target as selected (which may impact the console evaluation context selector).
+   *
+   * @param {String} targetActorID: The actorID of the target we want to select.
+   */
+  selectTarget(targetActorID) {
+    if (this.getSelectedTargetFront()?.actorID !== targetActorID) {
+      // The selected target is managed by the TargetCommand's store.
+      // So dispatch this action against that other store.
+      this.commands.targetCommand.store.dispatch(selectTarget(targetActorID));
+    }
+  },
+
+  /**
+   * @returns {ThreadFront|null} The selected thread front, or null if there is none.
+   */
+  getSelectedTargetFront() {
+    // The selected target is managed by the TargetCommand's store.
+    // So pull the state from that other store.
+    const selectedTarget = getSelectedTarget(
+      this.commands.targetCommand.store.getState()
+    );
+    if (!selectedTarget) {
+      return null;
+    }
+
+    return this.commands.client.getFrontByID(selectedTarget.actorID);
+  },
+
+  /**
+   * For now, the debugger isn't hooked to TargetCommand's store
+   * to display its thread list. So manually forward target selection change
+   * to the debugger via a dedicated action
+   */
+  _onTargetCommandStateChange(state, oldState) {
+    if (getSelectedTarget(state) !== getSelectedTarget(oldState)) {
+      const dbg = this.getPanel("jsdebugger");
+      if (!dbg) {
+        return;
+      }
+
+      const threadActorID = getSelectedTarget(state)?.threadFront?.actorID;
+      if (!threadActorID) {
+        return;
+      }
+
+      dbg.selectThread(threadActorID);
+    }
+  },
+
+  /**
+   * Called on each new THREAD_STATE resource
+   *
+   * @param {Object} resource The THREAD_STATE resource
+   */
+  _onThreadStateChanged(resource) {
+    if (resource.state == "paused") {
+      this._pauseToolbox(resource.why.type);
+    } else if (resource.state == "resumed") {
+      this._resumeToolbox();
+    }
+  },
+
+  /**
+   * Be careful, this method is synchronous, but highlightTool, raise, selectTool
+   * are all async.
+   */
+  _pauseToolbox(reason) {
+    // Suppress interrupted events by default because the thread is
+    // paused/resumed a lot for various actions.
+    if (reason === "interrupted") {
+      return;
+    }
+
+    this.highlightTool("jsdebugger");
+
+    if (
+      reason === "debuggerStatement" ||
+      reason === "mutationBreakpoint" ||
+      reason === "eventBreakpoint" ||
+      reason === "breakpoint" ||
+      reason === "exception" ||
+      reason === "resumeLimit" ||
+      reason === "XHR"
+    ) {
+      this.raise();
+      this.selectTool("jsdebugger", reason);
+      // Each Target/Thread can be paused only once at a time,
+      // so, for each pause, we should have a related resumed event.
+      // But we may have multiple targets paused at the same time
+      this._pausedTargets++;
+      this.emit("toolbox-paused");
+    }
+  },
+
+  _resumeToolbox() {
+    if (this.isHighlighted("jsdebugger")) {
+      this._pausedTargets--;
+      if (this._pausedTargets == 0) {
+        this.emit("toolbox-resumed");
+        this.unhighlightTool("jsdebugger");
+      }
+    }
+  },
+
+  /**
+   * This method will be called for the top-level target, as well as any potential
+   * additional targets we may care about.
+   */
+  async _onTargetAvailable({ targetFront, isTargetSwitching }) {
+    if (targetFront.isTopLevel) {
+      // Attach to a new top-level target.
+      // For now, register these event listeners only on the top level target
+      if (!targetFront.targetForm.ignoreSubFrames) {
+        targetFront.on("frame-update", this._updateFrames);
+      }
+      const consoleFront = await targetFront.getFront("console");
+      consoleFront.on("inspectObject", this._onInspectObject);
+    }
+
+    // Walker listeners allow to monitor DOM Mutation breakpoint updates.
+    // All targets should be monitored.
+    targetFront.watchFronts("inspector", async inspectorFront => {
+      registerWalkerListeners(this.store, inspectorFront.walker);
+    });
+
+    if (targetFront.isTopLevel && isTargetSwitching) {
+      // These methods expect the target to be attached, which is guaranteed by the time
+      // _onTargetAvailable is called by the targetCommand.
+      await this._listFrames();
+      // The target may have been destroyed while calling _listFrames if we navigate quickly
+      if (targetFront.isDestroyed()) {
+        return;
+      }
+    }
+
+    if (targetFront.targetForm.ignoreSubFrames) {
+      this._updateFrames({
+        frames: [
+          {
+            id: targetFront.actorID,
+            targetFront,
+            url: targetFront.url,
+            title: targetFront.title,
+            isTopLevel: targetFront.isTopLevel,
+          },
+        ],
+      });
+    }
+
+    // If a new popup is debugged, automagically switch the toolbox to become
+    // an independant window so that we can easily keep debugging the new tab.
+    // Only do that if that's not the current top level, otherwise it means
+    // we opened a toolbox dedicated to the popup.
+    if (
+      targetFront.targetForm.isPopup &&
+      !targetFront.isTopLevel &&
+      this._descriptorFront.isLocalTab
+    ) {
+      await this.switchHostToTab(targetFront.targetForm.browsingContextID);
+    }
+  },
+
+  async _onTargetSelected({ targetFront }) {
+    this._updateFrames({ selected: targetFront.actorID });
+    this.selectTarget(targetFront.actorID);
+  },
+
+  _onTargetDestroyed({ targetFront }) {
+    if (targetFront.isTopLevel) {
+      const consoleFront = targetFront.getCachedFront("console");
+      // If the target has already been destroyed, its console front will
+      // also already be destroyed and so we won't be able to retrieve it.
+      // Nor is it important to clear its listener as fronts automatically clears
+      // all their listeners on destroy.
+      if (consoleFront) {
+        consoleFront.off("inspectObject", this._onInspectObject);
+      }
+      targetFront.off("frame-update", this._updateFrames);
+    } else if (this.selection) {
+      this.selection.onTargetDestroyed(targetFront);
+    }
+
+    // When navigating the old (top level) target can get destroyed before the thread state changed
+    // event for the target is received, so it gets lost. This currently happens with bf-cache
+    // navigations when paused, so lets make sure we resumed if not.
+    //
+    // We should also resume if a paused non-top-level target is destroyed
+    if (targetFront.isTopLevel || targetFront.threadFront?.paused) {
+      this._resumeToolbox();
+    }
+
+    if (targetFront.targetForm.ignoreSubFrames) {
+      this._updateFrames({
+        frames: [
+          {
+            id: targetFront.actorID,
+            destroy: true,
+          },
+        ],
+      });
+    }
+  },
+
+  _onTargetThreadFrontResumeWrongOrder() {
+    const box = this.getNotificationBox();
+    box.appendNotification(
+      L10N.getStr("toolbox.resumeOrderWarning"),
+      "wrong-resume-order",
+      "",
+      box.PRIORITY_WARNING_HIGH
+    );
+  },
+
+  /**
+   * Open the toolbox
+   */
+  open() {
+    return async function () {
+      // Kick off async loading the Fluent bundles.
+      const fluentL10n = new FluentL10n();
+      const fluentInitPromise = fluentL10n.init([
+        "devtools/client/toolbox.ftl",
+      ]);
+
+      const isToolboxURL = this.win.location.href.startsWith(this._URL);
+      if (isToolboxURL) {
+        // Update the URL so that onceDOMReady watch for the right url.
+        this._URL = this.win.location.href;
+      }
+
+      const domReady = new Promise(resolve => {
+        DOMHelpers.onceDOMReady(
+          this.win,
+          () => {
+            resolve();
+          },
+          this._URL
+        );
+      });
+
+      this.commands.targetCommand.on(
+        "target-thread-wrong-order-on-resume",
+        this._onTargetThreadFrontResumeWrongOrder.bind(this)
+      );
+      registerStoreObserver(
+        this.commands.targetCommand.store,
+        this._onTargetCommandStateChange.bind(this)
+      );
+
+      // Bug 1709063: Use commands.resourceCommand instead of toolbox.resourceCommand
+      this.resourceCommand = this.commands.resourceCommand;
+
+      // Optimization: fire up a few other things before waiting on
+      // the iframe being ready (makes startup faster)
+      await this.commands.targetCommand.startListening();
+
+      // Lets get the current thread settings from the prefs and
+      // update the threadConfigurationActor which should manage
+      // updating the current threads.
+      const options = await getThreadOptions();
+      await this.commands.threadConfigurationCommand.updateConfiguration(
+        options
+      );
+
+      // This needs to be done before watching for resources so console messages can be
+      // custom formatted right away.
+      await this._applyCustomFormatterSetting();
+
+      // The targetCommand is created right before this code.
+      // It means that this call to watchTargets is the first,
+      // and we are registering the first target listener, which means
+      // Toolbox._onTargetAvailable will be called first, before any other
+      // onTargetAvailable listener that might be registered on targetCommand.
+      await this.commands.targetCommand.watchTargets({
+        types: this.commands.targetCommand.ALL_TYPES,
+        onAvailable: this._onTargetAvailable,
+        onSelected: this._onTargetSelected,
+        onDestroyed: this._onTargetDestroyed,
+      });
+
+      const watchedResources = [
+        // Watch for console API messages, errors and network events in order to populate
+        // the error count icon in the toolbox.
+        this.resourceCommand.TYPES.CONSOLE_MESSAGE,
+        this.resourceCommand.TYPES.ERROR_MESSAGE,
+        this.resourceCommand.TYPES.DOCUMENT_EVENT,
+        this.resourceCommand.TYPES.THREAD_STATE,
+      ];
+
+      if (!this.isBrowserToolbox) {
+        // Independently of watching network event resources for the error count icon,
+        // we need to start tracking network activity on toolbox open for targets such
+        // as tabs, in order to ensure there is always at least one listener existing
+        // for network events across the lifetime of the various panels, so stopping
+        // the resource command from clearing out its cache of network event resources.
+        watchedResources.push(this.resourceCommand.TYPES.NETWORK_EVENT);
+      }
+
+      const onResourcesWatched = this.resourceCommand.watchResources(
+        watchedResources,
+        {
+          onAvailable: this._onResourceAvailable,
+          onUpdated: this._onResourceUpdated,
+        }
+      );
+
+      await domReady;
+
+      this.browserRequire = BrowserLoader({
+        window: this.win,
+        useOnlyShared: true,
+      }).require;
+
+      this.isReady = true;
+
+      const framesPromise = this._listFrames();
+
+      Services.prefs.addObserver(
+        "devtools.cache.disabled",
+        this._applyCacheSettings
+      );
+      Services.prefs.addObserver(
+        "devtools.custom-formatters.enabled",
+        this._applyCustomFormatterSetting
+      );
+      Services.prefs.addObserver(
+        "devtools.serviceWorkers.testing.enabled",
+        this._applyServiceWorkersTestingSettings
+      );
+      Services.prefs.addObserver(
+        "devtools.inspector.simple-highlighters-reduced-motion",
+        this._applySimpleHighlightersSettings
+      );
+      Services.prefs.addObserver(
+        BROWSERTOOLBOX_SCOPE_PREF,
+        this._refreshHostTitle
+      );
+
+      // Get the DOM element to mount the ToolboxController to.
+      this._componentMount = this.doc.getElementById("toolbox-toolbar-mount");
+
+      await fluentInitPromise;
+
+      // Mount the ToolboxController component and update all its state
+      // that can be updated synchronousl
+      this._mountReactComponent(fluentL10n.getBundles());
+      this._buildDockOptions();
+      this._buildInitialPanelDefinitions();
+      this._setDebugTargetData();
+
+      // Forward configuration flags to the DevTools server.
+      this._applyCacheSettings();
+      this._applyServiceWorkersTestingSettings();
+      this._applySimpleHighlightersSettings();
+
+      this._addWindowListeners();
+      this._addChromeEventHandlerEvents();
+
+      // Get the tab bar of the ToolboxController to attach the "keypress" event listener to.
+      this._tabBar = this.doc.querySelector(".devtools-tabbar");
+      this._tabBar.addEventListener("keypress", this._onToolbarArrowKeypress);
+
+      this._componentMount.setAttribute(
+        "aria-label",
+        L10N.getStr("toolbox.label")
+      );
+
+      this.webconsolePanel = this.doc.querySelector(
+        "#toolbox-panel-webconsole"
+      );
+      this.webconsolePanel.style.height =
+        Services.prefs.getIntPref(SPLITCONSOLE_HEIGHT_PREF) + "px";
+      this.webconsolePanel.addEventListener(
+        "resize",
+        this._saveSplitConsoleHeight
+      );
+
+      this._buildButtons();
+
+      this._pingTelemetry();
+
+      // The isToolSupported check needs to happen after the target is
+      // remoted, otherwise we could have done it in the toolbox constructor
+      // (bug 1072764).
+      const toolDef = gDevTools.getToolDefinition(this._defaultToolId);
+      if (!toolDef || !toolDef.isToolSupported(this)) {
+        this._defaultToolId = "webconsole";
+      }
+
+      // Update all ToolboxController state that can only be done asynchronously
+      await this._setInitialMeatballState();
+
+      // Start rendering the toolbox toolbar before selecting the tool, as the tools
+      // can take a few hundred milliseconds seconds to start up.
+      //
+      // Delay React rendering as Toolbox.open is synchronous.
+      // Even if this involve promises, it is synchronous. Toolbox.open already loads
+      // react modules and freeze the event loop for a significant time.
+      // requestIdleCallback allows releasing it to allow user events to be processed.
+      // Use 16ms maximum delay to allow one frame to be rendered at 60FPS
+      // (1000ms/60FPS=16ms)
+      this.win.requestIdleCallback(
+        () => {
+          this.component.setCanRender();
+        },
+        { timeout: 16 }
+      );
+
+      await this.selectTool(this._defaultToolId, "initial_panel");
+
+      // Wait until the original tool is selected so that the split
+      // console input will receive focus.
+      let splitConsolePromise = Promise.resolve();
+      if (Services.prefs.getBoolPref(SPLITCONSOLE_ENABLED_PREF)) {
+        splitConsolePromise = this.openSplitConsole();
+        this.telemetry.addEventProperty(
+          this.topWindow,
+          "open",
+          "tools",
+          null,
+          "splitconsole",
+          true
+        );
+      } else {
+        this.telemetry.addEventProperty(
+          this.topWindow,
+          "open",
+          "tools",
+          null,
+          "splitconsole",
+          false
+        );
+      }
+
+      await Promise.all([
+        splitConsolePromise,
+        framesPromise,
+        onResourcesWatched,
+      ]);
+
+      // We do not expect the focus to be restored when using about:debugging toolboxes
+      // Otherwise, when reloading the toolbox, the debugged tab will be focused.
+      if (this.hostType !== Toolbox.HostType.PAGE) {
+        // Request the actor to restore the focus to the content page once the
+        // target is detached. This typically happens when the console closes.
+        // We restore the focus as it may have been stolen by the console input.
+        await this.commands.targetConfigurationCommand.updateConfiguration({
+          restoreFocus: true,
+        });
+      }
+
+      await this.initHarAutomation();
+
+      this.emit("ready");
+      this._resolveIsOpen();
+    }
+      .bind(this)()
+      .catch(e => {
+        console.error("Exception while opening the toolbox", String(e), e);
+        // While the exception stack is correctly printed in the Browser console when
+        // passing `e` to console.error, it is not on the stdout, so print it via dump.
+        dump(e.stack + "\n");
+      });
+  },
+
+  /**
+   * Retrieve the ChromeEventHandler associated to the toolbox frame.
+   * When DevTools are loaded in a content frame, this will return the containing chrome
+   * frame. Events from nested frames will bubble up to this chrome frame, which allows to
+   * listen to events from nested frames.
+   */
+  getChromeEventHandler() {
+    if (!this.win || !this.win.docShell) {
+      return null;
+    }
+    return this.win.docShell.chromeEventHandler;
+  },
+
+  /**
+   * Attach events on the chromeEventHandler for the current window. When loaded in a
+   * frame with type set to "content", events will not bubble across frames. The
+   * chromeEventHandler does not have this limitation and will catch all events triggered
+   * on any of the frames under the devtools document.
+   *
+   * Events relying on the chromeEventHandler need to be added and removed at specific
+   * moments in the lifecycle of the toolbox, so all the events relying on it should be
+   * grouped here.
+   */
+  _addChromeEventHandlerEvents() {
+    // win.docShell.chromeEventHandler might not be accessible anymore when removing the
+    // events, so we can't rely on a dynamic getter here.
+    // Keep a reference on the chromeEventHandler used to addEventListener to be sure we
+    // can remove the listeners afterwards.
+    this._chromeEventHandler = this.getChromeEventHandler();
+    if (!this._chromeEventHandler) {
+      return;
+    }
+
+    // Add shortcuts and window-host-shortcuts that use the ChromeEventHandler as target.
+    this._addShortcuts();
+    this._addWindowHostShortcuts();
+
+    this._chromeEventHandler.addEventListener(
+      "keypress",
+      this._splitConsoleOnKeypress
+    );
+    this._chromeEventHandler.addEventListener("focus", this._onFocus, true);
+    this._chromeEventHandler.addEventListener("blur", this._onBlur, true);
+    this._chromeEventHandler.addEventListener(
+      "contextmenu",
+      this._onContextMenu
+    );
+    this._chromeEventHandler.addEventListener("mousedown", this._onMouseDown);
+  },
+
+  _removeChromeEventHandlerEvents() {
+    if (!this._chromeEventHandler) {
+      return;
+    }
+
+    // Remove shortcuts and window-host-shortcuts that use the ChromeEventHandler as
+    // target.
+    this._removeShortcuts();
+    this._removeWindowHostShortcuts();
+
+    this._chromeEventHandler.removeEventListener(
+      "keypress",
+      this._splitConsoleOnKeypress
+    );
+    this._chromeEventHandler.removeEventListener("focus", this._onFocus, true);
+    this._chromeEventHandler.removeEventListener("focus", this._onBlur, true);
+    this._chromeEventHandler.removeEventListener(
+      "contextmenu",
+      this._onContextMenu
+    );
+    this._chromeEventHandler.removeEventListener(
+      "mousedown",
+      this._onMouseDown
+    );
+
+    this._chromeEventHandler = null;
+  },
+
+  _addShortcuts() {
+    // Create shortcuts instance for the toolbox
+    if (!this.shortcuts) {
+      this.shortcuts = new KeyShortcuts({
+        window: this.doc.defaultView,
+        // The toolbox key shortcuts should be triggered from any frame in DevTools.
+        // Use the chromeEventHandler as the target to catch events from all frames.
+        target: this.getChromeEventHandler(),
+      });
+    }
+
+    // Listen for the shortcut key to show the frame list
+    this.shortcuts.on(L10N.getStr("toolbox.showFrames.key"), event => {
+      if (event.target.id === "command-button-frames") {
+        event.target.click();
+      }
+    });
+
+    // Listen for tool navigation shortcuts.
+    this.shortcuts.on(L10N.getStr("toolbox.nextTool.key"), event => {
+      this.selectNextTool();
+      event.preventDefault();
+    });
+    this.shortcuts.on(L10N.getStr("toolbox.previousTool.key"), event => {
+      this.selectPreviousTool();
+      event.preventDefault();
+    });
+    this.shortcuts.on(L10N.getStr("toolbox.toggleHost.key"), event => {
+      this.switchToPreviousHost();
+      event.preventDefault();
+    });
+
+    // List for Help/Settings key.
+    this.shortcuts.on(L10N.getStr("toolbox.help.key"), this.toggleOptions);
+
+    if (!this.isBrowserToolbox) {
+      // Listen for Reload shortcuts
+      [
+        ["reload", false],
+        ["reload2", false],
+        ["forceReload", true],
+        ["forceReload2", true],
+      ].forEach(([id, force]) => {
+        const key = L10N.getStr("toolbox." + id + ".key");
+        this.shortcuts.on(key, event => {
+          this.commands.targetCommand.reloadTopLevelTarget(force);
+
+          // Prevent Firefox shortcuts from reloading the page
+          event.preventDefault();
+        });
+      });
+    }
+
+    // Add zoom-related shortcuts.
+    if (this.hostType != Toolbox.HostType.PAGE) {
+      // When the toolbox is rendered in a tab (ie host type is PAGE), the
+      // zoom should be handled by the default browser shortcuts.
+      ZoomKeys.register(this.win, this.shortcuts);
+    }
+  },
+
+  _removeShortcuts() {
+    if (this.shortcuts) {
+      this.shortcuts.destroy();
+      this.shortcuts = null;
+    }
+  },
+
+  /**
+   * Adds the keys and commands to the Toolbox Window in window mode.
+   */
+  _addWindowHostShortcuts() {
+    if (this.hostType != Toolbox.HostType.WINDOW) {
+      // Those shortcuts are only valid for host type WINDOW.
+      return;
+    }
+
+    if (!this._windowHostShortcuts) {
+      this._windowHostShortcuts = new KeyShortcuts({
+        window: this.win,
+        // The window host key shortcuts should be triggered from any frame in DevTools.
+        // Use the chromeEventHandler as the target to catch events from all frames.
+        target: this.getChromeEventHandler(),
+      });
+    }
+
+    const shortcuts = this._windowHostShortcuts;
+
+    for (const item of Startup.KeyShortcuts) {
+      const { id, toolId, shortcut, modifiers } = item;
+      const electronKey = KeyShortcuts.parseXulKey(modifiers, shortcut);
+
+      if (id == "browserConsole") {
+        // Add key for toggling the browser console from the detached window
+        shortcuts.on(electronKey, () => {
+          BrowserConsoleManager.toggleBrowserConsole();
+        });
+      } else if (toolId) {
+        // KeyShortcuts contain tool-specific and global key shortcuts,
+        // here we only need to copy shortcut specific to each tool.
+        shortcuts.on(electronKey, () => {
+          this.selectTool(toolId, "key_shortcut").then(() =>
+            this.fireCustomKey(toolId)
+          );
+        });
+      }
+    }
+
+    // CmdOrCtrl+W is registered only when the toolbox is running in
+    // detached window. In the other case the entire browser tab
+    // is closed when the user uses this shortcut.
+    shortcuts.on(L10N.getStr("toolbox.closeToolbox.key"), this.closeToolbox);
+
+    // The others are only registered in window host type as for other hosts,
+    // these keys are already registered by devtools-startup.js
+    shortcuts.on(
+      L10N.getStr("toolbox.toggleToolboxF12.key"),
+      this.closeToolbox
+    );
+    if (lazy.AppConstants.platform == "macosx") {
+      shortcuts.on(
+        L10N.getStr("toolbox.toggleToolboxOSX.key"),
+        this.closeToolbox
+      );
+    } else {
+      shortcuts.on(L10N.getStr("toolbox.toggleToolbox.key"), this.closeToolbox);
+    }
+  },
+
+  _removeWindowHostShortcuts() {
+    if (this._windowHostShortcuts) {
+      this._windowHostShortcuts.destroy();
+      this._windowHostShortcuts = null;
+    }
+  },
+
+  _onContextMenu(e) {
+    // Handle context menu events in standard input elements: <input> and <textarea>.
+    // Also support for custom input elements using .devtools-input class
+    // (e.g. CodeMirror instances).
+    const isInInput =
+      e.originalTarget.closest("input[type=text]") ||
+      e.originalTarget.closest("input[type=search]") ||
+      e.originalTarget.closest("input:not([type])") ||
+      e.originalTarget.closest(".devtools-input") ||
+      e.originalTarget.closest("textarea");
+
+    const doc = e.originalTarget.ownerDocument;
+    const isHTMLPanel = doc.documentElement.namespaceURI === HTML_NS;
+
+    if (
+      // Context-menu events on input elements will use a custom context menu.
+      isInInput ||
+      // Context-menu events from HTML panels should not trigger the default
+      // browser context menu for HTML documents.
+      isHTMLPanel
+    ) {
+      e.stopPropagation();
+      e.preventDefault();
+    }
+
+    if (isInInput) {
+      this.openTextBoxContextMenu(e.screenX, e.screenY);
+    }
+  },
+
+  _onMouseDown(e) {
+    const isMiddleClick = e.button === 1;
+    if (isMiddleClick) {
+      // Middle clicks will trigger the scroll lock feature to turn on.
+      // When the DevTools toolbox was running in an <iframe>, this behavior was
+      // disabled by default. When running in a <browser> element, we now need
+      // to catch and preventDefault() on those events.
+      e.preventDefault();
+    }
+  },
+
+  _getDebugTargetData() {
+    const url = new URL(this.win.location);
+    const remoteId = url.searchParams.get("remoteId");
+    const runtimeInfo = remoteClientManager.getRuntimeInfoByRemoteId(remoteId);
+    const connectionType =
+      remoteClientManager.getConnectionTypeByRemoteId(remoteId);
+
+    return {
+      connectionType,
+      runtimeInfo,
+      descriptorType: this._descriptorFront.descriptorType,
+    };
+  },
+
+  isDebugTargetFenix() {
+    return this._getDebugTargetData()?.runtimeInfo?.isFenix;
+  },
+
+  /**
+   * loading React modules when needed (to avoid performance penalties
+   * during Firefox start up time).
+   */
+  get React() {
+    return this.browserRequire("devtools/client/shared/vendor/react");
+  },
+
+  get ReactDOM() {
+    return this.browserRequire("devtools/client/shared/vendor/react-dom");
+  },
+
+  get ReactRedux() {
+    return this.browserRequire("devtools/client/shared/vendor/react-redux");
+  },
+
+  get ToolboxController() {
+    return this.browserRequire(
+      "devtools/client/framework/components/ToolboxController"
+    );
+  },
+
+  /**
+   * A common access point for the client-side mapping service for source maps that
+   * any panel can use.  This is a "low-level" API that connects to
+   * the source map worker.
+   */
+  get sourceMapLoader() {
+    if (this._sourceMapLoader) {
+      return this._sourceMapLoader;
+    }
+    this._sourceMapLoader = new SourceMapLoader();
+    this._sourceMapLoader.on("source-map-error", message =>
+      this.target.logWarningInPage(message, "source map")
+    );
+    return this._sourceMapLoader;
+  },
+
+  /**
+   * Expose the "Parser" debugger worker to both webconsole and debugger.
+   *
+   * Note that the Browser Console will also self-instantiate it as it doesn't involve a toolbox.
+   */
+  get parserWorker() {
+    if (this._parserWorker) {
+      return this._parserWorker;
+    }
+
+    const {
+      ParserDispatcher,
+    } = require("resource://devtools/client/debugger/src/workers/parser/index.js");
+
+    this._parserWorker = new ParserDispatcher();
+    return this._parserWorker;
+  },
+
+  /**
+   * Clients wishing to use source maps but that want the toolbox to
+   * track the source and style sheet actor mapping can use this
+   * source map service.  This is a higher-level service than the one
+   * returned by |sourceMapLoader|, in that it automatically tracks
+   * source and style sheet actor IDs.
+   */
+  get sourceMapURLService() {
+    if (this._sourceMapURLService) {
+      return this._sourceMapURLService;
+    }
+    this._sourceMapURLService = new SourceMapURLService(
+      this.commands,
+      this.sourceMapLoader
+    );
+    return this._sourceMapURLService;
+  },
+
+  // Return HostType id for telemetry
+  _getTelemetryHostId() {
+    switch (this.hostType) {
+      case Toolbox.HostType.BOTTOM:
+        return 0;
+      case Toolbox.HostType.RIGHT:
+        return 1;
+      case Toolbox.HostType.WINDOW:
+        return 2;
+      case Toolbox.HostType.BROWSERTOOLBOX:
+        return 3;
+      case Toolbox.HostType.LEFT:
+        return 4;
+      case Toolbox.HostType.PAGE:
+        return 5;
+      default:
+        return 9;
+    }
+  },
+
+  // Return HostType string for telemetry
+  _getTelemetryHostString() {
+    switch (this.hostType) {
+      case Toolbox.HostType.BOTTOM:
+        return "bottom";
+      case Toolbox.HostType.LEFT:
+        return "left";
+      case Toolbox.HostType.RIGHT:
+        return "right";
+      case Toolbox.HostType.WINDOW:
+        return "window";
+      case Toolbox.HostType.PAGE:
+        return "page";
+      case Toolbox.HostType.BROWSERTOOLBOX:
+        return "other";
+      default:
+        return "bottom";
+    }
+  },
+
+  _pingTelemetry() {
+    Services.prefs.setBoolPref("devtools.everOpened", true);
+    this.telemetry.toolOpened("toolbox", this);
+
+    this.telemetry
+      .getHistogramById(HOST_HISTOGRAM)
+      .add(this._getTelemetryHostId());
+
+    // Log current theme. The question we want to answer is:
+    // "What proportion of users use which themes?"
+    const currentTheme = Services.prefs.getCharPref("devtools.theme");
+    this.telemetry.keyedScalarAdd(CURRENT_THEME_SCALAR, currentTheme, 1);
+
+    const browserWin = this.topWindow;
+    this.telemetry.preparePendingEvent(browserWin, "open", "tools", null, [
+      "entrypoint",
+      "first_panel",
+      "host",
+      "shortcut",
+      "splitconsole",
+      "width",
+    ]);
+    this.telemetry.addEventProperty(
+      browserWin,
+      "open",
+      "tools",
+      null,
+      "host",
+      this._getTelemetryHostString()
+    );
+  },
+
+  /**
+   * Create a simple object to store the state of a toolbox button. The checked state of
+   * a button can be updated arbitrarily outside of the scope of the toolbar and its
+   * controllers. In order to simplify this interaction this object emits an
+   * "updatechecked" event any time the isChecked value is updated, allowing any consuming
+   * components to listen and respond to updates.
+   *
+   * @param {Object} options:
+   *
+   * @property {String} id - The id of the button or command.
+   * @property {String} className - An optional additional className for the button.
+   * @property {String} description - The value that will display as a tooltip and in
+   *                    the options panel for enabling/disabling.
+   * @property {Boolean} disabled - An optional disabled state for the button.
+   * @property {Function} onClick - The function to run when the button is activated by
+   *                      click or keyboard shortcut. First argument will be the 'click'
+   *                      event, and second argument is the toolbox instance.
+   * @property {Boolean} isInStartContainer - Buttons can either be placed at the start
+   *                     of the toolbar, or at the end.
+   * @property {Function} setup - Function run immediately to listen for events changing
+   *                      whenever the button is checked or unchecked. The toolbox object
+   *                      is passed as first argument and a callback is passed as second
+   *                       argument, to be called whenever the checked state changes.
+   * @property {Function} teardown - Function run on toolbox close to let a chance to
+   *                      unregister listeners set when `setup` was called and avoid
+   *                      memory leaks. The same arguments than `setup` function are
+   *                      passed to `teardown`.
+   * @property {Function} isToolSupported - Function to automatically enable/disable
+   *                      the button based on the toolbox. If the toolbox don't support
+   *                      the button feature, this method should return false.
+   * @property {Function} isCurrentlyVisible - Function to automatically
+   *                      hide/show the button based on current state.
+   * @property {Function} isChecked - Optional function called to known if the button
+   *                      is toggled or not. The function should return true when
+   *                      the button should be displayed as toggled on.
+   */
+  _createButtonState(options) {
+    let isCheckedValue = false;
+    const {
+      id,
+      className,
+      description,
+      disabled,
+      onClick,
+      isInStartContainer,
+      setup,
+      teardown,
+      isToolSupported,
+      isCurrentlyVisible,
+      isChecked,
+      onKeyDown,
+      experimentalURL,
+    } = options;
+    const toolbox = this;
+    const button = {
+      id,
+      className,
+      description,
+      disabled,
+      async onClick(event) {
+        if (typeof onClick == "function") {
+          await onClick(event, toolbox);
+          button.emit("updatechecked");
+        }
+      },
+      onKeyDown(event) {
+        if (typeof onKeyDown == "function") {
+          onKeyDown(event, toolbox);
+        }
+      },
+      isToolSupported,
+      isCurrentlyVisible,
+      get isChecked() {
+        if (typeof isChecked == "function") {
+          return isChecked(toolbox);
+        }
+        return isCheckedValue;
+      },
+      set isChecked(value) {
+        // Note that if options.isChecked is given, this is ignored
+        isCheckedValue = value;
+        this.emit("updatechecked");
+      },
+      // The preference for having this button visible.
+      visibilityswitch: `devtools.${id}.enabled`,
+      // The toolbar has a container at the start and end of the toolbar for
+      // holding buttons. By default the buttons are placed in the end container.
+      isInStartContainer: !!isInStartContainer,
+      experimentalURL,
+    };
+    if (typeof setup == "function") {
+      const onChange = () => {
+        button.emit("updatechecked");
+      };
+      setup(this, onChange);
+      // Save a reference to the cleanup method that will unregister the onChange
+      // callback. Immediately bind the function argument so that we don't have to
+      // also save a reference to them.
+      button.teardown = teardown.bind(options, this, onChange);
+    }
+    button.isVisible = this._commandIsVisible(button);
+
+    EventEmitter.decorate(button);
+
+    return button;
+  },
+
+  _splitConsoleOnKeypress(e) {
+    if (e.keyCode === KeyCodes.DOM_VK_ESCAPE) {
+      this.toggleSplitConsole();
+      // If the debugger is paused, don't let the ESC key stop any pending navigation.
+      // If the host is page, don't let the ESC stop the load of the webconsole frame.
+      if (
+        this.threadFront.state == "paused" ||
+        this.hostType === Toolbox.HostType.PAGE
+      ) {
+        e.preventDefault();
+      }
+    }
+  },
+
+  /**
+   * Add a shortcut key that should work when a split console
+   * has focus to the toolbox.
+   *
+   * @param {String} key
+   *        The electron key shortcut.
+   * @param {Function} handler
+   *        The callback that should be called when the provided key shortcut is pressed.
+   * @param {String} whichTool
+   *        The tool the key belongs to. The corresponding handler will only be triggered
+   *        if this tool is active.
+   */
+  useKeyWithSplitConsole(key, handler, whichTool) {
+    this.shortcuts.on(key, event => {
+      if (this.currentToolId === whichTool && this.isSplitConsoleFocused()) {
+        handler();
+        event.preventDefault();
+      }
+    });
+  },
+
+  _addWindowListeners() {
+    this.win.addEventListener("unload", this.destroy);
+    this.win.addEventListener("message", this._onBrowserMessage, true);
+  },
+
+  _removeWindowListeners() {
+    // The host iframe's contentDocument may already be gone.
+    if (this.win) {
+      this.win.removeEventListener("unload", this.destroy);
+      this.win.removeEventListener("message", this._onBrowserMessage, true);
+    }
+  },
+
+  // Called whenever the chrome send a message
+  _onBrowserMessage(event) {
+    if (event.data?.name === "switched-host") {
+      this._onSwitchedHost(event.data);
+    }
+    if (event.data?.name === "switched-host-to-tab") {
+      this._onSwitchedHostToTab(event.data.browsingContextID);
+    }
+    if (event.data?.name === "host-raised") {
+      this.emit("host-raised");
+    }
+  },
+
+  _saveSplitConsoleHeight() {
+    const height = parseInt(this.webconsolePanel.style.height, 10);
+    if (!isNaN(height)) {
+      Services.prefs.setIntPref(SPLITCONSOLE_HEIGHT_PREF, height);
+    }
+  },
+
+  /**
+   * Make sure that the console is showing up properly based on all the
+   * possible conditions.
+   *   1) If the console tab is selected, then regardless of split state
+   *      it should take up the full height of the deck, and we should
+   *      hide the deck and splitter.
+   *   2) If the console tab is not selected and it is split, then we should
+   *      show the splitter, deck, and console.
+   *   3) If the console tab is not selected and it is *not* split,
+   *      then we should hide the console and splitter, and show the deck
+   *      at full height.
+   */
+  _refreshConsoleDisplay() {
+    const deck = this.doc.getElementById("toolbox-deck");
+    const webconsolePanel = this.webconsolePanel;
+    const splitter = this.doc.getElementById("toolbox-console-splitter");
+    const openedConsolePanel = this.currentToolId === "webconsole";
+
+    if (openedConsolePanel) {
+      deck.collapsed = true;
+      deck.removeAttribute("expanded");
+      splitter.hidden = true;
+      webconsolePanel.collapsed = false;
+      webconsolePanel.setAttribute("expanded", "");
+    } else {
+      deck.collapsed = false;
+      deck.toggleAttribute("expanded", !this.splitConsole);
+      splitter.hidden = !this.splitConsole;
+      webconsolePanel.collapsed = !this.splitConsole;
+      webconsolePanel.removeAttribute("expanded");
+    }
+  },
+
+  /**
+   * Handle any custom key events.  Returns true if there was a custom key
+   * binding run.
+   * @param {string} toolId Which tool to run the command on (skip if not
+   * current)
+   */
+  fireCustomKey(toolId) {
+    const toolDefinition = gDevTools.getToolDefinition(toolId);
+
+    if (
+      toolDefinition.onkey &&
+      (this.currentToolId === toolId ||
+        (toolId == "webconsole" && this.splitConsole))
+    ) {
+      toolDefinition.onkey(this.getCurrentPanel(), this);
+    }
+  },
+
+  /**
+   * Build the notification box as soon as needed.
+   */
+  get notificationBox() {
+    if (!this._notificationBox) {
+      let { NotificationBox, PriorityLevels } = this.browserRequire(
+        "devtools/client/shared/components/NotificationBox"
+      );
+
+      NotificationBox = this.React.createFactory(NotificationBox);
+
+      // Render NotificationBox and assign priority levels to it.
+      const box = this.doc.getElementById("toolbox-notificationbox");
+      this._notificationBox = Object.assign(
+        this.ReactDOM.render(NotificationBox({}), box),
+        PriorityLevels
+      );
+    }
+    return this._notificationBox;
+  },
+
+  /**
+   * Build the options for changing hosts. Called every time
+   * the host changes.
+   */
+  _buildDockOptions() {
+    if (!this._descriptorFront.isLocalTab) {
+      this.component.setDockOptionsEnabled(false);
+      this.component.setCanCloseToolbox(false);
+      return;
+    }
+
+    this.component.setDockOptionsEnabled(true);
+    this.component.setCanCloseToolbox(
+      this.hostType !== Toolbox.HostType.WINDOW
+    );
+
+    const hostTypes = [];
+    for (const type in Toolbox.HostType) {
+      const position = Toolbox.HostType[type];
+      if (
+        position == Toolbox.HostType.BROWSERTOOLBOX ||
+        position == Toolbox.HostType.PAGE
+      ) {
+        continue;
+      }
+
+      hostTypes.push({
+        position,
+        switchHost: this.switchHost.bind(this, position),
+      });
+    }
+
+    this.component.setCurrentHostType(this.hostType);
+    this.component.setHostTypes(hostTypes);
+  },
+
+  postMessage(msg) {
+    // We sometime try to send messages in middle of destroy(), where the
+    // toolbox iframe may already be detached.
+    if (!this._destroyer) {
+      // Toolbox document is still chrome and disallow identifying message
+      // origin via event.source as it is null. So use a custom id.
+      msg.frameId = this.frameId;
+      this.topWindow.postMessage(msg, "*");
+    }
+  },
+
+  /**
+   * This will fetch the panel definitions from the constants in definitions module
+   * and populate the state within the ToolboxController component.
+   */
+  async _buildInitialPanelDefinitions() {
+    // Get the initial list of tab definitions. This list can be amended at a later time
+    // by tools registering themselves.
+    const definitions = gDevTools.getToolDefinitionArray();
+    definitions.forEach(definition => this._buildPanelForTool(definition));
+
+    // Get the definitions that will only affect the main tab area.
+    this.panelDefinitions = definitions.filter(
+      definition =>
+        definition.isToolSupported(this) && definition.id !== "options"
+    );
+  },
+
+  async _setInitialMeatballState() {
+    let disableAutohide, pseudoLocale;
+    // Popup auto-hide disabling is only available in browser toolbox and webextension toolboxes.
+    if (
+      this.isBrowserToolbox ||
+      this._descriptorFront.isWebExtensionDescriptor
+    ) {
+      disableAutohide = await this._isDisableAutohideEnabled();
+    }
+    // Pseudo locale items are only displayed in the browser toolbox
+    if (this.isBrowserToolbox) {
+      pseudoLocale = await this.getPseudoLocale();
+    }
+    // Parallelize the asynchronous calls, so that the DOM is only updated once when
+    // updating the React components.
+    if (typeof disableAutohide == "boolean") {
+      this.component.setDisableAutohide(disableAutohide);
+    }
+    if (typeof pseudoLocale == "string") {
+      this.component.setPseudoLocale(pseudoLocale);
+    }
+    if (
+      this._descriptorFront.isWebExtensionDescriptor &&
+      this.hostType === Toolbox.HostType.WINDOW
+    ) {
+      const alwaysOnTop = Services.prefs.getBoolPref(
+        DEVTOOLS_ALWAYS_ON_TOP,
+        false
+      );
+      this.component.setAlwaysOnTop(alwaysOnTop);
+    }
+  },
+
+  /**
+   * Initiate ToolboxController React component and all it's properties. Do the initial render.
+   *
+   * @param {Object} fluentBundles
+   *        A FluentBundle instance used to display any localized text in the React component.
+   */
+  _mountReactComponent(fluentBundles) {
+    // Ensure the toolbar doesn't try to render until the tool is ready.
+    const element = this.React.createElement(this.ToolboxController, {
+      L10N,
+      fluentBundles,
+      currentToolId: this.currentToolId,
+      selectTool: this.selectTool,
+      toggleOptions: this.toggleOptions,
+      toggleSplitConsole: this.toggleSplitConsole,
+      toggleNoAutohide: this.toggleNoAutohide,
+      toggleAlwaysOnTop: this.toggleAlwaysOnTop,
+      disablePseudoLocale: this.disablePseudoLocale,
+      enableAccentedPseudoLocale: this.enableAccentedPseudoLocale,
+      enableBidiPseudoLocale: this.enableBidiPseudoLocale,
+      closeToolbox: this.closeToolbox,
+      focusButton: this._onToolbarFocus,
+      toolbox: this,
+      onTabsOrderUpdated: this._onTabsOrderUpdated,
+    });
+
+    this.component = this.ReactDOM.render(element, this._componentMount);
+  },
+
+  /**
+   * Reset tabindex attributes across all focusable elements inside the toolbar.
+   * Only have one element with tabindex=0 at a time to make sure that tabbing
+   * results in navigating away from the toolbar container.
+   * @param  {FocusEvent} event
+   */
+  _onToolbarFocus(id) {
+    this.component.setFocusedButton(id);
+  },
+
+  /**
+   * On left/right arrow press, attempt to move the focus inside the toolbar to
+   * the previous/next focusable element. This is not in the React component
+   * as it is difficult to coordinate between different component elements.
+   * The components are responsible for setting the correct tabindex value
+   * for if they are the focused element.
+   * @param  {KeyboardEvent} event
+   */
+  _onToolbarArrowKeypress(event) {
+    const { key, target, ctrlKey, shiftKey, altKey, metaKey } = event;
+
+    // If any of the modifier keys are pressed do not attempt navigation as it
+    // might conflict with global shortcuts (Bug 1327972).
+    if (ctrlKey || shiftKey || altKey || metaKey) {
+      return;
+    }
+
+    const buttons = [...this._tabBar.querySelectorAll("button")];
+    const curIndex = buttons.indexOf(target);
+
+    if (curIndex === -1) {
+      console.warn(
+        target +
+          " is not found among Developer Tools tab bar " +
+          "focusable elements."
+      );
+      return;
+    }
+
+    let newTarget;
+    const firstTabIndex = 0;
+    const lastTabIndex = buttons.length - 1;
+    const nextOrLastTabIndex = Math.min(lastTabIndex, curIndex + 1);
+    const previousOrFirstTabIndex = Math.max(firstTabIndex, curIndex - 1);
+    const ltr = this.direction === "ltr";
+
+    if (key === "ArrowLeft") {
+      // Do nothing if already at the beginning.
+      if (
+        (ltr && curIndex === firstTabIndex) ||
+        (!ltr && curIndex === lastTabIndex)
+      ) {
+        return;
+      }
+      newTarget = buttons[ltr ? previousOrFirstTabIndex : nextOrLastTabIndex];
+    } else if (key === "ArrowRight") {
+      // Do nothing if already at the end.
+      if (
+        (ltr && curIndex === lastTabIndex) ||
+        (!ltr && curIndex === firstTabIndex)
+      ) {
+        return;
+      }
+      newTarget = buttons[ltr ? nextOrLastTabIndex : previousOrFirstTabIndex];
+    } else {
+      return;
+    }
+
+    newTarget.focus();
+
+    event.preventDefault();
+    event.stopPropagation();
+  },
+
+  /**
+   * Add buttons to the UI as specified in devtools/client/definitions.js
+   */
+  _buildButtons() {
+    // Beyond the normal preference filtering
+    this.toolbarButtons = [
+      this._buildErrorCountButton(),
+      this._buildPickerButton(),
+      this._buildFrameButton(),
+    ];
+
+    ToolboxButtons.forEach(definition => {
+      const button = this._createButtonState(definition);
+      this.toolbarButtons.push(button);
+    });
+
+    this.component.setToolboxButtons(this.toolbarButtons);
+  },
+
+  /**
+   * Button to select a frame for the inspector to target.
+   */
+  _buildFrameButton() {
+    this.frameButton = this._createButtonState({
+      id: "command-button-frames",
+      description: L10N.getStr("toolbox.frames.tooltip"),
+      isToolSupported: toolbox => {
+        return toolbox.target.getTrait("frames");
+      },
+      isCurrentlyVisible: () => {
+        const hasFrames = this.frameMap.size > 1;
+        const isOnOptionsPanel = this.currentToolId === "options";
+        return hasFrames || isOnOptionsPanel;
+      },
+    });
+
+    return this.frameButton;
+  },
+
+  /**
+   * Button to display the number of errors.
+   */
+  _buildErrorCountButton() {
+    this.errorCountButton = this._createButtonState({
+      id: "command-button-errorcount",
+      isInStartContainer: false,
+      isToolSupported: toolbox => true,
+      description: L10N.getStr("toolbox.errorCountButton.description"),
+    });
+    // Use updateErrorCountButton to set some properties so we don't have to repeat
+    // the logic here.
+    this.updateErrorCountButton();
+
+    return this.errorCountButton;
+  },
+
+  /**
+   * Toggle the picker, but also decide whether or not the highlighter should
+   * focus the window. This is only desirable when the toolbox is mounted to the
+   * window. When devtools is free floating, then the target window should not
+   * pop in front of the viewer when the picker is clicked.
+   *
+   * Note: Toggle picker can be overwritten by panel other than the inspector to
+   * allow for custom picker behaviour.
+   */
+  async _onPickerClick() {
+    const focus =
+      this.hostType === Toolbox.HostType.BOTTOM ||
+      this.hostType === Toolbox.HostType.LEFT ||
+      this.hostType === Toolbox.HostType.RIGHT;
+    const currentPanel = this.getCurrentPanel();
+    if (currentPanel.togglePicker) {
+      currentPanel.togglePicker(focus);
+    } else {
+      this.nodePicker.togglePicker(focus);
+    }
+  },
+
+  /**
+   * If the picker is activated, then allow the Escape key to deactivate the
+   * functionality instead of the default behavior of toggling the console.
+   */
+  _onPickerKeypress(event) {
+    if (event.keyCode === KeyCodes.DOM_VK_ESCAPE) {
+      const currentPanel = this.getCurrentPanel();
+      if (currentPanel.cancelPicker) {
+        currentPanel.cancelPicker();
+      } else {
+        this.nodePicker.stop({ canceled: true });
+      }
+      // Stop the console from toggling.
+      event.stopImmediatePropagation();
+    }
+  },
+
+  async _onPickerStarting() {
+    if (this.isDestroying()) {
+      return;
+    }
+    this.tellRDMAboutPickerState(true, PICKER_TYPES.ELEMENT);
+    this.pickerButton.isChecked = true;
+    await this.selectTool("inspector", "inspect_dom");
+    // turn off color picker when node picker is starting
+    this.getPanel("inspector").hideEyeDropper();
+    this.on("select", this._onToolSelectedStopPicker);
+  },
+
+  async _onPickerStarted() {
+    this.doc.addEventListener("keypress", this._onPickerKeypress, true);
+  },
+
+  _onPickerStopped() {
+    if (this.isDestroying()) {
+      return;
+    }
+    this.tellRDMAboutPickerState(false, PICKER_TYPES.ELEMENT);
+    this.off("select", this._onToolSelectedStopPicker);
+    this.doc.removeEventListener("keypress", this._onPickerKeypress, true);
+    this.pickerButton.isChecked = false;
+  },
+
+  _onToolSelectedStopPicker() {
+    this.nodePicker.stop({ canceled: true });
+  },
+
+  /**
+   * When the picker is canceled, make sure the toolbox
+   * gets the focus.
+   */
+  _onPickerCanceled() {
+    if (this.hostType !== Toolbox.HostType.WINDOW) {
+      this.win.focus();
+    }
+  },
+
+  _onPickerPicked(nodeFront) {
+    this.selection.setNodeFront(nodeFront, { reason: "picker-node-picked" });
+  },
+
+  _onPickerPreviewed(nodeFront) {
+    this.selection.setNodeFront(nodeFront, { reason: "picker-node-previewed" });
+  },
+
+  /**
+   * RDM sometimes simulates touch events. For this to work correctly at all times, it
+   * needs to know when the picker is active or not.
+   * This method communicates with the RDM Manager if it exists.
+   *
+   * @param {Boolean} state
+   * @param {String} pickerType
+   *        One of devtools/shared/picker-constants
+   */
+  async tellRDMAboutPickerState(state, pickerType) {
+    const { localTab } = this.target;
+
+    if (!ResponsiveUIManager.isActiveForTab(localTab)) {
+      return;
+    }
+
+    const ui = ResponsiveUIManager.getResponsiveUIForTab(localTab);
+    await ui.responsiveFront.setElementPickerState(state, pickerType);
+  },
+
+  /**
+   * The element picker button enables the ability to select a DOM node by clicking
+   * it on the page.
+   */
+  _buildPickerButton() {
+    this.pickerButton = this._createButtonState({
+      id: "command-button-pick",
+      className: this._getPickerAdditionalClassName(),
+      description: this._getPickerTooltip(),
+      onClick: this._onPickerClick,
+      isInStartContainer: true,
+      isToolSupported: toolbox => {
+        return toolbox.target.getTrait("frames");
+      },
+    });
+
+    return this.pickerButton;
+  },
+
+  _getPickerAdditionalClassName() {
+    if (this.isDebugTargetFenix()) {
+      return "remote-fenix";
+    }
+    return null;
+  },
+
+  /**
+   * Get the tooltip for the element picker button.
+   * It has multiple possible keyboard shortcuts for macOS.
+   *
+   * @return {String}
+   */
+  _getPickerTooltip() {
+    let shortcut = L10N.getStr("toolbox.elementPicker.key");
+    shortcut = KeyShortcuts.parseElectronKey(this.win, shortcut);
+    shortcut = KeyShortcuts.stringify(shortcut);
+    const shortcutMac = L10N.getStr("toolbox.elementPicker.mac.key");
+    const isMac = Services.appinfo.OS === "Darwin";
+
+    let label;
+    if (this.isDebugTargetFenix()) {
+      label = isMac
+        ? "toolbox.androidElementPicker.mac.tooltip"
+        : "toolbox.androidElementPicker.tooltip";
+    } else {
+      label = isMac
+        ? "toolbox.elementPicker.mac.tooltip"
+        : "toolbox.elementPicker.tooltip";
+    }
+
+    return isMac
+      ? L10N.getFormatStr(label, shortcut, shortcutMac)
+      : L10N.getFormatStr(label, shortcut);
+  },
+
+  /**
+   * Apply the current cache setting from devtools.cache.disabled to this
+   * toolbox's tab.
+   */
+  async _applyCacheSettings() {
+    const pref = "devtools.cache.disabled";
+    const cacheDisabled = Services.prefs.getBoolPref(pref);
+
+    await this.commands.targetConfigurationCommand.updateConfiguration({
+      cacheDisabled,
+    });
+
+    // This event is only emitted for tests in order to know when to reload
+    if (flags.testing) {
+      this.emit("cache-reconfigured");
+    }
+  },
+
+  /**
+   * Apply the custom formatter setting (from `devtools.custom-formatters.enabled`) to this
+   * toolbox's tab.
+   */
+  async _applyCustomFormatterSetting() {
+    if (!this.commands) {
+      return;
+    }
+
+    const customFormatters =
+      Services.prefs.getBoolPref("devtools.custom-formatters", false) &&
+      Services.prefs.getBoolPref("devtools.custom-formatters.enabled", false);
+
+    await this.commands.targetConfigurationCommand.updateConfiguration({
+      customFormatters,
+    });
+
+    this.emitForTests("custom-formatters-reconfigured");
+  },
+
+  /**
+   * Apply the current service workers testing setting from
+   * devtools.serviceWorkers.testing.enabled to this toolbox's tab.
+   */
+  _applyServiceWorkersTestingSettings() {
+    const pref = "devtools.serviceWorkers.testing.enabled";
+    const serviceWorkersTestingEnabled = Services.prefs.getBoolPref(pref);
+    this.commands.targetConfigurationCommand.updateConfiguration({
+      serviceWorkersTestingEnabled,
+    });
+  },
+
+  /**
+   * Apply the current simple highlighters setting to this toolbox's tab.
+   */
+  _applySimpleHighlightersSettings() {
+    const useSimpleHighlightersForReducedMotion = Services.prefs.getBoolPref(
+      "devtools.inspector.simple-highlighters-reduced-motion",
+      false
+    );
+    this.commands.targetConfigurationCommand.updateConfiguration({
+      useSimpleHighlightersForReducedMotion,
+    });
+  },
+
+  /**
+   * Update the visibility of the buttons.
+   */
+  updateToolboxButtonsVisibility() {
+    this.toolbarButtons.forEach(button => {
+      button.isVisible = this._commandIsVisible(button);
+    });
+    this.component.setToolboxButtons(this.toolbarButtons);
+  },
+
+  /**
+   * Update the buttons.
+   */
+  updateToolboxButtons() {
+    const inspectorFront = this.target.getCachedFront("inspector");
+    // two of the buttons have highlighters that need to be cleared
+    // on will-navigate, otherwise we hold on to the stale highlighter
+    const hasHighlighters =
+      inspectorFront &&
+      (inspectorFront.hasHighlighter("RulersHighlighter") ||
+        inspectorFront.hasHighlighter("MeasuringToolHighlighter"));
+    if (hasHighlighters) {
+      inspectorFront.destroyHighlighters();
+      this.component.setToolboxButtons(this.toolbarButtons);
+    }
+  },
+
+  /**
+   * Visually update picker button.
+   * This function is called on every "select" event. Newly selected panel can
+   * update the visual state of the picker button such as disabled state,
+   * additional CSS classes (className), and tooltip (description).
+   */
+  updatePickerButton() {
+    const button = this.pickerButton;
+    const currentPanel = this.getCurrentPanel();
+
+    if (currentPanel?.updatePickerButton) {
+      currentPanel.updatePickerButton();
+    } else {
+      // If the current panel doesn't define a custom updatePickerButton,
+      // revert the button to its default state
+      button.description = this._getPickerTooltip();
+      button.className = this._getPickerAdditionalClassName();
+      button.disabled = null;
+    }
+  },
+
+  /**
+   * Update the visual state of the Frame picker button.
+   */
+  updateFrameButton() {
+    if (this.isDestroying()) {
+      return;
+    }
+
+    if (this.currentToolId === "options" && this.frameMap.size <= 1) {
+      // If the button is only visible because the user is on the Options panel, disable
+      // the button and set an appropriate description.
+      this.frameButton.disabled = true;
+      this.frameButton.description = L10N.getStr(
+        "toolbox.frames.disabled.tooltip"
+      );
+    } else {
+      // Otherwise, enable the button and update the description.
+      this.frameButton.disabled = false;
+      this.frameButton.description = L10N.getStr("toolbox.frames.tooltip");
+    }
+
+    // Highlight the button when a child frame is selected and visible.
+    const selectedFrame = this.frameMap.get(this.selectedFrameId) || {};
+
+    // We need to do something a bit different to avoid some test failures. This function
+    // can be called from onWillNavigate, and the current target might have this `traits`
+    // property nullifed, which is unfortunate as that's what isToolSupported is checking,
+    // so it will throw.
+    // So here, we check first if the button isn't going to be visible anyway (it only checks
+    // for this.frameMap size) so we don't call _commandIsVisible.
+    const isVisible = !this.frameButton.isCurrentlyVisible()
+      ? false
+      : this._commandIsVisible(this.frameButton);
+
+    this.frameButton.isVisible = isVisible;
+
+    if (isVisible) {
+      this.frameButton.isChecked = !selectedFrame.isTopLevel;
+    }
+  },
+
+  updateErrorCountButton() {
+    this.errorCountButton.isVisible =
+      this._commandIsVisible(this.errorCountButton) && this._errorCount > 0;
+    this.errorCountButton.errorCount = this._errorCount;
+  },
+
+  /**
+   * Ensure the visibility of each toolbox button matches the preference value.
+   */
+  _commandIsVisible(button) {
+    const { isToolSupported, isCurrentlyVisible, visibilityswitch } = button;
+
+    if (!Services.prefs.getBoolPref(visibilityswitch, true)) {
+      return false;
+    }
+
+    if (isToolSupported && !isToolSupported(this)) {
+      return false;
+    }
+
+    if (isCurrentlyVisible && !isCurrentlyVisible()) {
+      return false;
+    }
+
+    return true;
+  },
+
+  /**
+   * Build a panel for a tool definition.
+   *
+   * @param {string} toolDefinition
+   *        Tool definition of the tool to build a tab for.
+   */
+  _buildPanelForTool(toolDefinition) {
+    if (!toolDefinition.isToolSupported(this)) {
+      return;
+    }
+
+    const deck = this.doc.getElementById("toolbox-deck");
+    const id = toolDefinition.id;
+
+    if (toolDefinition.ordinal == undefined || toolDefinition.ordinal < 0) {
+      toolDefinition.ordinal = MAX_ORDINAL;
+    }
+
+    if (!toolDefinition.bgTheme) {
+      toolDefinition.bgTheme = "theme-toolbar";
+    }
+    const panel = this.doc.createXULElement("vbox");
+    panel.className = "toolbox-panel " + toolDefinition.bgTheme;
+
+    // There is already a container for the webconsole frame.
+    if (!this.doc.getElementById("toolbox-panel-" + id)) {
+      panel.id = "toolbox-panel-" + id;
+    }
+
+    deck.appendChild(panel);
+  },
+
+  /**
+   * Lazily created map of the additional tools registered to this toolbox.
+   *
+   * @returns {Map<string, object>}
+   *          a map of the tools definitions registered to this
+   *          particular toolbox (the key is the toolId string, the value
+   *          is the tool definition plain javascript object).
+   */
+  get additionalToolDefinitions() {
+    if (!this._additionalToolDefinitions) {
+      this._additionalToolDefinitions = new Map();
+    }
+
+    return this._additionalToolDefinitions;
+  },
+
+  /**
+   * Retrieve the array of the additional tools registered to this toolbox.
+   *
+   * @return {Array<object>}
+   *         the array of additional tool definitions registered on this toolbox.
+   */
+  getAdditionalTools() {
+    if (this._additionalToolDefinitions) {
+      return Array.from(this.additionalToolDefinitions.values());
+    }
+    return [];
+  },
+
+  /**
+   * Get the additional tools that have been registered and are visible.
+   *
+   * @return {Array<object>}
+   *         the array of additional tool definitions registered on this toolbox.
+   */
+  getVisibleAdditionalTools() {
+    return this.visibleAdditionalTools.map(toolId =>
+      this.additionalToolDefinitions.get(toolId)
+    );
+  },
+
+  /**
+   * Test the existence of a additional tools registered to this toolbox by tool id.
+   *
+   * @param {string} toolId
+   *        the id of the tool to test for existence.
+   *
+   * @return {boolean}
+   *
+   */
+  hasAdditionalTool(toolId) {
+    return this.additionalToolDefinitions.has(toolId);
+  },
+
+  /**
+   * Register and load an additional tool on this particular toolbox.
+   *
+   * @param {object} definition
+   *        the additional tool definition to register and add to this toolbox.
+   */
+  addAdditionalTool(definition) {
+    if (!definition.id) {
+      throw new Error("Tool definition id is missing");
+    }
+
+    if (this.isToolRegistered(definition.id)) {
+      throw new Error("Tool definition already registered: " + definition.id);
+    }
+
+    this.additionalToolDefinitions.set(definition.id, definition);
+    this.visibleAdditionalTools = [
+      ...this.visibleAdditionalTools,
+      definition.id,
+    ];
+
+    const buildPanel = () => this._buildPanelForTool(definition);
+
+    if (this.isReady) {
+      buildPanel();
+    } else {
+      this.once("ready", buildPanel);
+    }
+  },
+
+  /**
+   * Retrieve the registered inspector extension sidebars
+   * (used by the inspector panel during its deferred initialization).
+   */
+  get inspectorExtensionSidebars() {
+    return this._inspectorExtensionSidebars;
+  },
+
+  /**
+   * Register an extension sidebar for the inspector panel.
+   *
+   * @param {String} id
+   *        An unique sidebar id
+   * @param {Object} options
+   * @param {String} options.title
+   *        A title for the sidebar
+   */
+  async registerInspectorExtensionSidebar(id, options) {
+    this._inspectorExtensionSidebars.set(id, options);
+
+    // Defer the extension sidebar creation if the inspector
+    // has not been created yet (and do not create the inspector
+    // only to register an extension sidebar).
+    if (!this.target.getCachedFront("inspector")) {
+      return;
+    }
+
+    const inspector = this.getPanel("inspector");
+    if (!inspector) {
+      return;
+    }
+
+    inspector.addExtensionSidebar(id, options);
+  },
+
+  /**
+   * Unregister an extension sidebar for the inspector panel.
+   *
+   * @param {String} id
+   *        An unique sidebar id
+   */
+  unregisterInspectorExtensionSidebar(id) {
+    // Unregister the sidebar from the toolbox if the toolbox is not already
+    // being destroyed (otherwise we would trigger a re-rendering of the
+    // inspector sidebar tabs while the toolbox is going away).
+    if (this._destroyer) {
+      return;
+    }
+
+    const sidebarDef = this._inspectorExtensionSidebars.get(id);
+    if (!sidebarDef) {
+      return;
+    }
+
+    this._inspectorExtensionSidebars.delete(id);
+
+    // Remove the created sidebar instance if the inspector panel
+    // has been already created.
+    if (!this.target.getCachedFront("inspector")) {
+      return;
+    }
+
+    const inspector = this.getPanel("inspector");
+    inspector.removeExtensionSidebar(id);
+  },
+
+  /**
+   * Unregister and unload an additional tool from this particular toolbox.
+   *
+   * @param {string} toolId
+   *        the id of the additional tool to unregister and remove.
+   */
+  removeAdditionalTool(toolId) {
+    // Early exit if the toolbox is already destroying itself.
+    if (this._destroyer) {
+      return;
+    }
+
+    if (!this.hasAdditionalTool(toolId)) {
+      throw new Error(
+        "Tool definition not registered to this toolbox: " + toolId
+      );
+    }
+
+    this.additionalToolDefinitions.delete(toolId);
+    this.visibleAdditionalTools = this.visibleAdditionalTools.filter(
+      id => id !== toolId
+    );
+    this.unloadTool(toolId);
+  },
+
+  /**
+   * Ensure the tool with the given id is loaded.
+   *
+   * @param {string} id
+   *        The id of the tool to load.
+   * @param {Object} options
+   *        Object that will be passed to the panel `open` method.
+   */
+  loadTool(id, options) {
+    let iframe = this.doc.getElementById("toolbox-panel-iframe-" + id);
+    if (iframe) {
+      const panel = this._toolPanels.get(id);
+      return new Promise(resolve => {
+        if (panel) {
+          resolve(panel);
+        } else {
+          this.once(id + "-ready", initializedPanel => {
+            resolve(initializedPanel);
+          });
+        }
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      // Retrieve the tool definition (from the global or the per-toolbox tool maps)
+      const definition = this.getToolDefinition(id);
+
+      if (!definition) {
+        reject(new Error("no such tool id " + id));
+        return;
+      }
+
+      iframe = this.doc.createXULElement("iframe");
+      iframe.className = "toolbox-panel-iframe";
+      iframe.id = "toolbox-panel-iframe-" + id;
+      iframe.setAttribute("flex", 1);
+      iframe.setAttribute("forceOwnRefreshDriver", "");
+      iframe.tooltip = "aHTMLTooltip";
+      iframe.style.visibility = "hidden";
+
+      gDevTools.emit(id + "-init", this, iframe);
+      this.emit(id + "-init", iframe);
+
+      // If no parent yet, append the frame into default location.
+      if (!iframe.parentNode) {
+        const vbox = this.doc.getElementById("toolbox-panel-" + id);
+        vbox.appendChild(iframe);
+        vbox.visibility = "visible";
+      }
+
+      const onLoad = async () => {
+        // Prevent flicker while loading by waiting to make visible until now.
+        iframe.style.visibility = "visible";
+
+        // Try to set the dir attribute as early as possible.
+        this.setIframeDocumentDir(iframe);
+
+        // The build method should return a panel instance, so events can
+        // be fired with the panel as an argument. However, in order to keep
+        // backward compatibility with existing extensions do a check
+        // for a promise return value.
+        let built = definition.build(iframe.contentWindow, this, this.commands);
+
+        if (!(typeof built.then == "function")) {
+          const panel = built;
+          iframe.panel = panel;
+
+          // The panel instance is expected to fire (and listen to) various
+          // framework events, so make sure it's properly decorated with
+          // appropriate API (on, off, once, emit).
+          // In this case we decorate panel instances directly returned by
+          // the tool definition 'build' method.
+          if (typeof panel.emit == "undefined") {
+            EventEmitter.decorate(panel);
+          }
+
+          gDevTools.emit(id + "-build", this, panel);
+          this.emit(id + "-build", panel);
+
+          // The panel can implement an 'open' method for asynchronous
+          // initialization sequence.
+          if (typeof panel.open == "function") {
+            built = panel.open(options);
+          } else {
+            built = new Promise(resolve => {
+              resolve(panel);
+            });
+          }
+        }
+
+        // Wait till the panel is fully ready and fire 'ready' events.
+        Promise.resolve(built).then(panel => {
+          this._toolPanels.set(id, panel);
+
+          // Make sure to decorate panel object with event API also in case
+          // where the tool definition 'build' method returns only a promise
+          // and the actual panel instance is available as soon as the
+          // promise is resolved.
+          if (typeof panel.emit == "undefined") {
+            EventEmitter.decorate(panel);
+          }
+
+          gDevTools.emit(id + "-ready", this, panel);
+          this.emit(id + "-ready", panel);
+
+          resolve(panel);
+        }, console.error);
+      };
+
+      iframe.setAttribute("src", definition.url);
+      if (definition.panelLabel) {
+        iframe.setAttribute("aria-label", definition.panelLabel);
+      }
+
+      // Depending on the host, iframe.contentWindow is not always
+      // defined at this moment. If it is not defined, we use an
+      // event listener on the iframe DOM node. If it's defined,
+      // we use the chromeEventHandler. We can't use a listener
+      // on the DOM node every time because this won't work
+      // if the (xul chrome) iframe is loaded in a content docshell.
+      if (iframe.contentWindow) {
+        DOMHelpers.onceDOMReady(iframe.contentWindow, onLoad);
+      } else {
+        const callback = () => {
+          iframe.removeEventListener("DOMContentLoaded", callback);
+          onLoad();
+        };
+
+        iframe.addEventListener("DOMContentLoaded", callback);
+      }
+    });
+  },
+
+  /**
+   * Set the dir attribute on the content document element of the provided iframe.
+   *
+   * @param {IFrameElement} iframe
+   */
+  setIframeDocumentDir(iframe) {
+    const docEl = iframe.contentWindow?.document.documentElement;
+    if (!docEl || docEl.namespaceURI !== HTML_NS) {
+      // Bail out if the content window or document is not ready or if the document is not
+      // HTML.
+      return;
+    }
+
+    if (docEl.hasAttribute("dir")) {
+      // Set the dir attribute value only if dir is already present on the document.
+      docEl.setAttribute("dir", this.direction);
+    }
+  },
+
+  /**
+   * Mark all in collection as unselected; and id as selected
+   * @param {string} collection
+   *        DOM collection of items
+   * @param {string} id
+   *        The Id of the item within the collection to select
+   */
+  selectSingleNode(collection, id) {
+    [...collection].forEach(node => {
+      if (node.id === id) {
+        node.setAttribute("selected", "true");
+        node.setAttribute("aria-selected", "true");
+      } else {
+        node.removeAttribute("selected");
+        node.removeAttribute("aria-selected");
+      }
+      // The webconsole panel is in a special location due to split console
+      if (!node.id) {
+        node = this.webconsolePanel;
+      }
+
+      const iframe = node.querySelector(".toolbox-panel-iframe");
+      if (iframe) {
+        let visible = node.id == id;
+        // Prevents hiding the split-console if it is currently enabled
+        if (node == this.webconsolePanel && this.splitConsole) {
+          visible = true;
+        }
+        this.setIframeVisible(iframe, visible);
+      }
+    });
+  },
+
+  /**
+   * Make a privileged iframe visible/hidden.
+   *
+   * For now, XUL Iframes loading chrome documents (i.e. <iframe type!="content" />)
+   * can't be hidden at platform level. And so don't support 'visibilitychange' event.
+   *
+   * This helper workarounds that by at least being able to send these kind of events.
+   * It will help panel react differently depending on them being displayed or in
+   * background.
+   */
+  setIframeVisible(iframe, visible) {
+    const state = visible ? "visible" : "hidden";
+    const win = iframe.contentWindow;
+    const doc = win.document;
+    if (doc.visibilityState != state) {
+      // 1) Overload document's `visibilityState` attribute
+      // Use defineProperty, as by default `document.visbilityState` is read only.
+      Object.defineProperty(doc, "visibilityState", {
+        value: state,
+        configurable: true,
+      });
+
+      // 2) Fake the 'visibilitychange' event
+      doc.dispatchEvent(new win.Event("visibilitychange"));
+    }
+  },
+
+  /**
+   * Switch to the tool with the given id
+   *
+   * @param {string} id
+   *        The id of the tool to switch to
+   * @param {string} reason
+   *        Reason the tool was opened
+   * @param {Object} options
+   *        Object that will be passed to the panel
+   */
+  selectTool(id, reason = "unknown", options) {
+    this.emit("panel-changed");
+
+    if (this.currentToolId == id) {
+      const panel = this._toolPanels.get(id);
+      if (panel) {
+        // We have a panel instance, so the tool is already fully loaded.
+
+        // re-focus tool to get key events again
+        this.focusTool(id);
+
+        // Return the existing panel in order to have a consistent return value.
+        return Promise.resolve(panel);
+      }
+      // Otherwise, if there is no panel instance, it is still loading,
+      // so we are racing another call to selectTool with the same id.
+      return this.once("select").then(() =>
+        Promise.resolve(this._toolPanels.get(id))
+      );
+    }
+
+    if (!this.isReady) {
+      throw new Error("Can't select tool, wait for toolbox 'ready' event");
+    }
+
+    // Check if the tool exists.
+    if (
+      this.panelDefinitions.find(definition => definition.id === id) ||
+      id === "options" ||
+      this.additionalToolDefinitions.get(id)
+    ) {
+      if (this.currentToolId) {
+        this.telemetry.toolClosed(this.currentToolId, this);
+      }
+
+      this._pingTelemetrySelectTool(id, reason);
+    } else {
+      throw new Error("No tool found");
+    }
+
+    // and select the right iframe
+    const toolboxPanels = this.doc.querySelectorAll(".toolbox-panel");
+    this.selectSingleNode(toolboxPanels, "toolbox-panel-" + id);
+
+    this.lastUsedToolId = this.currentToolId;
+    this.currentToolId = id;
+    this._refreshConsoleDisplay();
+    if (id != "options") {
+      Services.prefs.setCharPref(this._prefs.LAST_TOOL, id);
+    }
+
+    return this.loadTool(id, options).then(panel => {
+      // focus the tool's frame to start receiving key events
+      this.focusTool(id);
+
+      this.emit("select", id);
+      this.emit(id + "-selected", panel);
+      return panel;
+    });
+  },
+
+  _pingTelemetrySelectTool(id, reason) {
+    const width = Math.ceil(this.win.outerWidth / 50) * 50;
+    const panelName = this.getTelemetryPanelNameOrOther(id);
+    const prevPanelName = this.getTelemetryPanelNameOrOther(this.currentToolId);
+    const cold = !this.getPanel(id);
+    const pending = ["host", "width", "start_state", "panel_name", "cold"];
+
+    // On first load this.currentToolId === undefined so we need to skip sending
+    // a devtools.main.exit telemetry event.
+    if (this.currentToolId) {
+      this.telemetry.recordEvent("exit", prevPanelName, null, {
+        host: this._hostType,
+        width,
+        panel_name: prevPanelName,
+        next_panel: panelName,
+        reason,
+      });
+    }
+
+    this.telemetry.addEventProperties(this.topWindow, "open", "tools", null, {
+      width,
+    });
+
+    if (id === "webconsole") {
+      pending.push("message_count");
+    }
+
+    this.telemetry.preparePendingEvent(this, "enter", panelName, null, pending);
+
+    this.telemetry.addEventProperties(this, "enter", panelName, null, {
+      host: this._hostType,
+      start_state: reason,
+      panel_name: panelName,
+      cold,
+    });
+
+    if (reason !== "initial_panel") {
+      const width = Math.ceil(this.win.outerWidth / 50) * 50;
+      this.telemetry.addEventProperty(
+        this,
+        "enter",
+        panelName,
+        null,
+        "width",
+        width
+      );
+    }
+
+    // Cold webconsole event message_count is handled in
+    // devtools/client/webconsole/webconsole-wrapper.js
+    if (!cold && id === "webconsole") {
+      this.telemetry.addEventProperty(
+        this,
+        "enter",
+        "webconsole",
+        null,
+        "message_count",
+        0
+      );
+    }
+
+    this.telemetry.toolOpened(id, this);
+  },
+
+  /**
+   * Focus a tool's panel by id
+   * @param  {string} id
+   *         The id of tool to focus
+   */
+  focusTool(id, state = true) {
+    const iframe = this.doc.getElementById("toolbox-panel-iframe-" + id);
+
+    if (state) {
+      iframe.focus();
+    } else {
+      iframe.blur();
+    }
+  },
+
+  /**
+   * Focus split console's input line
+   */
+  focusConsoleInput() {
+    const consolePanel = this.getPanel("webconsole");
+    if (consolePanel) {
+      consolePanel.focusInput();
+    }
+  },
+
+  /**
+   * Disable all network logs in the console
+   */
+  disableAllConsoleNetworkLogs() {
+    const consolePanel = this.getPanel("webconsole");
+    if (consolePanel) {
+      consolePanel.hud.ui.disableAllNetworkMessages();
+    }
+  },
+
+  /**
+   * If the console is split and we are focusing an element outside
+   * of the console, then store the newly focused element, so that
+   * it can be restored once the split console closes.
+   *
+   * @param Element originalTarget
+   *        The DOM Element that just got focused.
+   */
+  _updateLastFocusedElementForSplitConsole(originalTarget) {
+    // Ignore any non element nodes, or any elements contained
+    // within the webconsole frame.
+    const webconsoleURL = gDevTools.getToolDefinition("webconsole").url;
+    if (
+      originalTarget.nodeType !== 1 ||
+      originalTarget.baseURI === webconsoleURL
+    ) {
+      return;
+    }
+
+    this._lastFocusedElement = originalTarget;
+  },
+
+  // Report if the toolbox is currently focused,
+  // or the focus in elsewhere in the browser or another app.
+  _isToolboxFocused: false,
+
+  _onFocus({ originalTarget }) {
+    this._isToolboxFocused = true;
+    this._debounceUpdateFocusedState();
+
+    this._updateLastFocusedElementForSplitConsole(originalTarget);
+  },
+
+  _onBlur() {
+    this._isToolboxFocused = false;
+    this._debounceUpdateFocusedState();
+  },
+
+  _onTabsOrderUpdated() {
+    this._combineAndSortPanelDefinitions();
+  },
+
+  /**
+   * Opens the split console.
+   *
+   * @param {boolean} focusConsoleInput
+   *        By default, the console input will be focused.
+   *        Pass false in order to prevent this.
+   *
+   * @returns {Promise} a promise that resolves once the tool has been
+   *          loaded and focused.
+   */
+  openSplitConsole({ focusConsoleInput = true } = {}) {
+    this._splitConsole = true;
+    Services.prefs.setBoolPref(SPLITCONSOLE_ENABLED_PREF, true);
+    this._refreshConsoleDisplay();
+
+    // Ensure split console is visible if console was already loaded in background
+    const iframe = this.webconsolePanel.querySelector(".toolbox-panel-iframe");
+    if (iframe) {
+      this.setIframeVisible(iframe, true);
+    }
+
+    return this.loadTool("webconsole").then(() => {
+      this.component.setIsSplitConsoleActive(true);
+      this.telemetry.recordEvent("activate", "split_console", null, {
+        host: this._getTelemetryHostString(),
+        width: Math.ceil(this.win.outerWidth / 50) * 50,
+      });
+      this.emit("split-console");
+      if (focusConsoleInput) {
+        this.focusConsoleInput();
+      }
+    });
+  },
+
+  /**
+   * Closes the split console.
+   *
+   * @returns {Promise} a promise that resolves once the tool has been
+   *          closed.
+   */
+  closeSplitConsole() {
+    this._splitConsole = false;
+    Services.prefs.setBoolPref(SPLITCONSOLE_ENABLED_PREF, false);
+    this._refreshConsoleDisplay();
+    this.component.setIsSplitConsoleActive(false);
+
+    this.telemetry.recordEvent("deactivate", "split_console", null, {
+      host: this._getTelemetryHostString(),
+      width: Math.ceil(this.win.outerWidth / 50) * 50,
+    });
+
+    this.emit("split-console");
+
+    if (this._lastFocusedElement) {
+      this._lastFocusedElement.focus();
+    }
+    return Promise.resolve();
+  },
+
+  /**
+   * Toggles the split state of the webconsole.  If the webconsole panel
+   * is already selected then this command is ignored.
+   *
+   * @returns {Promise} a promise that resolves once the tool has been
+   *          opened or closed.
+   */
+  toggleSplitConsole() {
+    if (this.currentToolId !== "webconsole") {
+      return this.splitConsole
+        ? this.closeSplitConsole()
+        : this.openSplitConsole();
+    }
+
+    return Promise.resolve();
+  },
+
+  /**
+   * Toggles the options panel.
+   * If the option panel is already selected then select the last selected panel.
+   */
+  toggleOptions(event) {
+    // Flip back to the last used panel if we are already
+    // on the options panel.
+    if (
+      this.currentToolId === "options" &&
+      gDevTools.getToolDefinition(this.lastUsedToolId)
+    ) {
+      this.selectTool(this.lastUsedToolId, "toggle_settings_off");
+    } else {
+      this.selectTool("options", "toggle_settings_on");
+    }
+
+    // preventDefault will avoid a Linux only bug when the focus is on a text input
+    // See Bug 1519087.
+    event.preventDefault();
+  },
+
+  /**
+   * Loads the tool next to the currently selected tool.
+   */
+  selectNextTool() {
+    const definitions = this.component.panelDefinitions;
+    const index = definitions.findIndex(({ id }) => id === this.currentToolId);
+    const definition =
+      index === -1 || index >= definitions.length - 1
+        ? definitions[0]
+        : definitions[index + 1];
+    return this.selectTool(definition.id, "select_next_key");
+  },
+
+  /**
+   * Loads the tool just left to the currently selected tool.
+   */
+  selectPreviousTool() {
+    const definitions = this.component.panelDefinitions;
+    const index = definitions.findIndex(({ id }) => id === this.currentToolId);
+    const definition =
+      index === -1 || index < 1
+        ? definitions[definitions.length - 1]
+        : definitions[index - 1];
+    return this.selectTool(definition.id, "select_prev_key");
+  },
+
+  /**
+   * Tells if the given tool is currently highlighted.
+   * (doesn't mean selected, its tab header will be green)
+   *
+   * @param {string} id
+   *        The id of the tool to check.
+   */
+  isHighlighted(id) {
+    return this.component.state.highlightedTools.has(id);
+  },
+
+  /**
+   * Highlights the tool's tab if it is not the currently selected tool.
+   *
+   * @param {string} id
+   *        The id of the tool to highlight
+   */
+  async highlightTool(id) {
+    if (!this.component) {
+      await this.isOpen;
+    }
+    this.component.highlightTool(id);
+  },
+
+  /**
+   * De-highlights the tool's tab.
+   *
+   * @param {string} id
+   *        The id of the tool to unhighlight
+   */
+  async unhighlightTool(id) {
+    if (!this.component) {
+      await this.isOpen;
+    }
+    this.component.unhighlightTool(id);
+  },
+
+  /**
+   * Raise the toolbox host.
+   */
+  raise() {
+    this.postMessage({ name: "raise-host" });
+
+    return this.once("host-raised");
+  },
+
+  /**
+   * Fired when user just started navigating away to another web page.
+   */
+  async _onWillNavigate({ isFrameSwitching } = {}) {
+    // On navigate, the server will resume all paused threads, but due to an
+    // issue which can cause loosing outgoing messages/RDP packets, the THREAD_STATE
+    // resources for the resumed state might not get received. So let assume it happens
+    // make use the UI is the appropriate state.
+    if (this._pausedTargets > 0) {
+      this.emit("toolbox-resumed");
+      this._pausedTargets = 0;
+      if (this.isHighlighted("jsdebugger")) {
+        this.unhighlightTool("jsdebugger");
+      }
+    }
+
+    // Clearing the error count and the iframe list as soon as we navigate
+    this.setErrorCount(0);
+    if (!isFrameSwitching) {
+      this._updateFrames({ destroyAll: true });
+    }
+    this.updateToolboxButtons();
+    const toolId = this.currentToolId;
+    // For now, only inspector, webconsole, netmonitor and accessibility fire "reloaded" event
+    if (
+      toolId != "inspector" &&
+      toolId != "webconsole" &&
+      toolId != "netmonitor" &&
+      toolId != "accessibility"
+    ) {
+      return;
+    }
+
+    const start = this.win.performance.now();
+    const panel = this.getPanel(toolId);
+    // Ignore the timing if the panel is still loading
+    if (!panel) {
+      return;
+    }
+
+    await panel.once("reloaded");
+    // The toolbox may have been destroyed while the panel was reloading
+    if (this.isDestroying()) {
+      return;
+    }
+    const delay = this.win.performance.now() - start;
+
+    const telemetryKey = "DEVTOOLS_TOOLBOX_PAGE_RELOAD_DELAY_MS";
+    this.telemetry.getKeyedHistogramById(telemetryKey).add(toolId, delay);
+  },
+
+  /**
+   * Refresh the host's title.
+   */
+  _refreshHostTitle() {
+    let title;
+
+    if (this.target.isXpcShellTarget) {
+      // This will only be displayed for local development and can remain
+      // hardcoded in english.
+      title = "XPCShell Toolbox";
+    } else if (this.isMultiProcessBrowserToolbox) {
+      const scope = Services.prefs.getCharPref(BROWSERTOOLBOX_SCOPE_PREF);
+      if (scope == BROWSERTOOLBOX_SCOPE_EVERYTHING) {
+        title = L10N.getStr("toolbox.multiProcessBrowserToolboxTitle");
+      } else if (scope == BROWSERTOOLBOX_SCOPE_PARENTPROCESS) {
+        title = L10N.getStr("toolbox.parentProcessBrowserToolboxTitle");
+      } else {
+        throw new Error("Unsupported scope: " + scope);
+      }
+    } else if (this.target.name && this.target.name != this.target.url) {
+      const url = this.target.isWebExtension
+        ? this.target.getExtensionPathName(this.target.url)
+        : getUnicodeUrl(this.target.url);
+      title = L10N.getFormatStr(
+        "toolbox.titleTemplate2",
+        this.target.name,
+        url
+      );
+    } else {
+      title = L10N.getFormatStr(
+        "toolbox.titleTemplate1",
+        getUnicodeUrl(this.target.url)
+      );
+    }
+    this.postMessage({
+      name: "set-host-title",
+      title,
+    });
+  },
+
+  /**
+   * Returns an instance of the preference actor. This is a lazily initialized root
+   * actor that persists preferences to the debuggee, instead of just to the DevTools
+   * client. See the definition of the preference actor for more information.
+   */
+  get preferenceFront() {
+    if (!this._preferenceFrontRequest) {
+      // Set the _preferenceFrontRequest property to allow the resetPreference toolbox
+      // method to cleanup the preference set when the toolbox is closed.
+      this._preferenceFrontRequest =
+        this.commands.client.mainRoot.getFront("preference");
+    }
+    return this._preferenceFrontRequest;
+  },
+
+  /**
+   * See: https://firefox-source-docs.mozilla.org/l10n/fluent/tutorial.html#manually-testing-ui-with-pseudolocalization
+   *
+   * @param {"bidi" | "accented" | "none"} pseudoLocale
+   */
+  async changePseudoLocale(pseudoLocale) {
+    await this.isOpen;
+    const prefFront = await this.preferenceFront;
+    if (pseudoLocale === "none") {
+      await prefFront.clearUserPref(PSEUDO_LOCALE_PREF);
+    } else {
+      await prefFront.setCharPref(PSEUDO_LOCALE_PREF, pseudoLocale);
+    }
+    this.component.setPseudoLocale(pseudoLocale);
+    this._pseudoLocaleChanged = true;
+  },
+
+  /**
+   * Returns the pseudo-locale when the target is browser chrome, otherwise undefined.
+   *
+   * @returns {"bidi" | "accented" | "none" | undefined}
+   */
+  async getPseudoLocale() {
+    if (!this.isBrowserToolbox) {
+      return undefined;
+    }
+
+    const prefFront = await this.preferenceFront;
+    const locale = await prefFront.getCharPref(PSEUDO_LOCALE_PREF);
+
+    switch (locale) {
+      case "bidi":
+      case "accented":
+        return locale;
+      default:
+        return "none";
+    }
+  },
+
+  async toggleNoAutohide() {
+    const front = await this.preferenceFront;
+
+    const toggledValue = !(await this._isDisableAutohideEnabled());
+
+    front.setBoolPref(DISABLE_AUTOHIDE_PREF, toggledValue);
+
+    if (
+      this.isBrowserToolbox ||
+      this._descriptorFront.isWebExtensionDescriptor
+    ) {
+      this.component.setDisableAutohide(toggledValue);
+    }
+    this._autohideHasBeenToggled = true;
+  },
+
+  /**
+   * Toggling "always on top" behavior is a bit special.
+   *
+   * We toggle the preference and then destroy and re-create the toolbox
+   * as there is no way to change this behavior on an existing window
+   * (see bug 1788946).
+   */
+  async toggleAlwaysOnTop() {
+    const currentValue = Services.prefs.getBoolPref(
+      DEVTOOLS_ALWAYS_ON_TOP,
+      false
+    );
+    Services.prefs.setBoolPref(DEVTOOLS_ALWAYS_ON_TOP, !currentValue);
+
+    const addonId = this._descriptorFront.id;
+    await this.destroy();
+    gDevTools.showToolboxForWebExtension(addonId);
+  },
+
+  async _isDisableAutohideEnabled() {
+    if (
+      !this.isBrowserToolbox &&
+      !this._descriptorFront.isWebExtensionDescriptor
+    ) {
+      return false;
+    }
+
+    const prefFront = await this.preferenceFront;
+    return prefFront.getBoolPref(DISABLE_AUTOHIDE_PREF);
+  },
+
+  async _listFrames(event) {
+    if (
+      !this.target.getTrait("frames") ||
+      this.target.targetForm.ignoreSubFrames
+    ) {
+      // We are not targetting a regular WindowGlobalTargetActor (it can be either an
+      // addon or browser toolbox actor), or EFT is enabled.
+      return;
+    }
+
+    try {
+      const { frames } = await this.target.listFrames();
+      this._updateFrames({ frames });
+    } catch (e) {
+      console.error("Error while listing frames", e);
+    }
+  },
+
+  /**
+   * Called by the iframe picker when the user selected a frame.
+   *
+   * @param {String} frameIdOrTargetActorId
+   */
+  onIframePickerFrameSelected(frameIdOrTargetActorId) {
+    if (!this.frameMap.has(frameIdOrTargetActorId)) {
+      console.error(
+        `Can't focus on frame "${frameIdOrTargetActorId}", it is not a known frame`
+      );
+      return;
+    }
+
+    const frameInfo = this.frameMap.get(frameIdOrTargetActorId);
+    // If there is no targetFront in the frameData, this means EFT is not enabled.
+    // Send packet to the backend to select specified frame and  wait for 'frameUpdate'
+    // event packet to update the UI.
+    if (!frameInfo.targetFront) {
+      this.target.switchToFrame({ windowId: frameIdOrTargetActorId });
+      return;
+    }
+
+    // Here, EFT is enabled, so we want to focus the toolbox on the specific targetFront
+    // that was selected by the user. This will trigger this._onTargetSelected which will
+    // take care of updating the iframe picker state.
+    this.commands.targetCommand.selectTarget(frameInfo.targetFront);
+  },
+
+  /**
+   * Highlight a frame in the page
+   *
+   * @param {String} frameIdOrTargetActorId
+   */
+  async onHighlightFrame(frameIdOrTargetActorId) {
+    // Only enable frame highlighting when the top level document is targeted
+    if (!this.rootFrameSelected) {
+      return null;
+    }
+
+    const frameInfo = this.frameMap.get(frameIdOrTargetActorId);
+    if (!frameInfo) {
+      return null;
+    }
+
+    let nodeFront;
+    if (frameInfo.targetFront) {
+      const inspectorFront = await frameInfo.targetFront.getFront("inspector");
+      nodeFront = await inspectorFront.walker.documentElement();
+    } else {
+      const inspectorFront = await this.target.getFront("inspector");
+      nodeFront = await inspectorFront.walker.getNodeActorFromWindowID(
+        frameIdOrTargetActorId
+      );
+    }
+    const highlighter = this.getHighlighter();
+    return highlighter.highlight(nodeFront);
+  },
+
+  /**
+   * Handles changes in document frames.
+   *
+   * @param {Object} data
+   * @param {Boolean} data.destroyAll: All frames have been destroyed.
+   * @param {Number} data.selected: A frame has been selected
+   * @param {Object} data.frameData: Some frame data were updated
+   * @param {String} data.frameData.url: new frame URL (it might have been blank or about:blank)
+   * @param {String} data.frameData.title: new frame title
+   * @param {Number|String} data.frameData.id: frame ID / targetFront actorID when EFT is enabled.
+   * @param {Array<Object>} data.frames: List of frames. Every frame can have:
+   * @param {Number|String} data.frames[].id: frame ID / targetFront actorID when EFT is enabled.
+   * @param {String} data.frames[].url: frame URL
+   * @param {String} data.frames[].title: frame title
+   * @param {Boolean} data.frames[].destroy: Set to true if destroyed
+   * @param {Boolean} data.frames[].isTopLevel: true for top level window
+   */
+  _updateFrames(data) {
+    // At the moment, frames `id` can either be outerWindowID (a Number),
+    // or a targetActorID (a String).
+    // In order to have the same type of data as a key of `frameMap`, we transform any
+    // outerWindowID into a string.
+    // This can be removed once EFT is enabled by default
+    if (data.selected) {
+      data.selected = data.selected.toString();
+    } else if (data.frameData) {
+      data.frameData.id = data.frameData.id.toString();
+    } else if (data.frames) {
+      data.frames.forEach(frame => {
+        if (frame.id) {
+          frame.id = frame.id.toString();
+        }
+      });
+    }
+
+    // Store (synchronize) data about all existing frames on the backend
+    if (data.destroyAll) {
+      this.frameMap.clear();
+      this.selectedFrameId = null;
+    } else if (data.selected) {
+      // If we select the top level target, default back to no particular selected document.
+      if (data.selected == this.target.actorID) {
+        this.selectedFrameId = null;
+      } else {
+        this.selectedFrameId = data.selected;
+      }
+    } else if (data.frameData && this.frameMap.has(data.frameData.id)) {
+      const existingFrameData = this.frameMap.get(data.frameData.id);
+      if (
+        existingFrameData.title == data.frameData.title &&
+        existingFrameData.url == data.frameData.url
+      ) {
+        return;
+      }
+
+      this.frameMap.set(data.frameData.id, {
+        ...existingFrameData,
+        url: data.frameData.url,
+        title: data.frameData.title,
+      });
+    } else if (data.frames) {
+      data.frames.forEach(frame => {
+        if (frame.destroy) {
+          this.frameMap.delete(frame.id);
+
+          // Reset the currently selected frame if it's destroyed.
+          if (this.selectedFrameId == frame.id) {
+            this.selectedFrameId = null;
+          }
+        } else {
+          this.frameMap.set(frame.id, frame);
+        }
+      });
+    }
+
+    // If there is no selected frame select the first top level
+    // frame by default. Note that there might be more top level
+    // frames in case of the BrowserToolbox.
+    if (!this.selectedFrameId) {
+      const frames = [...this.frameMap.values()];
+      const topFrames = frames.filter(frame => frame.isTopLevel);
+      this.selectedFrameId = topFrames.length ? topFrames[0].id : null;
+    }
+
+    // Debounce the update to avoid unnecessary flickering/rendering.
+    if (!this.debouncedToolbarUpdate) {
+      this.debouncedToolbarUpdate = debounce(
+        () => {
+          // Toolbox may have been destroyed in the meantime
+          if (this.component) {
+            this.component.setToolboxButtons(this.toolbarButtons);
+          }
+          this.debouncedToolbarUpdate = null;
+        },
+        200,
+        this
+      );
+    }
+
+    const updateUiElements = () => {
+      // We may need to hide/show the frames button now.
+      this.updateFrameButton();
+
+      if (this.debouncedToolbarUpdate) {
+        this.debouncedToolbarUpdate();
+      }
+    };
+
+    // This may have been called before the toolbox is ready (= the dom elements for
+    // the iframe picker don't exist yet).
+    if (!this.isReady) {
+      this.once("ready").then(() => updateUiElements);
+    } else {
+      updateUiElements();
+    }
+  },
+
+  /**
+   * Returns whether a root frame (with no parent frame) is selected.
+   */
+  get rootFrameSelected() {
+    // If the frame switcher is disabled, we won't have a selected frame ID.
+    // In this case, we're always showing the root frame.
+    if (!this.selectedFrameId) {
+      return true;
+    }
+
+    return this.frameMap.get(this.selectedFrameId).isTopLevel;
+  },
+
+  /**
+   * Switch to the last used host for the toolbox UI.
+   */
+  switchToPreviousHost() {
+    return this.switchHost("previous");
+  },
+
+  /**
+   * Switch to a new host for the toolbox UI. E.g. bottom, sidebar, window,
+   * and focus the window when done.
+   *
+   * @param {string} hostType
+   *        The host type of the new host object
+   */
+  switchHost(hostType) {
+    if (hostType == this.hostType || !this._descriptorFront.isLocalTab) {
+      return null;
+    }
+
+    // chromeEventHandler will change after swapping hosts, remove events relying on it.
+    this._removeChromeEventHandlerEvents();
+
+    this.emit("host-will-change", hostType);
+
+    // ToolboxHostManager is going to call swapFrameLoaders which mess up with
+    // focus. We have to blur before calling it in order to be able to restore
+    // the focus after, in _onSwitchedHost.
+    this.focusTool(this.currentToolId, false);
+
+    // Host code on the chrome side will send back a message once the host
+    // switched
+    this.postMessage({
+      name: "switch-host",
+      hostType,
+    });
+
+    return this.once("host-changed");
+  },
+
+  /**
+   * Request to Firefox UI to move the toolbox to another tab.
+   * This is used when we move a toolbox to a new popup opened by the tab we were currently debugging.
+   * We also move the toolbox back to the original tab we were debugging if we select it via Firefox tabs.
+   *
+   * @param {String} tabBrowsingContextID
+   *        The BrowsingContext ID of the tab we want to move to.
+   * @returns {Promise<undefined>}
+   *        This will resolve only once we moved to the new tab.
+   */
+  switchHostToTab(tabBrowsingContextID) {
+    this.postMessage({
+      name: "switch-host-to-tab",
+      tabBrowsingContextID,
+    });
+
+    return this.once("switched-host-to-tab");
+  },
+
+  _onSwitchedHost({ hostType }) {
+    this._hostType = hostType;
+
+    this._buildDockOptions();
+
+    // chromeEventHandler changed after swapping hosts, add again events relying on it.
+    this._addChromeEventHandlerEvents();
+
+    // We blurred the tools at start of switchHost, but also when clicking on
+    // host switching button. We now have to restore the focus.
+    this.focusTool(this.currentToolId, true);
+
+    this.emit("host-changed");
+    this.telemetry
+      .getHistogramById(HOST_HISTOGRAM)
+      .add(this._getTelemetryHostId());
+
+    this.component.setCurrentHostType(hostType);
+  },
+
+  /**
+   * Event handler fired when the toolbox was moved to another tab.
+   * This fires when the toolbox itself requests to be moved to another tab,
+   * but also when we select the original tab where the toolbox originally was.
+   *
+   * @param {String} browsingContextID
+   *        The BrowsingContext ID of the tab the toolbox has been moved to.
+   */
+  _onSwitchedHostToTab(browsingContextID) {
+    const targets = this.commands.targetCommand.getAllTargets([
+      this.commands.targetCommand.TYPES.FRAME,
+    ]);
+    const target = targets.find(
+      target => target.browsingContextID == browsingContextID
+    );
+
+    this.commands.targetCommand.selectTarget(target);
+
+    this.emit("switched-host-to-tab");
+  },
+
+  /**
+   * Test the availability of a tool (both globally registered tools and
+   * additional tools registered to this toolbox) by tool id.
+   *
+   * @param  {string} toolId
+   *         Id of the tool definition to search in the per-toolbox or globally
+   *         registered tools.
+   *
+   * @returns {bool}
+   *         Returns true if the tool is registered globally or on this toolbox.
+   */
+  isToolRegistered(toolId) {
+    return !!this.getToolDefinition(toolId);
+  },
+
+  /**
+   * Return the tool definition registered globally or additional tools registered
+   * to this toolbox.
+   *
+   * @param  {string} toolId
+   *         Id of the tool definition to retrieve for the per-toolbox and globally
+   *         registered tools.
+   *
+   * @returns {object}
+   *         The plain javascript object that represents the requested tool definition.
+   */
+  getToolDefinition(toolId) {
+    return (
+      gDevTools.getToolDefinition(toolId) ||
+      this.additionalToolDefinitions.get(toolId)
+    );
+  },
+
+  /**
+   * Internal helper that removes a loaded tool from the toolbox,
+   * it removes a loaded tool panel and tab from the toolbox without removing
+   * its definition, so that it can still be listed in options and re-added later.
+   *
+   * @param  {string} toolId
+   *         Id of the tool to be removed.
+   */
+  unloadTool(toolId) {
+    if (typeof toolId != "string") {
+      throw new Error("Unexpected non-string toolId received.");
+    }
+
+    if (this._toolPanels.has(toolId)) {
+      const instance = this._toolPanels.get(toolId);
+      instance.destroy();
+      this._toolPanels.delete(toolId);
+    }
+
+    const panel = this.doc.getElementById("toolbox-panel-" + toolId);
+
+    // Select another tool.
+    if (this.currentToolId == toolId) {
+      const index = this.panelDefinitions.findIndex(({ id }) => id === toolId);
+      const nextTool = this.panelDefinitions[index + 1];
+      const previousTool = this.panelDefinitions[index - 1];
+      let toolNameToSelect;
+
+      if (nextTool) {
+        toolNameToSelect = nextTool.id;
+      }
+      if (previousTool) {
+        toolNameToSelect = previousTool.id;
+      }
+      if (toolNameToSelect) {
+        this.selectTool(toolNameToSelect, "tool_unloaded");
+      }
+    }
+
+    // Remove this tool from the current panel definitions.
+    this.panelDefinitions = this.panelDefinitions.filter(
+      ({ id }) => id !== toolId
+    );
+    this.visibleAdditionalTools = this.visibleAdditionalTools.filter(
+      id => id !== toolId
+    );
+    this._combineAndSortPanelDefinitions();
+
+    if (panel) {
+      panel.remove();
+    }
+
+    if (this.hostType == Toolbox.HostType.WINDOW) {
+      const doc = this.win.parent.document;
+      const key = doc.getElementById("key_" + toolId);
+      if (key) {
+        key.remove();
+      }
+    }
+  },
+
+  /**
+   * Handler for the tool-registered event.
+   * @param  {string} toolId
+   *         Id of the tool that was registered
+   */
+  _toolRegistered(toolId) {
+    // Tools can either be in the global devtools, or added to this specific toolbox
+    // as an additional tool.
+    let definition = gDevTools.getToolDefinition(toolId);
+    let isAdditionalTool = false;
+    if (!definition) {
+      definition = this.additionalToolDefinitions.get(toolId);
+      isAdditionalTool = true;
+    }
+
+    if (definition.isToolSupported(this)) {
+      if (isAdditionalTool) {
+        this.visibleAdditionalTools = [...this.visibleAdditionalTools, toolId];
+        this._combineAndSortPanelDefinitions();
+      } else {
+        this.panelDefinitions = this.panelDefinitions.concat(definition);
+      }
+      this._buildPanelForTool(definition);
+
+      // Emit the event so tools can listen to it from the toolbox level
+      // instead of gDevTools.
+      this.emit("tool-registered", toolId);
+    }
+  },
+
+  /**
+   * Handler for the tool-unregistered event.
+   * @param  {string} toolId
+   *         id of the tool that was unregistered
+   */
+  _toolUnregistered(toolId) {
+    this.unloadTool(toolId);
+
+    // Emit the event so tools can listen to it from the toolbox level
+    // instead of gDevTools
+    this.emit("tool-unregistered", toolId);
+  },
+
+  /**
+   * A helper function that returns an object containing methods to show and hide the
+   * Box Model Highlighter on a given NodeFront or node grip (object with metadata which
+   * can be used to obtain a NodeFront for a node), as well as helpers to listen to the
+   * higligher show and hide events. The event helpers are used in tests where it is
+   * cumbersome to load the Inspector panel in order to listen to highlighter events.
+   *
+   * @returns {Object} an object of the following shape:
+   *   - {AsyncFunction} highlight: A function that will show a Box Model Highlighter
+   *                     for the provided NodeFront or node grip.
+   *   - {AsyncFunction} unhighlight: A function that will hide any Box Model Highlighter
+   *                     that is visible. If the `highlight` promise isn't settled yet,
+   *                     it will wait until it's done and then unhighlight to prevent
+   *                     zombie highlighters.
+   *   - {AsyncFunction} waitForHighlighterShown: Returns a promise which resolves with
+   *                     the "highlighter-shown" event data once the highlighter is shown.
+   *   - {AsyncFunction} waitForHighlighterHidden: Returns a promise which resolves with
+   *                     the "highlighter-hidden" event data once the highlighter is
+   *                     hidden.
+   *
+   */
+  getHighlighter() {
+    let pendingHighlight;
+
+    /**
+     * Return a promise wich resolves with a reference to the Inspector panel.
+     */
+    const _getInspector = async () => {
+      const inspector = this.getPanel("inspector");
+      if (inspector) {
+        return inspector;
+      }
+
+      return this.loadTool("inspector");
+    };
+
+    /**
+     * Returns a promise which resolves when a Box Model Highlighter emits the given event
+     *
+     * @param  {String} eventName
+     *         Name of the event to listen to.
+     * @return {Promise}
+     *         Promise which resolves when the highlighter event occurs.
+     *         Resolves with the data payload attached to the event.
+     */
+    async function _waitForHighlighterEvent(eventName) {
+      const inspector = await _getInspector();
+      return new Promise(resolve => {
+        function _handler(data) {
+          if (data.type === inspector.highlighters.TYPES.BOXMODEL) {
+            inspector.highlighters.off(eventName, _handler);
+            resolve(data);
+          }
+        }
+
+        inspector.highlighters.on(eventName, _handler);
+      });
+    }
+
+    return {
+      // highlight might be triggered right before a test finishes. Wrap it
+      // with safeAsyncMethod to avoid intermittents.
+      highlight: this._safeAsyncAfterDestroy(async (object, options) => {
+        pendingHighlight = (async () => {
+          let nodeFront = object;
+
+          if (!(nodeFront instanceof NodeFront)) {
+            const inspectorFront = await this.target.getFront("inspector");
+            nodeFront = await inspectorFront.getNodeFrontFromNodeGrip(object);
+          }
+
+          if (!nodeFront) {
+            return null;
+          }
+
+          const inspector = await _getInspector();
+          return inspector.highlighters.showHighlighterTypeForNode(
+            inspector.highlighters.TYPES.BOXMODEL,
+            nodeFront,
+            options
+          );
+        })();
+        return pendingHighlight;
+      }),
+      unhighlight: this._safeAsyncAfterDestroy(async () => {
+        if (pendingHighlight) {
+          await pendingHighlight;
+          pendingHighlight = null;
+        }
+
+        const inspector = await _getInspector();
+        return inspector.highlighters.hideHighlighterType(
+          inspector.highlighters.TYPES.BOXMODEL
+        );
+      }),
+
+      waitForHighlighterShown: this._safeAsyncAfterDestroy(async () => {
+        return _waitForHighlighterEvent("highlighter-shown");
+      }),
+
+      waitForHighlighterHidden: this._safeAsyncAfterDestroy(async () => {
+        return _waitForHighlighterEvent("highlighter-hidden");
+      }),
+    };
+  },
+
+  /**
+   * Shortcut to avoid throwing errors when an async method fails after toolbox
+   * destroy. Should be used with methods that might be triggered by a user
+   * input, regardless of the toolbox lifecycle.
+   */
+  _safeAsyncAfterDestroy(fn) {
+    return safeAsyncMethod(fn, () => !!this._destroyer);
+  },
+
+  async _onNewSelectedNodeFront() {
+    // Emit a "selection-changed" event when the toolbox.selection has been set
+    // to a new node (or cleared). Currently used in the WebExtensions APIs (to
+    // provide the `devtools.panels.elements.onSelectionChanged` event).
+    this.emit("selection-changed");
+
+    const targetFrontActorID = this.selection?.nodeFront?.targetFront?.actorID;
+    if (targetFrontActorID) {
+      this.selectTarget(targetFrontActorID);
+    }
+  },
+
+  _onToolSelected() {
+    this._refreshHostTitle();
+
+    this.updatePickerButton();
+    this.updateFrameButton();
+    this.updateErrorCountButton();
+
+    // Calling setToolboxButtons in case the visibility of a button changed.
+    this.component.setToolboxButtons(this.toolbarButtons);
+  },
+
+  /**
+   * Listener for "inspectObject" event on console top level target actor.
+   */
+  _onInspectObject(packet) {
+    this.inspectObjectActor(packet.objectActor, packet.inspectFromAnnotation);
+  },
+
+  async inspectObjectActor(objectActor, inspectFromAnnotation) {
+    const objectGrip = objectActor?.getGrip
+      ? objectActor.getGrip()
+      : objectActor;
+
+    if (
+      objectGrip.preview &&
+      objectGrip.preview.nodeType === domNodeConstants.ELEMENT_NODE
+    ) {
+      await this.viewElementInInspector(objectGrip, inspectFromAnnotation);
+      return;
+    }
+
+    if (objectGrip.class == "Function") {
+      if (!objectGrip.location) {
+        console.error("Missing location in Function objectGrip", objectGrip);
+        return;
+      }
+
+      const { url, line, column } = objectGrip.location;
+      await this.viewSourceInDebugger(url, line, column);
+      return;
+    }
+
+    if (objectGrip.type !== "null" && objectGrip.type !== "undefined") {
+      // Open then split console and inspect the object in the variables view,
+      // when the objectActor doesn't represent an undefined or null value.
+      if (this.currentToolId != "webconsole") {
+        await this.openSplitConsole();
+      }
+
+      const panel = this.getPanel("webconsole");
+      panel.hud.ui.inspectObjectActor(objectActor);
+    }
+  },
+
+  /**
+   * Get the toolbox's notification component
+   *
+   * @return The notification box component.
+   */
+  getNotificationBox() {
+    return this.notificationBox;
+  },
+
+  async closeToolbox() {
+    await this.destroy();
+  },
+
+  /**
+   * Public API to check is the current toolbox is currently being destroyed.
+   */
+  isDestroying() {
+    return this._destroyer;
+  },
+
+  /**
+   * Remove all UI elements, detach from target and clear up
+   */
+  destroy() {
+    // If several things call destroy then we give them all the same
+    // destruction promise so we're sure to destroy only once
+    if (this._destroyer) {
+      return this._destroyer;
+    }
+
+    // This pattern allows to immediately return the destroyer promise.
+    // See Bug 1602727 for more details.
+    let destroyerResolve;
+    this._destroyer = new Promise(r => (destroyerResolve = r));
+    this._destroyToolbox().then(destroyerResolve);
+
+    return this._destroyer;
+  },
+
+  async _destroyToolbox() {
+    this.emit("destroy");
+
+    // This flag will be checked by Fronts in order to decide if they should
+    // skip their destroy.
+    this.commands.client.isToolboxDestroy = true;
+
+    this.off("select", this._onToolSelected);
+    this.off("host-changed", this._refreshHostTitle);
+
+    gDevTools.off("tool-registered", this._toolRegistered);
+    gDevTools.off("tool-unregistered", this._toolUnregistered);
+
+    Services.prefs.removeObserver(
+      "devtools.cache.disabled",
+      this._applyCacheSettings
+    );
+    Services.prefs.removeObserver(
+      "devtools.custom-formatters.enabled",
+      this._applyCustomFormatterSetting
+    );
+    Services.prefs.removeObserver(
+      "devtools.serviceWorkers.testing.enabled",
+      this._applyServiceWorkersTestingSettings
+    );
+    Services.prefs.removeObserver(
+      "devtools.inspector.simple-highlighters-reduced-motion",
+      this._applySimpleHighlightersSettings
+    );
+    Services.prefs.removeObserver(
+      BROWSERTOOLBOX_SCOPE_PREF,
+      this._refreshHostTitle
+    );
+
+    // We normally handle toolClosed from selectTool() but in the event of the
+    // toolbox closing we need to handle it here instead.
+    this.telemetry.toolClosed(this.currentToolId, this);
+
+    this._lastFocusedElement = null;
+    this._pausedTargets = null;
+
+    if (this._sourceMapLoader) {
+      this._sourceMapLoader.stopSourceMapWorker();
+      // Unregister all listeners
+      this._sourceMapLoader.clearEvents();
+      this._sourceMapLoader = null;
+    }
+
+    if (this._parserWorker) {
+      this._parserWorker.stop();
+      this._parserWorker = null;
+    }
+
+    if (this.webconsolePanel) {
+      this._saveSplitConsoleHeight();
+      this.webconsolePanel.removeEventListener(
+        "resize",
+        this._saveSplitConsoleHeight
+      );
+      this.webconsolePanel = null;
+    }
+    if (this._componentMount) {
+      this._tabBar.removeEventListener(
+        "keypress",
+        this._onToolbarArrowKeypress
+      );
+      this.ReactDOM.unmountComponentAtNode(this._componentMount);
+      this.component = null;
+      this._componentMount = null;
+      this._tabBar = null;
+    }
+    this.destroyHarAutomation();
+
+    for (const [id, panel] of this._toolPanels) {
+      try {
+        gDevTools.emit(id + "-destroy", this, panel);
+        this.emit(id + "-destroy", panel);
+
+        const rv = panel.destroy();
+        if (rv) {
+          console.error(
+            `Panel ${id}'s destroy method returned something whereas it shouldn't (and should be synchronous).`
+          );
+        }
+      } catch (e) {
+        // We don't want to stop here if any panel fail to close.
+        console.error("Panel " + id + ":", e);
+      }
+    }
+
+    this.browserRequire = null;
+    this._toolNames = null;
+
+    // Reset preferences set by the toolbox, then remove the preference front.
+    const onResetPreference = this.resetPreference().then(() => {
+      this._preferenceFrontRequest = null;
+    });
+
+    this.commands.targetCommand.unwatchTargets({
+      types: this.commands.targetCommand.ALL_TYPES,
+      onAvailable: this._onTargetAvailable,
+      onSelected: this._onTargetSelected,
+      onDestroyed: this._onTargetDestroyed,
+    });
+
+    const watchedResources = [
+      this.resourceCommand.TYPES.CONSOLE_MESSAGE,
+      this.resourceCommand.TYPES.ERROR_MESSAGE,
+      this.resourceCommand.TYPES.DOCUMENT_EVENT,
+      this.resourceCommand.TYPES.THREAD_STATE,
+    ];
+
+    if (!this.isBrowserToolbox) {
+      watchedResources.push(this.resourceCommand.TYPES.NETWORK_EVENT);
+    }
+
+    this.resourceCommand.unwatchResources(watchedResources, {
+      onAvailable: this._onResourceAvailable,
+    });
+
+    // Unregister buttons listeners
+    this.toolbarButtons.forEach(button => {
+      if (typeof button.teardown == "function") {
+        // teardown arguments have already been bound in _createButtonState
+        button.teardown();
+      }
+    });
+
+    // We need to grab a reference to win before this._host is destroyed.
+    const win = this.win;
+    const host = this._getTelemetryHostString();
+    const width = Math.ceil(win.outerWidth / 50) * 50;
+    const prevPanelName = this.getTelemetryPanelNameOrOther(this.currentToolId);
+
+    this.telemetry.toolClosed("toolbox", this);
+    this.telemetry.recordEvent("exit", prevPanelName, null, {
+      host,
+      width,
+      panel_name: this.getTelemetryPanelNameOrOther(this.currentToolId),
+      next_panel: "none",
+      reason: "toolbox_close",
+    });
+    this.telemetry.recordEvent("close", "tools", null, {
+      host,
+      width,
+    });
+
+    // Wait for the preferences to be reset before destroying the target descriptor (which will destroy the preference front)
+    const onceDestroyed = new Promise(resolve => {
+      resolve(
+        onResetPreference
+          .catch(console.error)
+          .then(async () => {
+            // Destroy the node picker *after* destroying the panel,
+            // which may still try to access it. (And might spawn a new one)
+            if (this._nodePicker) {
+              this._nodePicker.destroy();
+              this._nodePicker = null;
+            }
+            this.selection.destroy();
+            this.selection = null;
+
+            if (this._netMonitorAPI) {
+              this._netMonitorAPI.destroy();
+              this._netMonitorAPI = null;
+            }
+
+            if (this._sourceMapURLService) {
+              await this._sourceMapURLService.waitForSourcesLoading();
+              this._sourceMapURLService.destroy();
+              this._sourceMapURLService = null;
+            }
+
+            this._removeWindowListeners();
+            this._removeChromeEventHandlerEvents();
+
+            this._store = null;
+
+            // All Commands need to be destroyed.
+            // This is done after other destruction tasks since it may tear down
+            // fronts and the debugger transport which earlier destroy methods may
+            // require to complete.
+            // (i.e. avoid exceptions about closing connection with pending requests)
+            //
+            // For similar reasons, only destroy the TargetCommand after every
+            // other outstanding cleanup is done. Destroying the target list
+            // will lead to destroy frame targets which can temporarily make
+            // some fronts unresponsive and block the cleanup.
+            return this.commands.destroy();
+          }, console.error)
+          .then(() => {
+            this.emit("destroyed");
+
+            // Free _host after the call to destroyed in order to let a chance
+            // to destroyed listeners to still query toolbox attributes
+            this._host = null;
+            this._win = null;
+            this._toolPanels.clear();
+            this._descriptorFront = null;
+            this.resourceCommand = null;
+            this.commands = null;
+
+            // Force GC to prevent long GC pauses when running tests and to free up
+            // memory in general when the toolbox is closed.
+            if (flags.testing) {
+              win.windowUtils.garbageCollect();
+            }
+          })
+          .catch(console.error)
+      );
+    });
+
+    const leakCheckObserver = ({ wrappedJSObject: barrier }) => {
+      // Make the leak detector wait until this toolbox is properly destroyed.
+      barrier.client.addBlocker(
+        "DevTools: Wait until toolbox is destroyed",
+        onceDestroyed
+      );
+    };
+
+    const topic = "shutdown-leaks-before-check";
+    Services.obs.addObserver(leakCheckObserver, topic);
+
+    await onceDestroyed;
+
+    Services.obs.removeObserver(leakCheckObserver, topic);
+  },
+
+  /**
+   * Open the textbox context menu at given coordinates.
+   * Panels in the toolbox can call this on contextmenu events with event.screenX/Y
+   * instead of having to implement their own copy/paste/selectAll menu.
+   * @param {Number} x
+   * @param {Number} y
+   */
+  openTextBoxContextMenu(x, y) {
+    const menu = createEditContextMenu(this.topWindow, "toolbox-menu");
+
+    // Fire event for tests
+    menu.once("open", () => this.emit("menu-open"));
+    menu.once("close", () => this.emit("menu-close"));
+
+    menu.popup(x, y, this.doc);
+  },
+
+  /**
+   *  Retrieve the current textbox context menu, if available.
+   */
+  getTextBoxContextMenu() {
+    return this.topDoc.getElementById("toolbox-menu");
+  },
+
+  /**
+   * Reset preferences set by the toolbox.
+   */
+  async resetPreference() {
+    if (
+      // No preferences have been changed, so there is nothing to reset.
+      !this._preferenceFrontRequest ||
+      // Did any pertinent prefs actually change? For autohide and the pseudo-locale,
+      // only reset prefs in the Browser Toolbox if it's been toggled in the UI
+      // (don't reset the pref if it was already set before opening)
+      (!this._autohideHasBeenToggled && !this._pseudoLocaleChanged)
+    ) {
+      return;
+    }
+
+    const preferenceFront = await this.preferenceFront;
+
+    if (this._autohideHasBeenToggled) {
+      await preferenceFront.clearUserPref(DISABLE_AUTOHIDE_PREF);
+    }
+    if (this._pseudoLocaleChanged) {
+      await preferenceFront.clearUserPref(PSEUDO_LOCALE_PREF);
+    }
+  },
+
+  // HAR Automation
+
+  async initHarAutomation() {
+    const autoExport = Services.prefs.getBoolPref(
+      "devtools.netmonitor.har.enableAutoExportToFile"
+    );
+    if (autoExport) {
+      this.harAutomation = new HarAutomation();
+      await this.harAutomation.initialize(this);
+    }
+  },
+  destroyHarAutomation() {
+    if (this.harAutomation) {
+      this.harAutomation.destroy();
+    }
+  },
+
+  /**
+   * Returns gViewSourceUtils for viewing source.
+   */
+  get gViewSourceUtils() {
+    return this.win.gViewSourceUtils;
+  },
+
+  /**
+   * Open a CSS file when there is no line or column information available.
+   *
+   * @param {string} url The URL of the CSS file to open.
+   */
+  async viewGeneratedSourceInStyleEditor(url) {
+    if (typeof url !== "string") {
+      console.warn("Failed to open generated source, no url given");
+      return false;
+    }
+
+    // The style editor hides the generated file if the file has original
+    // sources, so we have no choice but to open whichever original file
+    // corresponds to the first line of the generated file.
+    return viewSource.viewSourceInStyleEditor(this, url, 1);
+  },
+
+  /**
+   * Given a URL for a stylesheet (generated or original), open in the style
+   * editor if possible. Falls back to plain "view-source:".
+   * If the stylesheet has a sourcemap, we will attempt to open the original
+   * version of the file instead of the generated version.
+   */
+  async viewSourceInStyleEditorByURL(url, line, column) {
+    if (typeof url !== "string") {
+      console.warn("Failed to open source, no url given");
+      return false;
+    }
+    if (typeof line !== "number") {
+      console.warn(
+        "No line given when navigating to source. If you're seeing this, there is a bug."
+      );
+
+      // This is a fallback in case of programming errors, but in a perfect
+      // world, viewSourceInStyleEditorByURL would always get a line/colum.
+      line = 1;
+      column = null;
+    }
+
+    return viewSource.viewSourceInStyleEditor(this, url, line, column);
+  },
+
+  /**
+   * Opens source in style editor. Falls back to plain "view-source:".
+   * If the stylesheet has a sourcemap, we will attempt to open the original
+   * version of the file instead of the generated version.
+   */
+  async viewSourceInStyleEditorByResource(stylesheetResource, line, column) {
+    if (!stylesheetResource || typeof stylesheetResource !== "object") {
+      console.warn("Failed to open source, no stylesheet given");
+      return false;
+    }
+    if (typeof line !== "number") {
+      console.warn(
+        "No line given when navigating to source. If you're seeing this, there is a bug."
+      );
+
+      // This is a fallback in case of programming errors, but in a perfect
+      // world, viewSourceInStyleEditorByResource would always get a line/colum.
+      line = 1;
+      column = null;
+    }
+
+    return viewSource.viewSourceInStyleEditor(
+      this,
+      stylesheetResource,
+      line,
+      column
+    );
+  },
+
+  async viewElementInInspector(objectGrip, reason) {
+    // Open the inspector and select the DOM Element.
+    await this.loadTool("inspector");
+    const inspector = this.getPanel("inspector");
+    const nodeFound = await inspector.inspectNodeActor(objectGrip, reason);
+    if (nodeFound) {
+      await this.selectTool("inspector", reason);
+    }
+  },
+
+  /**
+   * Open a JS file when there is no line or column information available.
+   *
+   * @param {string} url The URL of the JS file to open.
+   */
+  async viewGeneratedSourceInDebugger(url) {
+    if (typeof url !== "string") {
+      console.warn("Failed to open generated source, no url given");
+      return false;
+    }
+
+    return viewSource.viewSourceInDebugger(this, url, null, null, null, null);
+  },
+
+  /**
+   * Opens source in debugger, the sourcemapped location will be selected in
+   * the debugger panel, if the given location resolves to a know sourcemapped one.
+   *
+   * Falls back to plain "view-source:".
+   *
+   * @see devtools/client/shared/source-utils.js
+   */
+  async viewSourceInDebugger(
+    sourceURL,
+    sourceLine,
+    sourceColumn,
+    sourceId,
+    reason
+  ) {
+    if (typeof sourceURL !== "string" && typeof sourceId !== "string") {
+      console.warn("Failed to open generated source, no url/id given");
+      return false;
+    }
+    if (typeof sourceLine !== "number") {
+      console.warn(
+        "No line given when navigating to source. If you're seeing this, there is a bug."
+      );
+
+      // This is a fallback in case of programming errors, but in a perfect
+      // world, viewSourceInDebugger would always get a line/colum.
+      sourceLine = 1;
+      sourceColumn = null;
+    }
+
+    return viewSource.viewSourceInDebugger(
+      this,
+      sourceURL,
+      sourceLine,
+      sourceColumn,
+      sourceId,
+      reason
+    );
+  },
+
+  /**
+   * Opens source in plain "view-source:".
+   * @see devtools/client/shared/source-utils.js
+   */
+  viewSource(sourceURL, sourceLine) {
+    return viewSource.viewSource(this, sourceURL, sourceLine);
+  },
+
+  // Support for WebExtensions API (`devtools.network.*`)
+
+  /**
+   * Return Netmonitor API object. This object offers Network monitor
+   * public API that can be consumed by other panels or WE API.
+   */
+  async getNetMonitorAPI() {
+    const netPanel = this.getPanel("netmonitor");
+
+    // Return Net panel if it exists.
+    if (netPanel) {
+      return netPanel.panelWin.Netmonitor.api;
+    }
+
+    if (this._netMonitorAPI) {
+      return this._netMonitorAPI;
+    }
+
+    // Create and initialize Network monitor API object.
+    // This object is only connected to the backend - not to the UI.
+    this._netMonitorAPI = new NetMonitorAPI();
+    await this._netMonitorAPI.connect(this);
+
+    return this._netMonitorAPI;
+  },
+
+  /**
+   * Returns data (HAR) collected by the Network panel.
+   */
+  async getHARFromNetMonitor() {
+    const netMonitor = await this.getNetMonitorAPI();
+    let har = await netMonitor.getHar();
+
+    // Return default empty HAR file if needed.
+    har = har || buildHarLog(Services.appinfo);
+
+    // Return the log directly to be compatible with
+    // Chrome WebExtension API.
+    return har.log;
+  },
+
+  /**
+   * Add listener for `onRequestFinished` events.
+   *
+   * @param {Object} listener
+   *        The listener to be called it's expected to be
+   *        a function that takes ({harEntry, requestId})
+   *        as first argument.
+   */
+  async addRequestFinishedListener(listener) {
+    const netMonitor = await this.getNetMonitorAPI();
+    netMonitor.addRequestFinishedListener(listener);
+  },
+
+  async removeRequestFinishedListener(listener) {
+    const netMonitor = await this.getNetMonitorAPI();
+    netMonitor.removeRequestFinishedListener(listener);
+
+    // Destroy Network monitor API object if the following is true:
+    // 1) there is no listener
+    // 2) the Net panel doesn't exist/use the API object (if the panel
+    //    exists it's also responsible for destroying it,
+    //    see `NetMonitorPanel.open` for more details)
+    const netPanel = this.getPanel("netmonitor");
+    const hasListeners = netMonitor.hasRequestFinishedListeners();
+    if (this._netMonitorAPI && !hasListeners && !netPanel) {
+      this._netMonitorAPI.destroy();
+      this._netMonitorAPI = null;
+    }
+  },
+
+  /**
+   * Used to lazily fetch HTTP response content within
+   * `onRequestFinished` event listener.
+   *
+   * @param {String} requestId
+   *        Id of the request for which the response content
+   *        should be fetched.
+   */
+  async fetchResponseContent(requestId) {
+    const netMonitor = await this.getNetMonitorAPI();
+    return netMonitor.fetchResponseContent(requestId);
+  },
+
+  // Support management of installed WebExtensions that provide a devtools_page.
+
+  /**
+   * List the subset of the active WebExtensions which have a devtools_page (used by
+   * toolbox-options.js to create the list of the tools provided by the enabled
+   * WebExtensions).
+   * @see devtools/client/framework/toolbox-options.js
+   */
+  listWebExtensions() {
+    // Return the array of the enabled webextensions (we can't use the prefs list here,
+    // because some of them may be disabled by the Addon Manager and still have a devtools
+    // preference).
+    return Array.from(this._webExtensions).map(([uuid, { name, pref }]) => {
+      return { uuid, name, pref };
+    });
+  },
+
+  /**
+   * Add a WebExtension to the list of the active extensions (given the extension UUID,
+   * a unique id assigned to an extension when it is installed, and its name),
+   * and emit a "webextension-registered" event to allow toolbox-options.js
+   * to refresh the listed tools accordingly.
+   * @see browser/components/extensions/ext-devtools.js
+   */
+  registerWebExtension(extensionUUID, { name, pref }) {
+    // Ensure that an installed extension (active in the AddonManager) which
+    // provides a devtools page is going to be listed in the toolbox options
+    // (and refresh its name if it was already listed).
+    this._webExtensions.set(extensionUUID, { name, pref });
+    this.emit("webextension-registered", extensionUUID);
+  },
+
+  /**
+   * Remove an active WebExtension from the list of the active extensions (given the
+   * extension UUID, a unique id assigned to an extension when it is installed, and its
+   * name), and emit a "webextension-unregistered" event to allow toolbox-options.js
+   * to refresh the listed tools accordingly.
+   * @see browser/components/extensions/ext-devtools.js
+   */
+  unregisterWebExtension(extensionUUID) {
+    // Ensure that an extension that has been disabled/uninstalled from the AddonManager
+    // is going to be removed from the toolbox options.
+    this._webExtensions.delete(extensionUUID);
+    this.emit("webextension-unregistered", extensionUUID);
+  },
+
+  /**
+   * A helper function which returns true if the extension with the given UUID is listed
+   * as active for the toolbox and has its related devtools about:config preference set
+   * to true.
+   * @see browser/components/extensions/ext-devtools.js
+   */
+  isWebExtensionEnabled(extensionUUID) {
+    const extInfo = this._webExtensions.get(extensionUUID);
+    return extInfo && Services.prefs.getBoolPref(extInfo.pref, false);
+  },
+
+  /**
+   * Returns a panel id in the case of built in panels or "other" in the case of
+   * third party panels. This is necessary due to limitations in addon id strings,
+   * the permitted length of event telemetry property values and what we actually
+   * want to see in our telemetry.
+   *
+   * @param {String} id
+   *        The panel id we would like to process.
+   */
+  getTelemetryPanelNameOrOther(id) {
+    if (!this._toolNames) {
+      const definitions = gDevTools.getToolDefinitionArray();
+      const definitionIds = definitions.map(definition => definition.id);
+
+      this._toolNames = new Set(definitionIds);
+    }
+
+    if (!this._toolNames.has(id)) {
+      return "other";
+    }
+
+    return id;
+  },
+
+  /**
+   * Sets basic information on the DebugTargetInfo component
+   */
+  _setDebugTargetData() {
+    // Note that local WebExtension are debugged via WINDOW host,
+    // but we still want to display target data.
+    if (
+      this.hostType === Toolbox.HostType.PAGE ||
+      this._descriptorFront.isWebExtensionDescriptor
+    ) {
+      // Displays DebugTargetInfo which shows the basic information of debug target,
+      // if `about:devtools-toolbox` URL opens directly.
+      // DebugTargetInfo requires this._debugTargetData to be populated
+      this.component.setDebugTargetData(this._getDebugTargetData());
+    }
+  },
+
+  _onResourceAvailable(resources) {
+    let errors = this._errorCount || 0;
+
+    const { TYPES } = this.resourceCommand;
+    for (const resource of resources) {
+      const { resourceType } = resource;
+      if (
+        resourceType === TYPES.ERROR_MESSAGE &&
+        // ERROR_MESSAGE resources can be warnings/info, but here we only want to count errors
+        resource.pageError.error
+      ) {
+        errors++;
+        continue;
+      }
+
+      if (resourceType === TYPES.CONSOLE_MESSAGE) {
+        const { level } = resource.message;
+        if (level === "error" || level === "exception" || level === "assert") {
+          errors++;
+        }
+
+        // Reset the count on console.clear
+        if (level === "clear") {
+          errors = 0;
+        }
+      }
+
+      // Only consider top level document, and ignore remote iframes top document
+      if (
+        resourceType === TYPES.DOCUMENT_EVENT &&
+        resource.name === "will-navigate" &&
+        resource.targetFront.isTopLevel
+      ) {
+        this._onWillNavigate({
+          isFrameSwitching: resource.isFrameSwitching,
+        });
+        // While we will call `setErrorCount(0)` from onWillNavigate, we also need to reset
+        // `errors` local variable in order to clear previous errors processed in the same
+        // throttling bucket as this will-navigate resource.
+        errors = 0;
+      }
+
+      if (
+        resourceType === TYPES.DOCUMENT_EVENT &&
+        !resource.isFrameSwitching &&
+        // `url` is set on the targetFront when we receive dom-loading, and `title` when
+        // `dom-interactive` is received. Here we're only updating the window title in
+        // the "newer" event.
+        resource.name === "dom-interactive"
+      ) {
+        // the targetFront title and url are updated on dom-interactive, so delay refreshing
+        // the host title a bit in order for the event listener in targetCommand to be
+        // executed.
+        setTimeout(() => {
+          this._updateFrames({
+            frameData: {
+              id: resource.targetFront.actorID,
+              url: resource.targetFront.url,
+              title: resource.targetFront.title,
+            },
+          });
+
+          if (resource.targetFront.isTopLevel) {
+            this._refreshHostTitle();
+            this._setDebugTargetData();
+          }
+        }, 0);
+      }
+
+      if (resourceType == TYPES.THREAD_STATE) {
+        this._onThreadStateChanged(resource);
+      }
+    }
+
+    this.setErrorCount(errors);
+  },
+
+  _onResourceUpdated(resources) {
+    let errors = this._errorCount || 0;
+
+    for (const { update } of resources) {
+      // In order to match webconsole behaviour, we treat 4xx and 5xx network calls as errors.
+      if (
+        update.resourceType === this.resourceCommand.TYPES.NETWORK_EVENT &&
+        update.resourceUpdates.status &&
+        update.resourceUpdates.status.toString().match(REGEX_4XX_5XX)
+      ) {
+        errors++;
+      }
+    }
+
+    this.setErrorCount(errors);
+  },
+
+  /**
+   * Set the number of errors in the toolbar icon.
+   *
+   * @param {Number} count
+   */
+  setErrorCount(count) {
+    // Don't re-render if the number of errors changed
+    if (!this.component || this._errorCount === count) {
+      return;
+    }
+
+    this._errorCount = count;
+
+    // Update button properties and trigger a render of the toolbox
+    this.updateErrorCountButton();
+    this._throttledSetToolboxButtons();
+  },
+};