The Tor Browser: comparison browser/devtools/debugger/debugger-commands.js

comparison: browser/devtools/debugger/debugger-commands.js

browser/devtools/debugger/debugger-commands.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:e706f8abaae2
+/* 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 { Cc, Ci, Cu } = require("chrome");
+const gcli = require("gcli/index");
+loader.lazyImporter(this, "gDevTools", "resource:///modules/devtools/gDevTools.jsm");
+/**
+* The commands and converters that are exported to GCLI
+*/
+exports.items = [];
+/**
+* Utility to get access to the current breakpoint list.
+*
+* @param DebuggerPanel dbg
+*        The debugger panel.
+* @return array
+*         An array of objects, one for each breakpoint, where each breakpoint
+*         object has the following properties:
+*           - url: the URL of the source file.
+*           - label: a unique string identifier designed to be user visible.
+*           - lineNumber: the line number of the breakpoint in the source file.
+*           - lineText: the text of the line at the breakpoint.
+*           - truncatedLineText: lineText truncated to MAX_LINE_TEXT_LENGTH.
+*/
+function getAllBreakpoints(dbg) {
+let breakpoints = [];
+let sources = dbg._view.Sources;
+let { trimUrlLength: trim } = dbg.panelWin.SourceUtils;
+for (let source of sources) {
+for (let { attachment: breakpoint } of source) {
+breakpoints.push({
+url: source.value,
+label: source.attachment.label + ":" + breakpoint.line,
+lineNumber: breakpoint.line,
+lineText: breakpoint.text,
+truncatedLineText: trim(breakpoint.text, MAX_LINE_TEXT_LENGTH, "end")
+});
+}
+}
+return breakpoints;
+}
+/**
+* 'break' command
+*/
+exports.items.push({
+name: "break",
+description: gcli.lookup("breakDesc"),
+manual: gcli.lookup("breakManual")
+});
+/**
+* 'break list' command
+*/
+exports.items.push({
+name: "break list",
+description: gcli.lookup("breaklistDesc"),
+returnType: "breakpoints",
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger", { ensureOpened: true });
+return dbg.then(getAllBreakpoints);
+}
+});
+exports.items.push({
+item: "converter",
+from: "breakpoints",
+to: "view",
+exec: function(breakpoints, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (dbg && breakpoints.length) {
+return context.createView({
+html: breakListHtml,
+data: {
+breakpoints: breakpoints,
+onclick: context.update,
+ondblclick: context.updateExec
+}
+});
+} else {
+return context.createView({
+html: "<p>${message}</p>",
+data: { message: gcli.lookup("breaklistNone") }
+});
+}
+}
+});
+var breakListHtml = "" +
+"<table>" +
+" <thead>" +
+"  <th>Source</th>" +
+"  <th>Line</th>" +
+"  <th>Actions</th>" +
+" </thead>" +
+" <tbody>" +
+"  <tr foreach='breakpoint in ${breakpoints}'>" +
+"    <td class='gcli-breakpoint-label'>${breakpoint.label}</td>" +
+"    <td class='gcli-breakpoint-lineText'>" +
+"      ${breakpoint.truncatedLineText}" +
+"    </td>" +
+"    <td>" +
+"      <span class='gcli-out-shortcut'" +
+"            data-command='break del ${breakpoint.label}'" +
+"            onclick='${onclick}'" +
+"            ondblclick='${ondblclick}'>" +
+"        " + gcli.lookup("breaklistOutRemove") + "</span>" +
+"    </td>" +
+"  </tr>" +
+" </tbody>" +
+"</table>" +
+"";
+var MAX_LINE_TEXT_LENGTH = 30;
+var MAX_LABEL_LENGTH = 20;
+/**
+* 'break add' command
+*/
+exports.items.push({
+name: "break add",
+description: gcli.lookup("breakaddDesc"),
+manual: gcli.lookup("breakaddManual")
+});
+/**
+* 'break add line' command
+*/
+exports.items.push({
+name: "break add line",
+description: gcli.lookup("breakaddlineDesc"),
+params: [
+{
+name: "file",
+type: {
+name: "selection",
+data: function(context) {
+let dbg = getPanel(context, "jsdebugger");
+if (dbg) {
+return dbg._view.Sources.values;
+}
+return [];
+}
+},
+description: gcli.lookup("breakaddlineFileDesc")
+},
+{
+name: "line",
+type: { name: "number", min: 1, step: 10 },
+description: gcli.lookup("breakaddlineLineDesc")
+}
+],
+returnType: "string",
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerStopped");
+}
+let deferred = context.defer();
+let position = { url: args.file, line: args.line };
+dbg.addBreakpoint(position).then(() => {
+deferred.resolve(gcli.lookup("breakaddAdded"));
+}, aError => {
+deferred.resolve(gcli.lookupFormat("breakaddFailed", [aError]));
+});
+return deferred.promise;
+}
+});
+/**
+* 'break del' command
+*/
+exports.items.push({
+name: "break del",
+description: gcli.lookup("breakdelDesc"),
+params: [
+{
+name: "breakpoint",
+type: {
+name: "selection",
+lookup: function(context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return [];
+}
+return getAllBreakpoints(dbg).map(breakpoint => ({
+name: breakpoint.label,
+value: breakpoint,
+description: breakpoint.truncatedLineText
+}));
+}
+},
+description: gcli.lookup("breakdelBreakidDesc")
+}
+],
+returnType: "string",
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerStopped");
+}
+let deferred = context.defer();
+let position = { url: args.breakpoint.url, line: args.breakpoint.lineNumber };
+dbg.removeBreakpoint(position).then(() => {
+deferred.resolve(gcli.lookup("breakdelRemoved"));
+}, () => {
+deferred.resolve(gcli.lookup("breakNotFound"));
+});
+return deferred.promise;
+}
+});
+/**
+* 'dbg' command
+*/
+exports.items.push({
+name: "dbg",
+description: gcli.lookup("dbgDesc"),
+manual: gcli.lookup("dbgManual")
+});
+/**
+* 'dbg open' command
+*/
+exports.items.push({
+name: "dbg open",
+description: gcli.lookup("dbgOpen"),
+params: [],
+exec: function(args, context) {
+let target = context.environment.target;
+return gDevTools.showToolbox(target, "jsdebugger").then(() => null);
+}
+});
+/**
+* 'dbg close' command
+*/
+exports.items.push({
+name: "dbg close",
+description: gcli.lookup("dbgClose"),
+params: [],
+exec: function(args, context) {
+if (!getPanel(context, "jsdebugger")) {
+return;
+}
+let target = context.environment.target;
+return gDevTools.closeToolbox(target).then(() => null);
+}
+});
+/**
+* 'dbg interrupt' command
+*/
+exports.items.push({
+name: "dbg interrupt",
+description: gcli.lookup("dbgInterrupt"),
+params: [],
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerStopped");
+}
+let controller = dbg._controller;
+let thread = controller.activeThread;
+if (!thread.paused) {
+thread.interrupt();
+}
+}
+});
+/**
+* 'dbg continue' command
+*/
+exports.items.push({
+name: "dbg continue",
+description: gcli.lookup("dbgContinue"),
+params: [],
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerStopped");
+}
+let controller = dbg._controller;
+let thread = controller.activeThread;
+if (thread.paused) {
+thread.resume();
+}
+}
+});
+/**
+* 'dbg step' command
+*/
+exports.items.push({
+name: "dbg step",
+description: gcli.lookup("dbgStepDesc"),
+manual: gcli.lookup("dbgStepManual")
+});
+/**
+* 'dbg step over' command
+*/
+exports.items.push({
+name: "dbg step over",
+description: gcli.lookup("dbgStepOverDesc"),
+params: [],
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerStopped");
+}
+let controller = dbg._controller;
+let thread = controller.activeThread;
+if (thread.paused) {
+thread.stepOver();
+}
+}
+});
+/**
+* 'dbg step in' command
+*/
+exports.items.push({
+name: 'dbg step in',
+description: gcli.lookup("dbgStepInDesc"),
+params: [],
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerStopped");
+}
+let controller = dbg._controller;
+let thread = controller.activeThread;
+if (thread.paused) {
+thread.stepIn();
+}
+}
+});
+/**
+* 'dbg step over' command
+*/
+exports.items.push({
+name: 'dbg step out',
+description: gcli.lookup("dbgStepOutDesc"),
+params: [],
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerStopped");
+}
+let controller = dbg._controller;
+let thread = controller.activeThread;
+if (thread.paused) {
+thread.stepOut();
+}
+}
+});
+/**
+* 'dbg list' command
+*/
+exports.items.push({
+name: "dbg list",
+description: gcli.lookup("dbgListSourcesDesc"),
+params: [],
+returnType: "dom",
+exec: function(args, context) {
+let dbg = getPanel(context, "jsdebugger");
+if (!dbg) {
+return gcli.lookup("debuggerClosed");
+}
+let sources = dbg._view.Sources.values;
+let doc = context.environment.chromeDocument;
+let div = createXHTMLElement(doc, "div");
+let ol = createXHTMLElement(doc, "ol");
+sources.forEach(source => {
+let li = createXHTMLElement(doc, "li");
+li.textContent = source;
+ol.appendChild(li);
+});
+div.appendChild(ol);
+return div;
+}
+});
+/**
+* Define the 'dbg blackbox' and 'dbg unblackbox' commands.
+*/
+[
+{
+name: "blackbox",
+clientMethod: "blackBox",
+l10nPrefix: "dbgBlackBox"
+},
+{
+name: "unblackbox",
+clientMethod: "unblackBox",
+l10nPrefix: "dbgUnBlackBox"
+}
+].forEach(function(cmd) {
+const lookup = function(id) {
+return gcli.lookup(cmd.l10nPrefix + id);
+};
+exports.items.push({
+name: "dbg " + cmd.name,
+description: lookup("Desc"),
+params: [
+{
+name: "source",
+type: {
+name: "selection",
+data: function(context) {
+let dbg = getPanel(context, "jsdebugger");
+if (dbg) {
+return dbg._view.Sources.values;
+}
+return [];
+}
+},
+description: lookup("SourceDesc"),
+defaultValue: null
+},
+{
+name: "glob",
+type: "string",
+description: lookup("GlobDesc"),
+defaultValue: null
+},
+{
+name: "invert",
+type: "boolean",
+description: lookup("InvertDesc")
+}
+],
+returnType: "dom",
+exec: function(args, context) {
+const dbg = getPanel(context, "jsdebugger");
+const doc = context.environment.chromeDocument;
+if (!dbg) {
+throw new Error(gcli.lookup("debuggerClosed"));
+}
+const { promise, resolve, reject } = context.defer();
+const { activeThread } = dbg._controller;
+const globRegExp = args.glob ? globToRegExp(args.glob) : null;
+// Filter the sources down to those that we will need to black box.
+function shouldBlackBox(source) {
+var value = globRegExp && globRegExp.test(source.url)
+|| args.source && source.url == args.source;
+return args.invert ? !value : value;
+}
+const toBlackBox = [s.attachment.source
+for (s of dbg._view.Sources.items)
+if (shouldBlackBox(s.attachment.source))];
+// If we aren't black boxing any sources, bail out now.
+if (toBlackBox.length === 0) {
+const empty = createXHTMLElement(doc, "div");
+empty.textContent = lookup("EmptyDesc");
+return void resolve(empty);
+}
+// Send the black box request to each source we are black boxing. As we
+// get responses, accumulate the results in `blackBoxed`.
+const blackBoxed = [];
+for (let source of toBlackBox) {
+activeThread.source(source)[cmd.clientMethod](function({ error }) {
+if (error) {
+blackBoxed.push(lookup("ErrorDesc") + " " + source.url);
+} else {
+blackBoxed.push(source.url);
+}
+if (toBlackBox.length === blackBoxed.length) {
+displayResults();
+}
+});
+}
+// List the results for the user.
+function displayResults() {
+const results = doc.createElement("div");
+results.textContent = lookup("NonEmptyDesc");
+const list = createXHTMLElement(doc, "ul");
+results.appendChild(list);
+for (let result of blackBoxed) {
+const item = createXHTMLElement(doc, "li");
+item.textContent = result;
+list.appendChild(item);
+}
+resolve(results);
+}
+return promise;
+}
+});
+});
+/**
+* A helper to create xhtml namespaced elements.
+*/
+function createXHTMLElement(document, tagname) {
+return document.createElementNS("http://www.w3.org/1999/xhtml", tagname);
+}
+/**
+* A helper to go from a command context to a debugger panel.
+*/
+function getPanel(context, id, options = {}) {
+if (!context) {
+return undefined;
+}
+let target = context.environment.target;
+if (options.ensureOpened) {
+return gDevTools.showToolbox(target, id).then(toolbox => {
+return toolbox.getPanel(id);
+});
+} else {
+let toolbox = gDevTools.getToolbox(target);
+if (toolbox) {
+return toolbox.getPanel(id);
+} else {
+return undefined;
+}
+}
+}
+/**
+* Converts a glob to a regular expression.
+*/
+function globToRegExp(glob) {
+const reStr = glob
+// Escape existing regular expression syntax.
+.replace(/\\/g, "\\\\")
+.replace(/\//g, "\\/")
+.replace(/\^/g, "\\^")
+.replace(/\$/g, "\\$")
+.replace(/\+/g, "\\+")
+.replace(/\?/g, "\\?")
+.replace(/\./g, "\\.")
+.replace(/\(/g, "\\(")
+.replace(/\)/g, "\\)")
+.replace(/\=/g, "\\=")
+.replace(/\!/g, "\\!")
+.replace(/\|/g, "\\|")
+.replace(/\{/g, "\\{")
+.replace(/\}/g, "\\}")
+.replace(/\,/g, "\\,")
+.replace(/\[/g, "\\[")
+.replace(/\]/g, "\\]")
+.replace(/\-/g, "\\-")
+// Turn * into the match everything wildcard.
+.replace(/\*/g, ".*")
+return new RegExp("^" + reStr + "$");
+}