--- a/devtools/client/framework/toolbox.js
+++ b/devtools/client/framework/toolbox.js
@@ -9,17 +9,17 @@ const SPLITCONSOLE_ENABLED_PREF = "devto
const SPLITCONSOLE_HEIGHT_PREF = "devtools.toolbox.splitconsoleHeight";
const OS_HISTOGRAM = "DEVTOOLS_OS_ENUMERATED_PER_USER";
const OS_IS_64_BITS = "DEVTOOLS_OS_IS_64_BITS_PER_USER";
const HOST_HISTOGRAM = "DEVTOOLS_TOOLBOX_HOST";
const SCREENSIZE_HISTOGRAM = "DEVTOOLS_SCREEN_RESOLUTION_ENUMERATED_PER_USER";
const HTML_NS = "http://www.w3.org/1999/xhtml";
const { SourceMapService } = require("./source-map-service");
-var {Cc, Ci, Cu} = require("chrome");
+var {Ci, Cu} = require("chrome");
var promise = require("promise");
var defer = require("devtools/shared/defer");
var Services = require("Services");
var {Task} = require("devtools/shared/task");
var {gDevTools} = require("devtools/client/framework/devtools");
var EventEmitter = require("devtools/shared/event-emitter");
var Telemetry = require("devtools/client/shared/telemetry");
var HUDService = require("devtools/client/webconsole/hudservice");
@@ -230,18 +230,18 @@ Toolbox.prototype = {
* A promise that resolves once the panel is ready.
*/
getPanelWhenReady: function (id) {
let deferred = defer();
let panel = this.getPanel(id);
if (panel) {
deferred.resolve(panel);
} else {
- this.on(id + "-ready", (e, panel) => {
- deferred.resolve(panel);
+ this.on(id + "-ready", (e, initializedPanel) => {
+ deferred.resolve(initializedPanel);
});
}
return deferred.promise;
},
/**
* This is a shortcut for getPanel(currentToolId) because it is much more
@@ -401,17 +401,17 @@ Toolbox.prototype = {
let noautohideMenu = this.doc.getElementById("command-button-noautohide");
noautohideMenu.addEventListener("click", this._toggleAutohide, true);
this.textboxContextMenuPopup =
this.doc.getElementById("toolbox-textbox-context-popup");
this.textboxContextMenuPopup.addEventListener("popupshowing",
this._updateTextboxMenuItems, true);
- var shortcuts = new KeyShortcuts({
+ let shortcuts = new KeyShortcuts({
window: this.doc.defaultView
});
this._buildDockButtons();
this._buildOptions(shortcuts);
this._buildTabs();
this._applyCacheSettings();
this._applyServiceWorkersTestingSettings();
this._addKeysToWindow();
@@ -497,17 +497,18 @@ Toolbox.prototype = {
},
_pingTelemetry: function () {
this._telemetry.toolOpened("toolbox");
this._telemetry.logOncePerBrowserVersion(OS_HISTOGRAM, system.getOSCPU());
this._telemetry.logOncePerBrowserVersion(OS_IS_64_BITS,
Services.appinfo.is64Bit ? 1 : 0);
- this._telemetry.logOncePerBrowserVersion(SCREENSIZE_HISTOGRAM, system.getScreenDimensions());
+ this._telemetry.logOncePerBrowserVersion(SCREENSIZE_HISTOGRAM,
+ system.getScreenDimensions());
this._telemetry.log(HOST_HISTOGRAM, this._getTelemetryHostId());
},
/**
* Because our panels are lazy loaded this is a good place to watch for
* "pref-changed" events.
* @param {String} event
* The event type, "pref-changed".
@@ -973,37 +974,38 @@ Toolbox.prototype = {
const options = {
environment: CommandUtils.createEnvironment(this, "_target")
};
return CommandUtils.createRequisition(this.target, options).then(requisition => {
this._requisition = requisition;
const spec = CommandUtils.getCommandbarSpec("devtools.toolbox.toolbarSpec");
- return CommandUtils.createButtons(spec, this.target, this.doc,
- requisition).then(buttons => {
- let container = this.doc.getElementById("toolbox-buttons");
- buttons.forEach(button=> {
- if (button) {
- container.appendChild(button);
- }
- });
- this.setToolboxButtonsVisibility();
- });
+ return CommandUtils.createButtons(spec, this.target, this.doc, requisition)
+ .then(buttons => {
+ let container = this.doc.getElementById("toolbox-buttons");
+ buttons.forEach(button => {
+ if (button) {
+ container.appendChild(button);
+ }
+ });
+ this.setToolboxButtonsVisibility();
+ });
});
},
/**
* Adding the element picker button is done here unlike the other buttons
* since we want it to work for remote targets too
*/
_buildPickerButton: function () {
this._pickerButton = this.doc.createElementNS(HTML_NS, "button");
this._pickerButton.id = "command-button-pick";
- this._pickerButton.className = "command-button command-button-invertable devtools-button";
+ this._pickerButton.className =
+ "command-button command-button-invertable devtools-button";
this._pickerButton.setAttribute("title", L10N.getStr("pickButton.tooltip"));
this._pickerButton.setAttribute("hidden", "true");
let container = this.doc.querySelector("#toolbox-picker-container");
container.appendChild(this._pickerButton);
this._togglePicker = this.highlighterUtils.togglePicker.bind(this.highlighterUtils);
this._pickerButton.addEventListener("click", this._togglePicker, false);
@@ -1079,17 +1081,19 @@ Toolbox.prototype = {
* preference value. Simply hide buttons that are preffed off.
*/
setToolboxButtonsVisibility: function () {
this.toolboxButtons.forEach(buttonSpec => {
let { visibilityswitch, button, isTargetSupported } = buttonSpec;
let on = true;
try {
on = Services.prefs.getBoolPref(visibilityswitch);
- } catch (ex) { }
+ } catch (ex) {
+ // Do nothing.
+ }
on = on && isTargetSupported(this.target);
if (button) {
if (on) {
button.removeAttribute("hidden");
} else {
button.setAttribute("hidden", "true");
@@ -1225,18 +1229,18 @@ Toolbox.prototype = {
let deferred = defer();
let iframe = this.doc.getElementById("toolbox-panel-iframe-" + id);
if (iframe) {
let panel = this._toolPanels.get(id);
if (panel) {
deferred.resolve(panel);
} else {
- this.once(id + "-ready", panel => {
- deferred.resolve(panel);
+ this.once(id + "-ready", initializedPanel => {
+ deferred.resolve(initializedPanel);
});
}
return deferred.promise;
}
let definition = gDevTools.getToolDefinition(id);
if (!definition) {
deferred.reject(new Error("no such tool id " + id));
@@ -1597,17 +1601,17 @@ Toolbox.prototype = {
title = L10N.getFormatStr("toolbox.titleTemplate1", this.target.url);
}
this._host.setTitle(title);
},
// Returns an instance of the preference actor
get _preferenceFront() {
return this.target.root.then(rootForm => {
- return new getPreferenceFront(this.target.client, rootForm);
+ return getPreferenceFront(this.target.client, rootForm);
});
},
_toggleAutohide: Task.async(function* () {
let prefName = "ui.popup.disable_autohide";
let front = yield this._preferenceFront;
let current = yield front.getBoolPref(prefName);
yield front.setBoolPref(prefName, !current);
@@ -1949,19 +1953,19 @@ Toolbox.prototype = {
/**
* Initialize the inspector/walker/selection/highlighter fronts.
* Returns a promise that resolves when the fronts are initialized
*/
initInspector: function () {
if (!this._initInspector) {
this._initInspector = Task.spawn(function* () {
this._inspector = InspectorFront(this._target.client, this._target.form);
- this._walker = yield this._inspector.getWalker(
- {showAllAnonymousContent: Services.prefs.getBoolPref("devtools.inspector.showAllAnonymousContent")}
- );
+ let pref = "devtools.inspector.showAllAnonymousContent";
+ let showAllAnonymousContent = Services.prefs.getBoolPref(pref);
+ this._walker = yield this._inspector.getWalker({ showAllAnonymousContent });
this._selection = new Selection(this._walker);
if (this.highlighterUtils.isRemoteHighlightable()) {
this.walker.on("highlighter-ready", this._highlighterReady);
this.walker.on("highlighter-hide", this._highlighterHidden);
let autohide = !flags.testing;
this._highlighter = yield this._inspector.getHighlighter(autohide);
@@ -1975,29 +1979,31 @@ Toolbox.prototype = {
* Destroy the inspector/walker/selection fronts
* Returns a promise that resolves when the fronts are destroyed
*/
destroyInspector: function () {
if (this._destroyingInspector) {
return this._destroyingInspector;
}
- return this._destroyingInspector = Task.spawn(function* () {
+ this._destroyingInspector = Task.spawn(function* () {
if (!this._inspector) {
return;
}
// Releasing the walker (if it has been created)
// This can fail, but in any case, we want to continue destroying the
// inspector/highlighter/selection
// FF42+: Inspector actor starts managing Walker actor and auto destroy it.
if (this._walker && !this.walker.traits.autoReleased) {
try {
yield this._walker.release();
- } catch (e) {}
+ } catch (e) {
+ // Do nothing;
+ }
}
yield this.highlighterUtils.stopPicker();
yield this._inspector.destroy();
if (this._highlighter) {
// Note that if the toolbox is closed, this will work fine, but will fail
// in case the browser is closed and will trigger a noSuchActor message.
// We ignore the promise that |_hideBoxModel| returns, since we should still
@@ -2017,16 +2023,17 @@ Toolbox.prototype = {
this.walker.off("highlighter-hide", this._highlighterHidden);
}
this._inspector = null;
this._highlighter = null;
this._selection = null;
this._walker = null;
}.bind(this));
+ return this._destroyingInspector;
},
/**
* Get the toolbox's notification component
*
* @return The notification box component.
*/
getNotificationBox: function () {
@@ -2220,17 +2227,17 @@ Toolbox.prototype = {
/**
* Connects to the SPS profiler when the developer tools are open. This is
* necessary because of the WebConsole's `profile` and `profileEnd` methods.
*/
initPerformance: Task.async(function* () {
// If target does not have profiler actor (addons), do not
// even register the shared performance connection.
if (!this.target.hasActor("profiler")) {
- return;
+ return promise.resolve();
}
if (this._performanceFrontConnection) {
return this._performanceFrontConnection.promise;
}
this._performanceFrontConnection = defer();
this._performance = createPerformanceFront(this._target);
@@ -2259,28 +2266,30 @@ Toolbox.prototype = {
yield this._performanceFrontConnection.promise;
}
this.performance.off("*", this._onPerformanceFrontEvent);
yield this.performance.destroy();
this._performance = null;
}),
/**
- * Called when any event comes from the PerformanceFront. If the performance tool is already
- * loaded when the first event comes in, immediately unbind this handler, as this is
- * only used to queue up observed recordings before the performance tool can handle them,
- * which will only occur when `console.profile()` recordings are started before the tool loads.
+ * Called when any event comes from the PerformanceFront. If the performance tool is
+ * already loaded when the first event comes in, immediately unbind this handler, as
+ * this is only used to queue up observed recordings before the performance tool can
+ * handle them, which will only occur when `console.profile()` recordings are started
+ * before the tool loads.
*/
_onPerformanceFrontEvent: Task.async(function* (eventName, recording) {
if (this.getPanel("performance")) {
this.performance.off("*", this._onPerformanceFrontEvent);
return;
}
- let recordings = this._performanceQueuedRecordings = this._performanceQueuedRecordings || [];
+ this._performanceQueuedRecordings = this._performanceQueuedRecordings || [];
+ let recordings = this._performanceQueuedRecordings;
// Before any console recordings, we'll get a `console-profile-start` event
// warning us that a recording will come later (via `recording-started`), so
// start to boot up the tool and populate the tool with any other recordings
// observed during that time.
if (eventName === "console-profile-start" && !this._performanceToolOpenedViaConsole) {
this._performanceToolOpenedViaConsole = this.loadTool("performance");
let panel = yield this._performanceToolOpenedViaConsole;