forked from mirrors/gecko-dev
621bf1a656
Backed out changeset 481558275c1d (bug 1651518) Backed out changeset 5337435e8bca (bug 1651518) Backed out changeset 8fe0c1a4da7f (bug 1651518) Backed out changeset 840a0d9db260 (bug 1651518) Backed out changeset eaab9de5819d (bug 1651518) Backed out changeset cf71de92d782 (bug 1651518) Backed out changeset d778691464db (bug 1651518) Backed out changeset af28e5f719e8 (bug 1883847)
1408 lines
47 KiB
JavaScript
1408 lines
47 KiB
JavaScript
/* 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/. */
|
|
|
|
/**
|
|
* This XPCOM component is loaded very early.
|
|
* Be careful to lazy load dependencies as much as possible.
|
|
*
|
|
* It manages all the possible entry points for DevTools:
|
|
* - Handles command line arguments like -jsconsole,
|
|
* - Register all key shortcuts,
|
|
* - Listen for "Browser Tools" system menu opening, under "Tools",
|
|
* - Inject the wrench icon in toolbar customization, which is used
|
|
* by the "Browser Tools" list displayed in the hamburger menu,
|
|
* - Register the JSON Viewer protocol handler.
|
|
* - Inject the profiler recording button in toolbar customization.
|
|
*
|
|
* Only once any of these entry point is fired, this module ensures starting
|
|
* core modules like 'devtools-browser.js' that hooks the browser windows
|
|
* and ensure setting up tools.
|
|
**/
|
|
|
|
const kDebuggerPrefs = [
|
|
"devtools.debugger.remote-enabled",
|
|
"devtools.chrome.enabled",
|
|
];
|
|
|
|
const DEVTOOLS_POLICY_DISABLED_PREF = "devtools.policy.disabled";
|
|
|
|
import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
|
|
|
|
const lazy = {};
|
|
ChromeUtils.defineESModuleGetters(lazy, {
|
|
CustomizableUI: "resource:///modules/CustomizableUI.sys.mjs",
|
|
CustomizableWidgets: "resource:///modules/CustomizableWidgets.sys.mjs",
|
|
PanelMultiView: "resource:///modules/PanelMultiView.sys.mjs",
|
|
PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
|
|
ProfilerMenuButton:
|
|
"resource://devtools/client/performance-new/popup/menu-button.sys.mjs",
|
|
WebChannel: "resource://gre/modules/WebChannel.sys.mjs",
|
|
});
|
|
|
|
// We don't want to spend time initializing the full loader here so we create
|
|
// our own lazy require.
|
|
ChromeUtils.defineLazyGetter(lazy, "Telemetry", function () {
|
|
const { require } = ChromeUtils.importESModule(
|
|
"resource://devtools/shared/loader/Loader.sys.mjs"
|
|
);
|
|
// eslint-disable-next-line no-shadow
|
|
const Telemetry = require("devtools/client/shared/telemetry");
|
|
|
|
return Telemetry;
|
|
});
|
|
|
|
ChromeUtils.defineLazyGetter(lazy, "KeyShortcutsBundle", function () {
|
|
return new Localization(["devtools/startup/key-shortcuts.ftl"], true);
|
|
});
|
|
|
|
/**
|
|
* Safely retrieve a localized DevTools key shortcut from KeyShortcutsBundle.
|
|
* If the shortcut is not available, this will return null. Consumer code
|
|
* should rely on this to skip unavailable shortcuts.
|
|
*
|
|
* Note that all shortcuts should always be available, but there is a notable
|
|
* exception, which is why we have to do this. When a localization change is
|
|
* uplifted to beta, language packs will not be updated immediately when the
|
|
* updated beta is available.
|
|
*
|
|
* This means that language pack users might get a new Beta version but will not
|
|
* have a language pack with the new strings yet.
|
|
*/
|
|
function getLocalizedKeyShortcut(id) {
|
|
try {
|
|
return lazy.KeyShortcutsBundle.formatValueSync(id);
|
|
} catch (e) {
|
|
console.error("Failed to retrieve DevTools localized shortcut for id", id);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
ChromeUtils.defineLazyGetter(lazy, "KeyShortcuts", function () {
|
|
const isMac = AppConstants.platform == "macosx";
|
|
|
|
// Common modifier shared by most key shortcuts
|
|
const modifiers = isMac ? "accel,alt" : "accel,shift";
|
|
|
|
// List of all key shortcuts triggering installation UI
|
|
// `id` should match tool's id from client/definitions.js
|
|
const shortcuts = [
|
|
// The following keys are also registered in /client/menus.js
|
|
// And should be synced.
|
|
|
|
// Both are toggling the toolbox on the last selected panel
|
|
// or the default one.
|
|
{
|
|
id: "toggleToolbox",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-toggle-toolbox"),
|
|
modifiers,
|
|
},
|
|
// All locales are using F12
|
|
{
|
|
id: "toggleToolboxF12",
|
|
shortcut: getLocalizedKeyShortcut(
|
|
"devtools-commandkey-toggle-toolbox-f12"
|
|
),
|
|
modifiers: "", // F12 is the only one without modifiers
|
|
},
|
|
// Open the Browser Toolbox
|
|
{
|
|
id: "browserToolbox",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-browser-toolbox"),
|
|
modifiers: "accel,alt,shift",
|
|
},
|
|
// Open the Browser Console
|
|
{
|
|
id: "browserConsole",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-browser-console"),
|
|
modifiers: "accel,shift",
|
|
},
|
|
// Toggle the Responsive Design Mode
|
|
{
|
|
id: "responsiveDesignMode",
|
|
shortcut: getLocalizedKeyShortcut(
|
|
"devtools-commandkey-responsive-design-mode"
|
|
),
|
|
modifiers,
|
|
},
|
|
// The following keys are also registered in /client/definitions.js
|
|
// and should be synced.
|
|
|
|
// Key for opening the Inspector
|
|
{
|
|
toolId: "inspector",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-inspector"),
|
|
modifiers,
|
|
},
|
|
// Key for opening the Web Console
|
|
{
|
|
toolId: "webconsole",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-webconsole"),
|
|
modifiers,
|
|
},
|
|
// Key for opening the Debugger
|
|
{
|
|
toolId: "jsdebugger",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-jsdebugger"),
|
|
modifiers,
|
|
},
|
|
// Key for opening the Network Monitor
|
|
{
|
|
toolId: "netmonitor",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-netmonitor"),
|
|
modifiers,
|
|
},
|
|
// Key for opening the Style Editor
|
|
{
|
|
toolId: "styleeditor",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-styleeditor"),
|
|
modifiers: "shift",
|
|
},
|
|
// Key for opening the Performance Panel
|
|
{
|
|
toolId: "performance",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-performance"),
|
|
modifiers: "shift",
|
|
},
|
|
// Key for opening the Storage Panel
|
|
{
|
|
toolId: "storage",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-storage"),
|
|
modifiers: "shift",
|
|
},
|
|
// Key for opening the DOM Panel
|
|
{
|
|
toolId: "dom",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-dom"),
|
|
modifiers,
|
|
},
|
|
// Key for opening the Accessibility Panel
|
|
{
|
|
toolId: "accessibility",
|
|
shortcut: getLocalizedKeyShortcut(
|
|
"devtools-commandkey-accessibility-f12"
|
|
),
|
|
modifiers: "shift",
|
|
},
|
|
];
|
|
|
|
if (isMac) {
|
|
// Add the extra key command for macOS, so you can open the inspector with cmd+shift+C
|
|
// like on Chrome DevTools.
|
|
shortcuts.push({
|
|
id: "inspectorMac",
|
|
toolId: "inspector",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-inspector"),
|
|
modifiers: "accel,shift",
|
|
});
|
|
}
|
|
|
|
if (lazy.ProfilerMenuButton.isInNavbar()) {
|
|
shortcuts.push(...getProfilerKeyShortcuts());
|
|
}
|
|
|
|
// Allow toggling the JavaScript tracing not only from DevTools UI,
|
|
// but also from the web page when it is focused.
|
|
if (
|
|
Services.prefs.getBoolPref(
|
|
"devtools.debugger.features.javascript-tracing",
|
|
false
|
|
)
|
|
) {
|
|
shortcuts.push({
|
|
id: "javascriptTracingToggle",
|
|
shortcut: getLocalizedKeyShortcut(
|
|
"devtools-commandkey-javascript-tracing-toggle"
|
|
),
|
|
modifiers: "control,shift",
|
|
});
|
|
}
|
|
|
|
return shortcuts;
|
|
});
|
|
|
|
function getProfilerKeyShortcuts() {
|
|
return [
|
|
// Start/stop the profiler
|
|
{
|
|
id: "profilerStartStop",
|
|
shortcut: getLocalizedKeyShortcut(
|
|
"devtools-commandkey-profiler-start-stop"
|
|
),
|
|
modifiers: "control,shift",
|
|
},
|
|
// Capture a profile
|
|
{
|
|
id: "profilerCapture",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-profiler-capture"),
|
|
modifiers: "control,shift",
|
|
},
|
|
// Because it's not uncommon for content or extension to bind this
|
|
// shortcut, allow using alt as well for starting and stopping the profiler
|
|
{
|
|
id: "profilerStartStopAlternate",
|
|
shortcut: getLocalizedKeyShortcut(
|
|
"devtools-commandkey-profiler-start-stop"
|
|
),
|
|
modifiers: "control,shift,alt",
|
|
},
|
|
{
|
|
id: "profilerCaptureAlternate",
|
|
shortcut: getLocalizedKeyShortcut("devtools-commandkey-profiler-capture"),
|
|
modifiers: "control,shift,alt",
|
|
},
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Validate the URL that will be used for the WebChannel for the profiler.
|
|
*
|
|
* @param {string} targetUrl
|
|
* @returns {string}
|
|
*/
|
|
export function validateProfilerWebChannelUrl(targetUrl) {
|
|
const frontEndUrl = "https://profiler.firefox.com";
|
|
|
|
if (targetUrl !== frontEndUrl) {
|
|
// The user can specify either localhost or deploy previews as well as
|
|
// the official frontend URL for testing.
|
|
if (
|
|
// Allow a test URL.
|
|
/^https?:\/\/example\.com$/.test(targetUrl) ||
|
|
// Allows the following:
|
|
// "http://localhost:4242"
|
|
// "http://localhost:4242/"
|
|
// "http://localhost:3"
|
|
// "http://localhost:334798455"
|
|
/^http:\/\/localhost:\d+\/?$/.test(targetUrl) ||
|
|
// Allows the following:
|
|
// "https://deploy-preview-1234--perf-html.netlify.com"
|
|
// "https://deploy-preview-1234--perf-html.netlify.com/"
|
|
// "https://deploy-preview-1234567--perf-html.netlify.app"
|
|
// "https://main--perf-html.netlify.app"
|
|
/^https:\/\/(?:deploy-preview-\d+|main)--perf-html\.netlify\.(?:com|app)\/?$/.test(
|
|
targetUrl
|
|
)
|
|
) {
|
|
// This URL is one of the allowed ones to be used for configuration.
|
|
return targetUrl;
|
|
}
|
|
|
|
console.error(
|
|
`The preference "devtools.performance.recording.ui-base-url" was set to a ` +
|
|
"URL that is not allowed. No WebChannel messages will be sent between the " +
|
|
`browser and that URL. Falling back to ${frontEndUrl}. Only localhost ` +
|
|
"and deploy previews URLs are allowed.",
|
|
targetUrl
|
|
);
|
|
}
|
|
|
|
return frontEndUrl;
|
|
}
|
|
|
|
ChromeUtils.defineLazyGetter(lazy, "ProfilerPopupBackground", function () {
|
|
return ChromeUtils.importESModule(
|
|
"resource://devtools/client/performance-new/shared/background.sys.mjs"
|
|
);
|
|
});
|
|
|
|
export function DevToolsStartup() {
|
|
this.onWindowReady = this.onWindowReady.bind(this);
|
|
this.addDevToolsItemsToSubview = this.addDevToolsItemsToSubview.bind(this);
|
|
this.onMoreToolsViewShowing = this.onMoreToolsViewShowing.bind(this);
|
|
this.toggleProfilerKeyShortcuts = this.toggleProfilerKeyShortcuts.bind(this);
|
|
}
|
|
|
|
DevToolsStartup.prototype = {
|
|
/**
|
|
* Boolean flag to check if DevTools have been already initialized or not.
|
|
* By initialized, we mean that its main modules are loaded.
|
|
*/
|
|
initialized: false,
|
|
|
|
/**
|
|
* Boolean flag to check if the devtools initialization was already sent to telemetry.
|
|
* We only want to record one devtools entry point per Firefox run, but we are not
|
|
* interested in all the entry points.
|
|
*/
|
|
recorded: false,
|
|
|
|
get telemetry() {
|
|
if (!this._telemetry) {
|
|
this._telemetry = new lazy.Telemetry();
|
|
this._telemetry.setEventRecordingEnabled(true);
|
|
}
|
|
return this._telemetry;
|
|
},
|
|
|
|
/**
|
|
* Flag that indicates if the developer toggle was already added to customizableUI.
|
|
*/
|
|
developerToggleCreated: false,
|
|
|
|
/**
|
|
* Flag that indicates if the profiler recording popup was already added to
|
|
* customizableUI.
|
|
*/
|
|
profilerRecordingButtonCreated: false,
|
|
|
|
isDisabledByPolicy() {
|
|
return Services.prefs.getBoolPref(DEVTOOLS_POLICY_DISABLED_PREF, false);
|
|
},
|
|
|
|
handle(cmdLine) {
|
|
const flags = this.readCommandLineFlags(cmdLine);
|
|
|
|
// handle() can be called after browser startup (e.g. opening links from other apps).
|
|
const isInitialLaunch =
|
|
cmdLine.state == Ci.nsICommandLine.STATE_INITIAL_LAUNCH;
|
|
if (isInitialLaunch) {
|
|
// Store devtoolsFlag to check it later in onWindowReady.
|
|
this.devtoolsFlag = flags.devtools;
|
|
|
|
/* eslint-disable mozilla/balanced-observers */
|
|
// We are not expecting to remove those listeners until Firefox closes.
|
|
|
|
// Only top level Firefox Windows fire a browser-delayed-startup-finished event
|
|
Services.obs.addObserver(
|
|
this.onWindowReady,
|
|
"browser-delayed-startup-finished"
|
|
);
|
|
|
|
// Add DevTools menu items to the "More Tools" view.
|
|
Services.obs.addObserver(
|
|
this.onMoreToolsViewShowing,
|
|
"web-developer-tools-view-showing"
|
|
);
|
|
/* eslint-enable mozilla/balanced-observers */
|
|
|
|
if (!this.isDisabledByPolicy()) {
|
|
if (AppConstants.MOZ_DEV_EDITION) {
|
|
// On DevEdition, the developer toggle is displayed by default in the navbar
|
|
// area and should be created before the first paint.
|
|
this.hookDeveloperToggle();
|
|
}
|
|
|
|
this.hookProfilerRecordingButton();
|
|
}
|
|
}
|
|
|
|
if (flags.console) {
|
|
this.commandLine = true;
|
|
this.handleConsoleFlag(cmdLine);
|
|
}
|
|
if (flags.debugger) {
|
|
this.commandLine = true;
|
|
const binaryPath =
|
|
typeof flags.debugger == "string" ? flags.debugger : null;
|
|
this.handleDebuggerFlag(cmdLine, binaryPath);
|
|
}
|
|
|
|
if (flags.devToolsServer) {
|
|
this.handleDevToolsServerFlag(cmdLine, flags.devToolsServer);
|
|
}
|
|
|
|
// If Firefox is already opened, and DevTools are also already opened,
|
|
// try to open links passed via command line arguments.
|
|
if (!isInitialLaunch && this.initialized && cmdLine.length) {
|
|
this.checkForDebuggerLink(cmdLine);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Lookup in all arguments passed to firefox binary to find
|
|
* URLs including a precise location, like this:
|
|
* https://domain.com/file.js:1:10 (URL ending with `:${line}:${number}`)
|
|
* When such argument exists, try to open this source and precise location
|
|
* in the debugger.
|
|
*
|
|
* @param {nsICommandLine} cmdLine
|
|
*/
|
|
checkForDebuggerLink(cmdLine) {
|
|
const urlFlagIdx = cmdLine.findFlag("url", false);
|
|
// Bail out when there is no -url argument, or if that's last and so there is no URL after it.
|
|
if (urlFlagIdx == -1 && urlFlagIdx + 1 < cmdLine.length) {
|
|
return;
|
|
}
|
|
|
|
// The following code would only work if we have a top level browser window opened
|
|
const window = Services.wm.getMostRecentWindow("navigator:browser");
|
|
if (!window) {
|
|
return;
|
|
}
|
|
|
|
const urlParam = cmdLine.getArgument(urlFlagIdx + 1);
|
|
|
|
// Avoid processing valid url like:
|
|
// http://foo@user:123
|
|
// Note that when loading `http://foo.com` the URL of the default html page will be `http://foo.com/`.
|
|
// So that there will always be another `/` after `https://`
|
|
if (
|
|
(urlParam.startsWith("http://") || urlParam.startsWith("https://")) &&
|
|
urlParam.lastIndexOf("/") <= 7
|
|
) {
|
|
return;
|
|
}
|
|
|
|
let match = urlParam.match(/^(?<url>\w+:.+):(?<line>\d+):(?<column>\d+)$/);
|
|
if (!match) {
|
|
// fallback on only having the line when there is no column
|
|
match = urlParam.match(/^(?<url>\w+:.+):(?<line>\d+)?$/);
|
|
if (!match) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// line and column are supposed to be 1-based.
|
|
const { url, line, column } = match.groups;
|
|
|
|
// Debugger internal uses 0-based column number.
|
|
// NOTE: Non-debugger view-source doesn't use column number.
|
|
const columnOneBased = parseInt(column || 0, 10);
|
|
const columnZeroBased = columnOneBased > 0 ? columnOneBased - 1 : 0;
|
|
|
|
// If for any reason the final url is invalid, ignore it
|
|
try {
|
|
Services.io.newURI(url);
|
|
} catch (e) {
|
|
return;
|
|
}
|
|
|
|
const require = this.initDevTools("CommandLine");
|
|
const { gDevTools } = require("devtools/client/framework/devtools");
|
|
const toolbox = gDevTools.getToolboxForTab(window.gBrowser.selectedTab);
|
|
// Ignore the url if there is no devtools currently opened for the current tab
|
|
if (!toolbox) {
|
|
return;
|
|
}
|
|
|
|
// Avoid regular Firefox code from processing this argument,
|
|
// otherwise we would open the source in DevTools and in a new tab.
|
|
//
|
|
// /!\ This has to be called synchronously from the call to `DevToolsStartup.handle(cmdLine)`
|
|
// Otherwise the next command lines listener will interpret the argument redundantly.
|
|
cmdLine.removeArguments(urlFlagIdx, urlFlagIdx + 1);
|
|
|
|
// Avoid opening a new empty top level window if there is no more arguments
|
|
if (!cmdLine.length) {
|
|
cmdLine.preventDefault = true;
|
|
}
|
|
|
|
// Immediately focus the browser window in order, to focus devtools, or the view-source tab.
|
|
// Otherwise, without this, the terminal would still be the topmost window.
|
|
toolbox.win.focus();
|
|
|
|
// Note that the following method is async and returns a promise.
|
|
// But the current method has to be synchronous because of cmdLine.removeArguments.
|
|
// Also note that it will fallback to view-source when the source url isn't found in the debugger
|
|
toolbox.viewSourceInDebugger(
|
|
url,
|
|
parseInt(line, 10),
|
|
columnZeroBased,
|
|
null,
|
|
"CommandLine"
|
|
);
|
|
},
|
|
|
|
readCommandLineFlags(cmdLine) {
|
|
// All command line flags are disabled if DevTools are disabled by policy.
|
|
if (this.isDisabledByPolicy()) {
|
|
return {
|
|
console: false,
|
|
debugger: false,
|
|
devtools: false,
|
|
devToolsServer: false,
|
|
};
|
|
}
|
|
|
|
const console = cmdLine.handleFlag("jsconsole", false);
|
|
const devtools = cmdLine.handleFlag("devtools", false);
|
|
|
|
let devToolsServer;
|
|
try {
|
|
devToolsServer = cmdLine.handleFlagWithParam(
|
|
"start-debugger-server",
|
|
false
|
|
);
|
|
} catch (e) {
|
|
// We get an error if the option is given but not followed by a value.
|
|
// By catching and trying again, the value is effectively optional.
|
|
devToolsServer = cmdLine.handleFlag("start-debugger-server", false);
|
|
}
|
|
|
|
let debuggerFlag;
|
|
try {
|
|
debuggerFlag = cmdLine.handleFlagWithParam("jsdebugger", false);
|
|
} catch (e) {
|
|
// We get an error if the option is given but not followed by a value.
|
|
// By catching and trying again, the value is effectively optional.
|
|
debuggerFlag = cmdLine.handleFlag("jsdebugger", false);
|
|
}
|
|
|
|
return { console, debugger: debuggerFlag, devtools, devToolsServer };
|
|
},
|
|
|
|
/**
|
|
* Called when receiving the "browser-delayed-startup-finished" event for a new
|
|
* top-level window.
|
|
*/
|
|
onWindowReady(window) {
|
|
if (
|
|
this.isDisabledByPolicy() ||
|
|
AppConstants.MOZ_APP_NAME == "thunderbird"
|
|
) {
|
|
return;
|
|
}
|
|
|
|
this.hookWindow(window);
|
|
|
|
// This listener is called for all Firefox windows, but we want to execute some code
|
|
// only once.
|
|
if (!this._firstWindowReadyReceived) {
|
|
this.onFirstWindowReady(window);
|
|
this._firstWindowReadyReceived = true;
|
|
}
|
|
|
|
JsonView.initialize();
|
|
},
|
|
|
|
onFirstWindowReady(window) {
|
|
if (this.devtoolsFlag) {
|
|
this.handleDevToolsFlag(window);
|
|
|
|
// In the case of the --jsconsole and --jsdebugger command line parameters
|
|
// there was no browser window when they were processed so we act on the
|
|
// this.commandline flag instead.
|
|
if (this.commandLine) {
|
|
this.sendEntryPointTelemetry("CommandLine");
|
|
}
|
|
}
|
|
this.setSlowScriptDebugHandler();
|
|
},
|
|
|
|
/**
|
|
* Register listeners to all possible entry points for Developer Tools.
|
|
* But instead of implementing the actual actions, defer to DevTools codebase.
|
|
* In most cases, it only needs to call this.initDevTools which handles the rest.
|
|
* We do that to prevent loading any DevTools module until the user intent to use them.
|
|
*/
|
|
hookWindow(window) {
|
|
// Key Shortcuts need to be added on all the created windows.
|
|
this.hookKeyShortcuts(window);
|
|
|
|
// In some situations (e.g. starting Firefox with --jsconsole) DevTools will be
|
|
// initialized before the first browser-delayed-startup-finished event is received.
|
|
// We use a dedicated flag because we still need to hook the developer toggle.
|
|
this.hookDeveloperToggle();
|
|
this.hookProfilerRecordingButton();
|
|
|
|
// The developer menu hook only needs to be added if devtools have not been
|
|
// initialized yet.
|
|
if (!this.initialized) {
|
|
this.hookBrowserToolsMenu(window);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Dynamically register a wrench icon in the customization menu.
|
|
* You can use this button by right clicking on Firefox toolbar
|
|
* and dragging it from the customization panel to the toolbar.
|
|
* (i.e. this isn't displayed by default to users!)
|
|
*
|
|
* _But_, the "Browser Tools" entry in the hamburger menu (the menu with
|
|
* 3 horizontal lines), is using this "developer-button" view to populate
|
|
* its menu. So we have to register this button for the menu to work.
|
|
*
|
|
* Also, this menu duplicates its own entries from the "Browser Tools"
|
|
* menu in the system menu, under "Tools" main menu item. The system
|
|
* menu is being hooked by "hookBrowserToolsMenu" which ends up calling
|
|
* devtools/client/framework/browser-menus to create the items for real,
|
|
* initDevTools, from onViewShowing is also calling browser-menu.
|
|
*/
|
|
hookDeveloperToggle() {
|
|
if (this.developerToggleCreated) {
|
|
return;
|
|
}
|
|
|
|
const id = "developer-button";
|
|
const widget = lazy.CustomizableUI.getWidget(id);
|
|
if (widget && widget.provider == lazy.CustomizableUI.PROVIDER_API) {
|
|
return;
|
|
}
|
|
|
|
const panelviewId = "PanelUI-developer-tools";
|
|
const subviewId = "PanelUI-developer-tools-view";
|
|
|
|
const item = {
|
|
id,
|
|
type: "view",
|
|
viewId: panelviewId,
|
|
shortcutId: "key_toggleToolbox",
|
|
tooltiptext: "developer-button.tooltiptext2",
|
|
onViewShowing: event => {
|
|
const doc = event.target.ownerDocument;
|
|
const developerItems = lazy.PanelMultiView.getViewNode(doc, subviewId);
|
|
this.addDevToolsItemsToSubview(developerItems);
|
|
},
|
|
onInit(anchor) {
|
|
// Since onBeforeCreated already bails out when initialized, we can call
|
|
// it right away.
|
|
this.onBeforeCreated(anchor.ownerDocument);
|
|
},
|
|
onBeforeCreated: doc => {
|
|
// The developer toggle needs the "key_toggleToolbox" <key> element.
|
|
// In DEV EDITION, the toggle is added before 1st paint and hookKeyShortcuts() is
|
|
// not called yet when CustomizableUI creates the widget.
|
|
this.hookKeyShortcuts(doc.defaultView);
|
|
},
|
|
};
|
|
lazy.CustomizableUI.createWidget(item);
|
|
lazy.CustomizableWidgets.push(item);
|
|
|
|
this.developerToggleCreated = true;
|
|
},
|
|
|
|
addDevToolsItemsToSubview(subview) {
|
|
// Initialize DevTools to create all menuitems in the system menu before
|
|
// trying to copy them.
|
|
this.initDevTools("HamburgerMenu");
|
|
|
|
// Populate the subview with whatever menuitems are in the developer
|
|
// menu. We skip menu elements, because the menu panel has no way
|
|
// of dealing with those right now.
|
|
const doc = subview.ownerDocument;
|
|
const menu = doc.getElementById("menuWebDeveloperPopup");
|
|
const itemsToDisplay = [...menu.children];
|
|
|
|
lazy.CustomizableUI.clearSubview(subview);
|
|
lazy.CustomizableUI.fillSubviewFromMenuItems(itemsToDisplay, subview);
|
|
},
|
|
|
|
onMoreToolsViewShowing(moreToolsView) {
|
|
this.addDevToolsItemsToSubview(moreToolsView);
|
|
},
|
|
|
|
/**
|
|
* Register the profiler recording button. This button will be available
|
|
* in the customization palette for the Firefox toolbar. In addition, it can be
|
|
* enabled from profiler.firefox.com.
|
|
*/
|
|
hookProfilerRecordingButton() {
|
|
if (this.profilerRecordingButtonCreated) {
|
|
return;
|
|
}
|
|
const featureFlagPref = "devtools.performance.popup.feature-flag";
|
|
const isPopupFeatureFlagEnabled =
|
|
Services.prefs.getBoolPref(featureFlagPref);
|
|
this.profilerRecordingButtonCreated = true;
|
|
|
|
// Listen for messages from the front-end. This needs to happen even if the
|
|
// button isn't enabled yet. This will allow the front-end to turn on the
|
|
// popup for our users, regardless of if the feature is enabled by default.
|
|
this.initializeProfilerWebChannel();
|
|
|
|
if (isPopupFeatureFlagEnabled) {
|
|
// Initialize the CustomizableUI widget.
|
|
lazy.ProfilerMenuButton.initialize(this.toggleProfilerKeyShortcuts);
|
|
} else {
|
|
// The feature flag is not enabled, but watch for it to be enabled. If it is,
|
|
// initialize everything.
|
|
const enable = () => {
|
|
lazy.ProfilerMenuButton.initialize(this.toggleProfilerKeyShortcuts);
|
|
Services.prefs.removeObserver(featureFlagPref, enable);
|
|
};
|
|
Services.prefs.addObserver(featureFlagPref, enable);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Initialize the WebChannel for profiler.firefox.com. This function happens at
|
|
* startup, so care should be taken to minimize its performance impact. The WebChannel
|
|
* is a mechanism that is used to communicate between the browser, and front-end code.
|
|
*/
|
|
initializeProfilerWebChannel() {
|
|
let channel;
|
|
|
|
// Register a channel for the URL in preferences. Also update the WebChannel if
|
|
// the URL changes.
|
|
const urlPref = "devtools.performance.recording.ui-base-url";
|
|
|
|
// This method is only run once per Firefox instance, so it should not be
|
|
// strictly necessary to remove observers here.
|
|
// eslint-disable-next-line mozilla/balanced-observers
|
|
Services.prefs.addObserver(urlPref, registerWebChannel);
|
|
|
|
registerWebChannel();
|
|
|
|
function registerWebChannel() {
|
|
if (channel) {
|
|
channel.stopListening();
|
|
}
|
|
|
|
const urlForWebChannel = Services.io.newURI(
|
|
validateProfilerWebChannelUrl(Services.prefs.getStringPref(urlPref))
|
|
);
|
|
|
|
channel = new lazy.WebChannel("profiler.firefox.com", urlForWebChannel);
|
|
|
|
channel.listen((id, message, target) => {
|
|
// Defer loading the ProfilerPopupBackground script until it's absolutely needed,
|
|
// as this code path gets loaded at startup.
|
|
lazy.ProfilerPopupBackground.handleWebChannelMessage(
|
|
channel,
|
|
id,
|
|
message,
|
|
target
|
|
);
|
|
});
|
|
}
|
|
},
|
|
|
|
/*
|
|
* We listen to the "Browser Tools" system menu, which is under "Tools" main item.
|
|
* This menu item is hardcoded empty in Firefox UI. We listen for its opening to
|
|
* populate it lazily. Loading main DevTools module is going to populate it.
|
|
*/
|
|
hookBrowserToolsMenu(window) {
|
|
const menu = window.document.getElementById("browserToolsMenu");
|
|
const onPopupShowing = () => {
|
|
menu.removeEventListener("popupshowing", onPopupShowing);
|
|
this.initDevTools("SystemMenu");
|
|
};
|
|
menu.addEventListener("popupshowing", onPopupShowing);
|
|
},
|
|
|
|
/**
|
|
* Check if the user is a DevTools user by looking at our selfxss pref.
|
|
* This preference is incremented everytime the console is used (up to 5).
|
|
*
|
|
* @return {Boolean} true if the user can be considered as a devtools user.
|
|
*/
|
|
isDevToolsUser() {
|
|
const selfXssCount = Services.prefs.getIntPref("devtools.selfxss.count", 0);
|
|
return selfXssCount > 0;
|
|
},
|
|
|
|
hookKeyShortcuts(window) {
|
|
const doc = window.document;
|
|
|
|
// hookKeyShortcuts can be called both from hookWindow and from the developer toggle
|
|
// onBeforeCreated. Make sure shortcuts are only added once per window.
|
|
if (doc.getElementById("devtoolsKeyset")) {
|
|
return;
|
|
}
|
|
|
|
const keyset = doc.createXULElement("keyset");
|
|
keyset.setAttribute("id", "devtoolsKeyset");
|
|
|
|
this.attachKeys(doc, lazy.KeyShortcuts, keyset);
|
|
|
|
// Appending a <key> element is not always enough. The <keyset> needs
|
|
// to be detached and reattached to make sure the <key> is taken into
|
|
// account (see bug 832984).
|
|
const mainKeyset = doc.getElementById("mainKeyset");
|
|
mainKeyset.parentNode.insertBefore(keyset, mainKeyset);
|
|
},
|
|
|
|
/**
|
|
* This method attaches on the key elements to the devtools keyset.
|
|
*/
|
|
attachKeys(doc, keyShortcuts, keyset = doc.getElementById("devtoolsKeyset")) {
|
|
const window = doc.defaultView;
|
|
for (const key of keyShortcuts) {
|
|
if (!key.shortcut) {
|
|
// Shortcuts might be missing when a user relies on a language packs
|
|
// which is missing a recently uplifted shortcut. Language packs are
|
|
// typically updated a few days after a code uplift.
|
|
continue;
|
|
}
|
|
const xulKey = this.createKey(doc, key, () => this.onKey(window, key));
|
|
keyset.appendChild(xulKey);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* This method removes keys from the devtools keyset.
|
|
*/
|
|
removeKeys(doc, keyShortcuts) {
|
|
for (const key of keyShortcuts) {
|
|
const keyElement = doc.getElementById(this.getKeyElementId(key));
|
|
if (keyElement) {
|
|
keyElement.remove();
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* We only want to have the keyboard shortcuts active when the menu button is on.
|
|
* This function either adds or removes the elements.
|
|
* @param {boolean} isEnabled
|
|
*/
|
|
toggleProfilerKeyShortcuts(isEnabled) {
|
|
const profilerKeyShortcuts = getProfilerKeyShortcuts();
|
|
for (const { document } of Services.wm.getEnumerator(null)) {
|
|
const devtoolsKeyset = document.getElementById("devtoolsKeyset");
|
|
const mainKeyset = document.getElementById("mainKeyset");
|
|
|
|
if (!devtoolsKeyset || !mainKeyset) {
|
|
// There may not be devtools keyset on this window.
|
|
continue;
|
|
}
|
|
|
|
const areProfilerKeysPresent = !!document.getElementById(
|
|
"key_profilerStartStop"
|
|
);
|
|
if (isEnabled === areProfilerKeysPresent) {
|
|
// Don't double add or double remove the shortcuts.
|
|
continue;
|
|
}
|
|
if (isEnabled) {
|
|
this.attachKeys(document, profilerKeyShortcuts);
|
|
} else {
|
|
this.removeKeys(document, profilerKeyShortcuts);
|
|
}
|
|
// Appending a <key> element is not always enough. The <keyset> needs
|
|
// to be detached and reattached to make sure the <key> is taken into
|
|
// account (see bug 832984).
|
|
mainKeyset.parentNode.insertBefore(devtoolsKeyset, mainKeyset);
|
|
}
|
|
},
|
|
|
|
async onKey(window, key) {
|
|
try {
|
|
// The profiler doesn't care if DevTools is loaded, so provide a quick check
|
|
// first to bail out of checking if DevTools is available.
|
|
switch (key.id) {
|
|
case "profilerStartStop":
|
|
case "profilerStartStopAlternate": {
|
|
lazy.ProfilerPopupBackground.toggleProfiler("aboutprofiling");
|
|
return;
|
|
}
|
|
case "profilerCapture":
|
|
case "profilerCaptureAlternate": {
|
|
lazy.ProfilerPopupBackground.captureProfile("aboutprofiling");
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Ignore the following key shortcut if DevTools aren't yet opened.
|
|
// The key shortcut is registered in this core component in order to
|
|
// work even when the web page is focused.
|
|
if (key.id == "javascriptTracingToggle" && !this.initialized) {
|
|
return;
|
|
}
|
|
|
|
// Record the timing at which this event started in order to compute later in
|
|
// gDevTools.showToolbox, the complete time it takes to open the toolbox.
|
|
// i.e. especially take `initDevTools` into account.
|
|
const startTime = Cu.now();
|
|
const require = this.initDevTools("KeyShortcut", key);
|
|
const {
|
|
gDevToolsBrowser,
|
|
} = require("devtools/client/framework/devtools-browser");
|
|
await gDevToolsBrowser.onKeyShortcut(window, key, startTime);
|
|
} catch (e) {
|
|
console.error(`Exception while trigerring key ${key}: ${e}\n${e.stack}`);
|
|
}
|
|
},
|
|
|
|
getKeyElementId({ id, toolId }) {
|
|
return "key_" + (id || toolId);
|
|
},
|
|
|
|
// Create a <xul:key> DOM Element
|
|
createKey(doc, key, oncommand) {
|
|
const { shortcut, modifiers: mod } = key;
|
|
const k = doc.createXULElement("key");
|
|
k.id = this.getKeyElementId(key);
|
|
|
|
if (shortcut.startsWith("VK_")) {
|
|
k.setAttribute("keycode", shortcut);
|
|
if (shortcut.match(/^VK_\d$/)) {
|
|
// Add the event keydown attribute to ensure that shortcuts work for combinations
|
|
// such as ctrl shift 1.
|
|
k.setAttribute("event", "keydown");
|
|
}
|
|
} else {
|
|
k.setAttribute("key", shortcut);
|
|
}
|
|
|
|
if (mod) {
|
|
k.setAttribute("modifiers", mod);
|
|
}
|
|
|
|
k.addEventListener("command", oncommand);
|
|
|
|
return k;
|
|
},
|
|
|
|
initDevTools(reason, key = "") {
|
|
// In the case of the --jsconsole and --jsdebugger command line parameters
|
|
// there is no browser window yet so we don't send any telemetry yet.
|
|
if (reason !== "CommandLine") {
|
|
this.sendEntryPointTelemetry(reason, key);
|
|
}
|
|
|
|
this.initialized = true;
|
|
const { require } = ChromeUtils.importESModule(
|
|
"resource://devtools/shared/loader/Loader.sys.mjs"
|
|
);
|
|
// Ensure loading main devtools module that hooks up into browser UI
|
|
// and initialize all devtools machinery.
|
|
// eslint-disable-next-line import/no-unassigned-import
|
|
require("devtools/client/framework/devtools-browser");
|
|
return require;
|
|
},
|
|
|
|
handleConsoleFlag(cmdLine) {
|
|
const window = Services.wm.getMostRecentWindow("devtools:webconsole");
|
|
if (!window) {
|
|
const require = this.initDevTools("CommandLine");
|
|
const {
|
|
BrowserConsoleManager,
|
|
} = require("devtools/client/webconsole/browser-console-manager");
|
|
BrowserConsoleManager.toggleBrowserConsole().catch(console.error);
|
|
} else {
|
|
// the Browser Console was already open
|
|
window.focus();
|
|
}
|
|
|
|
if (cmdLine.state == Ci.nsICommandLine.STATE_REMOTE_AUTO) {
|
|
cmdLine.preventDefault = true;
|
|
}
|
|
},
|
|
|
|
// Open the toolbox on the selected tab once the browser starts up.
|
|
async handleDevToolsFlag(window) {
|
|
const require = this.initDevTools("CommandLine");
|
|
const { gDevTools } = require("devtools/client/framework/devtools");
|
|
await gDevTools.showToolboxForTab(window.gBrowser.selectedTab);
|
|
},
|
|
|
|
_isRemoteDebuggingEnabled() {
|
|
let remoteDebuggingEnabled = false;
|
|
try {
|
|
remoteDebuggingEnabled = kDebuggerPrefs.every(pref => {
|
|
return Services.prefs.getBoolPref(pref);
|
|
});
|
|
} catch (ex) {
|
|
console.error(ex);
|
|
return false;
|
|
}
|
|
if (!remoteDebuggingEnabled) {
|
|
const errorMsg =
|
|
"Could not run chrome debugger! You need the following " +
|
|
"prefs to be set to true: " +
|
|
kDebuggerPrefs.join(", ");
|
|
console.error(new Error(errorMsg));
|
|
// Dump as well, as we're doing this from a commandline, make sure people
|
|
// don't miss it:
|
|
dump(errorMsg + "\n");
|
|
}
|
|
return remoteDebuggingEnabled;
|
|
},
|
|
|
|
handleDebuggerFlag(cmdLine, binaryPath) {
|
|
if (!this._isRemoteDebuggingEnabled()) {
|
|
return;
|
|
}
|
|
|
|
let devtoolsThreadResumed = false;
|
|
const pauseOnStartup = cmdLine.handleFlag("wait-for-jsdebugger", false);
|
|
if (pauseOnStartup) {
|
|
const observe = function () {
|
|
devtoolsThreadResumed = true;
|
|
Services.obs.removeObserver(observe, "devtools-thread-ready");
|
|
};
|
|
Services.obs.addObserver(observe, "devtools-thread-ready");
|
|
}
|
|
|
|
const { BrowserToolboxLauncher } = ChromeUtils.importESModule(
|
|
"resource://devtools/client/framework/browser-toolbox/Launcher.sys.mjs"
|
|
);
|
|
// --jsdebugger $binaryPath is an helper alias to set MOZ_BROWSER_TOOLBOX_BINARY=$binaryPath
|
|
// See comment within BrowserToolboxLauncher.
|
|
// Setting it as an environment variable helps it being reused if we restart the browser via CmdOrCtrl+R
|
|
Services.env.set("MOZ_BROWSER_TOOLBOX_BINARY", binaryPath);
|
|
|
|
const browserToolboxLauncherConfig = {};
|
|
|
|
// If user passed the --jsdebugger in mochitests, we want to enable the
|
|
// multiprocess Browser Toolbox (by default it's parent process only)
|
|
if (Services.prefs.getBoolPref("devtools.testing", false)) {
|
|
browserToolboxLauncherConfig.forceMultiprocess = true;
|
|
}
|
|
BrowserToolboxLauncher.init(browserToolboxLauncherConfig);
|
|
|
|
if (pauseOnStartup) {
|
|
// Spin the event loop until the debugger connects.
|
|
const tm = Cc["@mozilla.org/thread-manager;1"].getService();
|
|
tm.spinEventLoopUntil("DevToolsStartup.jsm:handleDebuggerFlag", () => {
|
|
return devtoolsThreadResumed;
|
|
});
|
|
}
|
|
|
|
if (cmdLine.state == Ci.nsICommandLine.STATE_REMOTE_AUTO) {
|
|
cmdLine.preventDefault = true;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Handle the --start-debugger-server command line flag. The options are:
|
|
* --start-debugger-server
|
|
* The portOrPath parameter is boolean true in this case. Reads and uses the defaults
|
|
* from devtools.debugger.remote-port and devtools.debugger.remote-websocket prefs.
|
|
* The default values of these prefs are port 6000, WebSocket disabled.
|
|
*
|
|
* --start-debugger-server 6789
|
|
* Start the non-WebSocket server on port 6789.
|
|
*
|
|
* --start-debugger-server /path/to/filename
|
|
* Start the server on a Unix domain socket.
|
|
*
|
|
* --start-debugger-server ws:6789
|
|
* Start the WebSocket server on port 6789.
|
|
*
|
|
* --start-debugger-server ws:
|
|
* Start the WebSocket server on the default port (taken from d.d.remote-port)
|
|
*/
|
|
handleDevToolsServerFlag(cmdLine, portOrPath) {
|
|
if (!this._isRemoteDebuggingEnabled()) {
|
|
return;
|
|
}
|
|
|
|
let webSocket = false;
|
|
const defaultPort = Services.prefs.getIntPref(
|
|
"devtools.debugger.remote-port"
|
|
);
|
|
if (portOrPath === true) {
|
|
// Default to pref values if no values given on command line
|
|
webSocket = Services.prefs.getBoolPref(
|
|
"devtools.debugger.remote-websocket"
|
|
);
|
|
portOrPath = defaultPort;
|
|
} else if (portOrPath.startsWith("ws:")) {
|
|
webSocket = true;
|
|
const port = portOrPath.slice(3);
|
|
portOrPath = Number(port) ? port : defaultPort;
|
|
}
|
|
|
|
const {
|
|
useDistinctSystemPrincipalLoader,
|
|
releaseDistinctSystemPrincipalLoader,
|
|
} = ChromeUtils.importESModule(
|
|
"resource://devtools/shared/loader/DistinctSystemPrincipalLoader.sys.mjs"
|
|
);
|
|
|
|
try {
|
|
// Create a separate loader instance, so that we can be sure to receive
|
|
// a separate instance of the DebuggingServer from the rest of the
|
|
// devtools. This allows us to safely use the tools against even the
|
|
// actors and DebuggingServer itself, especially since we can mark
|
|
// serverLoader as invisible to the debugger (unlike the usual loader
|
|
// settings).
|
|
const serverLoader = useDistinctSystemPrincipalLoader(this);
|
|
const { DevToolsServer: devToolsServer } = serverLoader.require(
|
|
"resource://devtools/server/devtools-server.js"
|
|
);
|
|
const { SocketListener } = serverLoader.require(
|
|
"resource://devtools/shared/security/socket.js"
|
|
);
|
|
devToolsServer.init();
|
|
|
|
// Force the server to be kept running when the last connection closes.
|
|
// So that another client can connect after the previous one is disconnected.
|
|
devToolsServer.keepAlive = true;
|
|
|
|
devToolsServer.registerAllActors();
|
|
devToolsServer.allowChromeProcess = true;
|
|
const socketOptions = { portOrPath, webSocket };
|
|
|
|
const listener = new SocketListener(devToolsServer, socketOptions);
|
|
listener.open();
|
|
dump("Started devtools server on " + portOrPath + "\n");
|
|
|
|
// Prevent leaks on shutdown.
|
|
const close = () => {
|
|
Services.obs.removeObserver(close, "quit-application");
|
|
dump("Stopped devtools server on " + portOrPath + "\n");
|
|
if (listener) {
|
|
listener.close();
|
|
}
|
|
if (devToolsServer) {
|
|
devToolsServer.destroy();
|
|
}
|
|
releaseDistinctSystemPrincipalLoader(this);
|
|
};
|
|
Services.obs.addObserver(close, "quit-application");
|
|
} catch (e) {
|
|
dump("Unable to start devtools server on " + portOrPath + ": " + e);
|
|
}
|
|
|
|
if (cmdLine.state == Ci.nsICommandLine.STATE_REMOTE_AUTO) {
|
|
cmdLine.preventDefault = true;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Send entry point telemetry explaining how the devtools were launched. This
|
|
* functionality also lives inside `devtools/client/framework/browser-menus.js`
|
|
* because this codepath is only used the first time a toolbox is opened for a
|
|
* tab.
|
|
*
|
|
* @param {String} reason
|
|
* One of "KeyShortcut", "SystemMenu", "HamburgerMenu", "ContextMenu",
|
|
* "CommandLine".
|
|
* @param {String} key
|
|
* The key used by a key shortcut.
|
|
*/
|
|
sendEntryPointTelemetry(reason, key = "") {
|
|
if (!reason) {
|
|
return;
|
|
}
|
|
|
|
let keys = "";
|
|
|
|
if (reason === "KeyShortcut") {
|
|
let { modifiers, shortcut } = key;
|
|
|
|
modifiers = modifiers.replace(",", "+");
|
|
|
|
if (shortcut.startsWith("VK_")) {
|
|
shortcut = shortcut.substr(3);
|
|
}
|
|
|
|
keys = `${modifiers}+${shortcut}`;
|
|
}
|
|
|
|
const window = Services.wm.getMostRecentWindow("navigator:browser");
|
|
|
|
this.telemetry.addEventProperty(
|
|
window,
|
|
"open",
|
|
"tools",
|
|
null,
|
|
"shortcut",
|
|
keys
|
|
);
|
|
this.telemetry.addEventProperty(
|
|
window,
|
|
"open",
|
|
"tools",
|
|
null,
|
|
"entrypoint",
|
|
reason
|
|
);
|
|
|
|
if (this.recorded) {
|
|
return;
|
|
}
|
|
|
|
// Only save the first call for each firefox run as next call
|
|
// won't necessarely start the tool. For example key shortcuts may
|
|
// only change the currently selected tool.
|
|
try {
|
|
this.telemetry.getHistogramById("DEVTOOLS_ENTRY_POINT").add(reason);
|
|
} catch (e) {
|
|
dump("DevTools telemetry entry point failed: " + e + "\n");
|
|
}
|
|
this.recorded = true;
|
|
},
|
|
|
|
/**
|
|
* Hook the debugger tool to the "Debug Script" button of the slow script dialog.
|
|
*/
|
|
setSlowScriptDebugHandler() {
|
|
const debugService = Cc["@mozilla.org/dom/slow-script-debug;1"].getService(
|
|
Ci.nsISlowScriptDebug
|
|
);
|
|
|
|
debugService.activationHandler = window => {
|
|
const chromeWindow = window.browsingContext.topChromeWindow;
|
|
|
|
let setupFinished = false;
|
|
this.slowScriptDebugHandler(chromeWindow.gBrowser.selectedTab).then(
|
|
() => {
|
|
setupFinished = true;
|
|
}
|
|
);
|
|
|
|
// Don't return from the interrupt handler until the debugger is brought
|
|
// up; no reason to continue executing the slow script.
|
|
const utils = window.windowUtils;
|
|
utils.enterModalState();
|
|
Services.tm.spinEventLoopUntil(
|
|
"devtools-browser.js:debugService.activationHandler",
|
|
() => {
|
|
return setupFinished;
|
|
}
|
|
);
|
|
utils.leaveModalState();
|
|
};
|
|
|
|
debugService.remoteActivationHandler = async (browser, callback) => {
|
|
try {
|
|
// Force selecting the freezing tab
|
|
const chromeWindow = browser.ownerGlobal;
|
|
const tab = chromeWindow.gBrowser.getTabForBrowser(browser);
|
|
chromeWindow.gBrowser.selectedTab = tab;
|
|
|
|
await this.slowScriptDebugHandler(tab);
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
callback.finishDebuggerStartup();
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Called by setSlowScriptDebugHandler, when a tab freeze because of a slow running script
|
|
*/
|
|
async slowScriptDebugHandler(tab) {
|
|
const require = this.initDevTools("SlowScript");
|
|
const { gDevTools } = require("devtools/client/framework/devtools");
|
|
const toolbox = await gDevTools.showToolboxForTab(tab, {
|
|
toolId: "jsdebugger",
|
|
});
|
|
const threadFront = toolbox.threadFront;
|
|
|
|
// Break in place, which means resuming the debuggee thread and pausing
|
|
// right before the next step happens.
|
|
switch (threadFront.state) {
|
|
case "paused":
|
|
// When the debugger is already paused.
|
|
threadFront.resumeThenPause();
|
|
break;
|
|
case "attached":
|
|
// When the debugger is already open.
|
|
const onPaused = threadFront.once("paused");
|
|
threadFront.interrupt();
|
|
await onPaused;
|
|
threadFront.resumeThenPause();
|
|
break;
|
|
case "resuming":
|
|
// The debugger is newly opened.
|
|
const onResumed = threadFront.once("resumed");
|
|
await threadFront.interrupt();
|
|
await onResumed;
|
|
threadFront.resumeThenPause();
|
|
break;
|
|
default:
|
|
throw Error(
|
|
"invalid thread front state in slow script debug handler: " +
|
|
threadFront.state
|
|
);
|
|
}
|
|
},
|
|
|
|
// Used by tests and the toolbox to register the same key shortcuts in toolboxes loaded
|
|
// in a window window.
|
|
get KeyShortcuts() {
|
|
return lazy.KeyShortcuts;
|
|
},
|
|
get wrappedJSObject() {
|
|
return this;
|
|
},
|
|
|
|
get jsdebuggerHelpInfo() {
|
|
return ` --jsdebugger [<path>] Open the Browser Toolbox. Defaults to the local build
|
|
but can be overridden by a firefox path.
|
|
--wait-for-jsdebugger Spin event loop until JS debugger connects.
|
|
Enables debugging (some) application startup code paths.
|
|
Only has an effect when \`--jsdebugger\` is also supplied.
|
|
--start-debugger-server [ws:][ <port> | <path> ] Start the devtools server on
|
|
a TCP port or Unix domain socket path. Defaults to TCP port
|
|
6000. Use WebSocket protocol if ws: prefix is specified.
|
|
`;
|
|
},
|
|
|
|
get helpInfo() {
|
|
return ` --jsconsole Open the Browser Console.
|
|
--devtools Open DevTools on initial load.
|
|
${this.jsdebuggerHelpInfo}`;
|
|
},
|
|
|
|
classID: Components.ID("{9e9a9283-0ce9-4e4a-8f1c-ba129a032c32}"),
|
|
QueryInterface: ChromeUtils.generateQI(["nsICommandLineHandler"]),
|
|
};
|
|
|
|
/**
|
|
* Singleton object that represents the JSON View in-content tool.
|
|
* It has the same lifetime as the browser.
|
|
*/
|
|
const JsonView = {
|
|
initialized: false,
|
|
|
|
initialize() {
|
|
// Prevent loading the frame script multiple times if we call this more than once.
|
|
if (this.initialized) {
|
|
return;
|
|
}
|
|
this.initialized = true;
|
|
|
|
// Register for messages coming from the child process.
|
|
// This is never removed as there is no particular need to unregister
|
|
// it during shutdown.
|
|
Services.mm.addMessageListener("devtools:jsonview:save", this.onSave);
|
|
},
|
|
|
|
// Message handlers for events from child processes
|
|
|
|
/**
|
|
* Save JSON to a file needs to be implemented here
|
|
* in the parent process.
|
|
*/
|
|
onSave(message) {
|
|
const browser = message.target;
|
|
const chrome = browser.ownerGlobal;
|
|
if (message.data === null) {
|
|
// Save original contents
|
|
chrome.saveBrowser(browser);
|
|
} else {
|
|
if (
|
|
!message.data.startsWith("blob:resource://devtools/") ||
|
|
browser.contentPrincipal.origin != "resource://devtools"
|
|
) {
|
|
console.error("Got invalid request to save JSON data");
|
|
return;
|
|
}
|
|
// The following code emulates saveBrowser, but:
|
|
// - Uses the given blob URL containing the custom contents to save.
|
|
// - Obtains the file name from the URL of the document, not the blob.
|
|
// - avoids passing the document and explicitly passes system principal.
|
|
// We have a blob created by a null principal to save, and the null
|
|
// principal is from the child. Null principals don't survive crossing
|
|
// over IPC, so there's no other principal that'll work.
|
|
const persistable = browser.frameLoader;
|
|
persistable.startPersistence(null, {
|
|
onDocumentReady(doc) {
|
|
const uri = chrome.makeURI(doc.documentURI, doc.characterSet);
|
|
const filename = chrome.getDefaultFileName(undefined, uri, doc, null);
|
|
chrome.internalSave(
|
|
message.data,
|
|
null /* originalURL */,
|
|
null,
|
|
filename,
|
|
null,
|
|
doc.contentType,
|
|
false /* bypass cache */,
|
|
null /* filepicker title key */,
|
|
null /* file chosen */,
|
|
null /* referrer */,
|
|
doc.cookieJarSettings,
|
|
null /* initiating document */,
|
|
false /* don't skip prompt for a location */,
|
|
null /* cache key */,
|
|
lazy.PrivateBrowsingUtils.isBrowserPrivate(
|
|
browser
|
|
) /* private browsing ? */,
|
|
Services.scriptSecurityManager.getSystemPrincipal()
|
|
);
|
|
},
|
|
onError() {
|
|
throw new Error("JSON Viewer's onSave failed in startPersistence");
|
|
},
|
|
});
|
|
}
|
|
},
|
|
};
|