Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 751 insertions, 0 deletions

diff --git a/devtools/server/actors/source.js b/devtools/server/actors/source.js
new file mode 100644
index 0000000000..601265cd05
--- /dev/null
+++ b/devtools/server/actors/source.js
@@ -0,0 +1,751 @@
+/* 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 { Cu } = require("chrome");
+const {
+  setBreakpointAtEntryPoints,
+} = require("devtools/server/actors/breakpoint");
+const { ActorClassWithSpec, Actor } = require("devtools/shared/protocol");
+const DevToolsUtils = require("devtools/shared/DevToolsUtils");
+const { assert } = DevToolsUtils;
+const { sourceSpec } = require("devtools/shared/specs/source");
+const {
+  resolveSourceURL,
+  getSourcemapBaseURL,
+} = require("devtools/server/actors/utils/source-map-utils");
+const {
+  getDebuggerSourceURL,
+} = require("devtools/server/actors/utils/source-url");
+
+loader.lazyRequireGetter(
+  this,
+  "ArrayBufferActor",
+  "devtools/server/actors/array-buffer",
+  true
+);
+loader.lazyRequireGetter(
+  this,
+  "LongStringActor",
+  "devtools/server/actors/string",
+  true
+);
+
+loader.lazyRequireGetter(this, "Services");
+loader.lazyGetter(
+  this,
+  "WebExtensionPolicy",
+  () => Cu.getGlobalForObject(Cu).WebExtensionPolicy
+);
+
+const windowsDrive = /^([a-zA-Z]:)/;
+
+function getSourceURL(source, window) {
+  // Some eval sources have URLs, but we want to explcitly ignore those because
+  // they are generally useless strings like "eval" or "debugger eval code".
+  const resourceURL =
+    (getDebuggerSourceURL(source) || "").split(" -> ").pop() || null;
+
+  // A "//# sourceURL=" pragma should basically be treated as a source file's
+  // full URL, so that is what we want to use as the base if it is present.
+  // If this is not an absolute URL, this will mean the maps in the file
+  // will not have a valid base URL, but that is up to tooling that
+  let result = resolveSourceURL(source.displayURL, window);
+  if (!result) {
+    result = resolveSourceURL(resourceURL, window) || resourceURL;
+
+    // In XPCShell tests, the source URL isn't actually a URL, it's a file path.
+    // That causes issues because "C:/folder/file.js" is parsed as a URL with
+    // "c:" as the URL scheme, which causes the drive letter to be unexpectedly
+    // lower-cased when the parsed URL is re-serialized. To avoid that, we
+    // detect that case and re-uppercase it again. This is a bit gross and
+    // ideally it seems like XPCShell tests should use file:// URLs for files,
+    // but alas they do not.
+    if (
+      resourceURL &&
+      resourceURL.match(windowsDrive) &&
+      result.slice(0, 2) == resourceURL.slice(0, 2).toLowerCase()
+    ) {
+      result = resourceURL.slice(0, 2) + result.slice(2);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * A SourceActor provides information about the source of a script. Source
+ * actors are 1:1 with Debugger.Source objects.
+ *
+ * @param Debugger.Source source
+ *        The source object we are representing.
+ * @param ThreadActor thread
+ *        The current thread actor.
+ */
+const SourceActor = ActorClassWithSpec(sourceSpec, {
+  initialize: function({ source, thread }) {
+    Actor.prototype.initialize.call(this, thread.conn);
+
+    this._threadActor = thread;
+    this._url = undefined;
+    this._source = source;
+    this.__isInlineSource = undefined;
+    this._startLineColumnDisplacement = null;
+  },
+
+  get _isInlineSource() {
+    const source = this._source;
+    if (this.__isInlineSource === undefined) {
+      // If the source has a usable displayURL, the source is treated as not
+      // inlined because it has its own URL.
+      this.__isInlineSource =
+        source.introductionType === "inlineScript" &&
+        !resolveSourceURL(source.displayURL, this.threadActor._parent.window);
+    }
+    return this.__isInlineSource;
+  },
+
+  get threadActor() {
+    return this._threadActor;
+  },
+  get sourcesManager() {
+    return this._threadActor.sourcesManager;
+  },
+  get dbg() {
+    return this.threadActor.dbg;
+  },
+  get breakpointActorMap() {
+    return this.threadActor.breakpointActorMap;
+  },
+  get url() {
+    if (this._url === undefined) {
+      this._url = getSourceURL(this._source, this.threadActor._parent.window);
+    }
+    return this._url;
+  },
+
+  get extensionName() {
+    if (this._extensionName === undefined) {
+      this._extensionName = null;
+
+      // Cu is not available for workers and so we are not able to get a
+      // WebExtensionPolicy object
+      if (!isWorker && this.url) {
+        try {
+          const extURI = Services.io.newURI(this.url);
+          if (extURI) {
+            const policy = WebExtensionPolicy.getByURI(extURI);
+            if (policy) {
+              this._extensionName = policy.name;
+            }
+          }
+        } catch (e) {
+          // Ignore
+        }
+      }
+    }
+
+    return this._extensionName;
+  },
+
+  get internalSourceId() {
+    return this._source.id;
+  },
+
+  form: function() {
+    const source = this._source;
+
+    let introductionType = source.introductionType;
+    if (
+      introductionType === "srcScript" ||
+      introductionType === "inlineScript" ||
+      introductionType === "injectedScript"
+    ) {
+      // These three used to be one single type, so here we combine them all
+      // so that clients don't see any change in behavior.
+      introductionType = "scriptElement";
+    }
+
+    return {
+      actor: this.actorID,
+      extensionName: this.extensionName,
+      url: this.url,
+      isBlackBoxed: this.sourcesManager.isBlackBoxed(this.url),
+      sourceMapBaseURL: getSourcemapBaseURL(
+        this.url,
+        this.threadActor._parent.window
+      ),
+      sourceMapURL: source.sourceMapURL,
+      introductionType,
+    };
+  },
+
+  destroy: function() {
+    const parent = this.getParent();
+    if (parent && parent.sourceActors) {
+      delete parent.sourceActors[this.actorID];
+    }
+    Actor.prototype.destroy.call(this);
+  },
+
+  get _isWasm() {
+    return this._source.introductionType === "wasm";
+  },
+
+  _getSourceText: async function() {
+    if (this._isWasm) {
+      const wasm = this._source.binary;
+      const buffer = wasm.buffer;
+      assert(
+        wasm.byteOffset === 0 && wasm.byteLength === buffer.byteLength,
+        "Typed array from wasm source binary must cover entire buffer"
+      );
+      return {
+        content: buffer,
+        contentType: "text/wasm",
+      };
+    }
+
+    // Use `source.text` if it exists, is not the "no source" string, and
+    // the source isn't one that is inlined into some larger file.
+    // It will be "no source" if the Debugger API wasn't able to load
+    // the source because sources were discarded
+    // (javascript.options.discardSystemSource == true).
+    if (this._source.text !== "[no source]" && !this._isInlineSource) {
+      return {
+        content: this.actualText(),
+        contentType: "text/javascript",
+      };
+    }
+
+    return this.sourcesManager.urlContents(
+      this.url,
+      /* partial */ false,
+      /* canUseCache */ this._isInlineSource
+    );
+  },
+
+  // Get the actual text of this source, padded so that line numbers will match
+  // up with the source itself.
+  actualText() {
+    // If the source doesn't start at line 1, line numbers in the client will
+    // not match up with those in the source. Pad the text with blank lines to
+    // fix this. This can show up for sources associated with inline scripts
+    // in HTML created via document.write() calls: the script's source line
+    // number is relative to the start of the written HTML, but we show the
+    // source's content by itself.
+    const padding = this._source.startLine
+      ? "\n".repeat(this._source.startLine - 1)
+      : "";
+    return padding + this._source.text;
+  },
+
+  // Return whether the specified fetched contents includes the actual text of
+  // this source in the expected position.
+  contentMatches(fileContents) {
+    const lineBreak = /\r\n?|\n|\u2028|\u2029/;
+    const contentLines = fileContents.content.split(lineBreak);
+    const sourceLines = this._source.text.split(lineBreak);
+    let line = this._source.startLine - 1;
+    for (const sourceLine of sourceLines) {
+      const contentLine = contentLines[line++] || "";
+      if (!contentLine.includes(sourceLine)) {
+        return false;
+      }
+    }
+    return true;
+  },
+
+  getBreakableLines: async function() {
+    const positions = await this.getBreakpointPositions();
+    const lines = new Set();
+    for (const position of positions) {
+      if (!lines.has(position.line)) {
+        lines.add(position.line);
+      }
+    }
+
+    return Array.from(lines);
+  },
+
+  // For inline <script> tags in HTML pages, the column numbers of the start
+  // line are relative to the column immediately after the opening <script> tag,
+  // rather than the start of the line itself. Calculate the start line and any
+  // column displacement from the start of that line in the HTML file.
+  _getStartLineColumnDisplacement() {
+    if (this._startLineColumnDisplacement) {
+      return this._startLineColumnDisplacement;
+    }
+
+    // Allow fetching the partial contents of the HTML file. When getting the
+    // displacement to install breakpoints on an inline source that just
+    // appeared, we don't expect the HTML file to be completely loaded, and if
+    // we wait for it to load then the script will have already started running.
+    // Fetching the partial contents will only return a promise if we haven't
+    // seen any data for the file, which will only be the case when the debugger
+    // attaches to an existing page. In this case we don't need to get the
+    // displacement synchronously, so it's OK if we yield to the event loop
+    // while the promise resolves.
+    const fileContents = this.sourcesManager.urlContents(
+      this.url,
+      /* partial */ true,
+      /* canUseCache */ this._isInlineSource
+    );
+    if (fileContents.then) {
+      return fileContents.then(contents =>
+        this._setStartLineColumnDisplacement(contents)
+      );
+    }
+    return this._setStartLineColumnDisplacement(fileContents);
+  },
+
+  _setStartLineColumnDisplacement(fileContents) {
+    const d = this._calculateStartLineColumnDisplacement(fileContents);
+    this._startLineColumnDisplacement = d;
+    return d;
+  },
+
+  _calculateStartLineColumnDisplacement(fileContents) {
+    const startLine = this._source.startLine;
+
+    const lineBreak = /\r\n?|\n|\u2028|\u2029/;
+    const fileStartLine =
+      fileContents.content.split(lineBreak)[startLine - 1] || "";
+
+    const sourceContents = this._source.text;
+
+    if (lineBreak.test(sourceContents)) {
+      // The inline script must end the HTML file's line.
+      const firstLine = sourceContents.split(lineBreak)[0];
+      if (firstLine.length && fileStartLine.endsWith(firstLine)) {
+        const column = fileStartLine.length - firstLine.length;
+        return { startLine, column };
+      }
+      return {};
+    }
+
+    // The inline script could be anywhere on the line. Search for its
+    // contents in the line's text. This is a best-guess method and may return
+    // the wrong result if the text appears multiple times on the line, but
+    // the result should make some sense to the user in any case.
+    const column = fileStartLine.indexOf(sourceContents);
+    if (column != -1) {
+      return { startLine, column };
+    }
+    return {};
+  },
+
+  // If a { line, column } location is on the starting line of an inline source,
+  // adjust it upwards or downwards (per |upward|) according to the starting
+  // column displacement.
+  _adjustInlineScriptLocation(location, upward) {
+    if (!this._isInlineSource) {
+      return location;
+    }
+
+    const info = this._getStartLineColumnDisplacement();
+    if (info.then) {
+      return info.then(i =>
+        this._adjustInlineScriptLocationFromDisplacement(i, location, upward)
+      );
+    }
+    return this._adjustInlineScriptLocationFromDisplacement(
+      info,
+      location,
+      upward
+    );
+  },
+
+  _adjustInlineScriptLocationFromDisplacement(info, location, upward) {
+    const { line, column } = location;
+    if (this._startLineColumnDisplacement.startLine == line) {
+      let displacement = this._startLineColumnDisplacement.column;
+      if (!upward) {
+        displacement = -displacement;
+      }
+      return { line, column: column + displacement };
+    }
+    return location;
+  },
+
+  // Get all toplevel scripts in the source. Transitive child scripts must be
+  // found by traversing the child script tree.
+  _getTopLevelDebuggeeScripts() {
+    if (this._scripts) {
+      return this._scripts;
+    }
+
+    let scripts = this.dbg.findScripts({ source: this._source });
+
+    if (!this._isWasm) {
+      // There is no easier way to get the top-level scripts right now, so
+      // we have to build that up the list manually.
+      // Note: It is not valid to simply look for scripts where
+      // `.isFunction == false` because a source may have executed multiple
+      // where some have been GCed and some have not (bug 1627712).
+      const allScripts = new Set(scripts);
+      for (const script of allScripts) {
+        for (const child of script.getChildScripts()) {
+          allScripts.delete(child);
+        }
+      }
+      scripts = [...allScripts];
+    }
+
+    this._scripts = scripts;
+    return scripts;
+  },
+
+  resetDebuggeeScripts() {
+    this._scripts = null;
+  },
+
+  // Get toplevel scripts which contain all breakpoint positions for the source.
+  // This is different from _scripts if we detected that some scripts have been
+  // GC'ed and reparsed the source contents.
+  _getTopLevelBreakpointPositionScripts() {
+    if (this._breakpointPositionScripts) {
+      return this._breakpointPositionScripts;
+    }
+
+    let scripts = this._getTopLevelDebuggeeScripts();
+
+    // We need to find all breakpoint positions, even if scripts associated with
+    // this source have been GC'ed. We detect this by looking for a script which
+    // does not have a function: a source will typically have a top level
+    // non-function script. If this top level script still exists, then it keeps
+    // all its child scripts alive and we will find all breakpoint positions by
+    // scanning the existing scripts. If the top level script has been GC'ed
+    // then we won't find its breakpoint positions, and inner functions may have
+    // been GC'ed as well. In this case we reparse the source and generate a new
+    // and complete set of scripts to look for the breakpoint positions.
+    // Note that in some cases like "new Function(stuff)" there might not be a
+    // top level non-function script, but if there is a non-function script then
+    // it must be at the top level and will keep all other scripts in the source
+    // alive.
+    if (!this._isWasm && !scripts.some(script => !script.isFunction)) {
+      let newScript;
+      try {
+        newScript = this._source.reparse();
+      } catch (e) {
+        // reparse() will throw if the source is not valid JS. This can happen
+        // if this source is the resurrection of a GC'ed source and there are
+        // parse errors in the refetched contents.
+      }
+      if (newScript) {
+        scripts = [newScript];
+      }
+    }
+
+    this._breakpointPositionScripts = scripts;
+    return scripts;
+  },
+
+  // Get all scripts in this source that might include content in the range
+  // specified by the given query.
+  _findDebuggeeScripts(query, forBreakpointPositions) {
+    const scripts = forBreakpointPositions
+      ? this._getTopLevelBreakpointPositionScripts()
+      : this._getTopLevelDebuggeeScripts();
+
+    const {
+      start: { line: startLine = 0, column: startColumn = 0 } = {},
+      end: { line: endLine = Infinity, column: endColumn = Infinity } = {},
+    } = query || {};
+
+    const rv = [];
+    addMatchingScripts(scripts);
+    return rv;
+
+    function scriptMatches(script) {
+      // These tests are approximate, as we can't easily get the script's end
+      // column.
+      let lineCount;
+      try {
+        lineCount = script.lineCount;
+      } catch (err) {
+        // Accessing scripts which were optimized out during parsing can throw
+        // an exception. Tolerate these so that we can still get positions for
+        // other scripts in the source.
+        return false;
+      }
+
+      if (
+        script.startLine > endLine ||
+        script.startLine + lineCount <= startLine ||
+        (script.startLine == endLine && script.startColumn > endColumn)
+      ) {
+        return false;
+      }
+
+      if (
+        lineCount == 1 &&
+        script.startLine == startLine &&
+        script.startColumn + script.sourceLength <= startColumn
+      ) {
+        return false;
+      }
+
+      return true;
+    }
+
+    function addMatchingScripts(childScripts) {
+      for (const script of childScripts) {
+        if (scriptMatches(script)) {
+          rv.push(script);
+          if (script.format === "js") {
+            addMatchingScripts(script.getChildScripts());
+          }
+        }
+      }
+    }
+  },
+
+  getBreakpointPositions: async function(query) {
+    const scripts = this._findDebuggeeScripts(
+      query,
+      /* forBreakpointPositions */ true
+    );
+
+    const positions = [];
+    for (const script of scripts) {
+      await this._addScriptBreakpointPositions(query, script, positions);
+    }
+
+    return (
+      positions
+        // Sort the items by location.
+        .sort((a, b) => {
+          const lineDiff = a.line - b.line;
+          return lineDiff === 0 ? a.column - b.column : lineDiff;
+        })
+    );
+  },
+
+  async _addScriptBreakpointPositions(query, script, positions) {
+    const {
+      start: { line: startLine = 0, column: startColumn = 0 } = {},
+      end: { line: endLine = Infinity, column: endColumn = Infinity } = {},
+    } = query || {};
+
+    const offsets = script.getPossibleBreakpoints();
+    for (const { lineNumber, columnNumber } of offsets) {
+      if (
+        lineNumber < startLine ||
+        (lineNumber === startLine && columnNumber < startColumn) ||
+        lineNumber > endLine ||
+        (lineNumber === endLine && columnNumber >= endColumn)
+      ) {
+        continue;
+      }
+
+      // Adjust columns according to any inline script start column, so that
+      // column breakpoints show up correctly in the UI.
+      const position = await this._adjustInlineScriptLocation(
+        {
+          line: lineNumber,
+          column: columnNumber,
+        },
+        /* upward */ true
+      );
+
+      positions.push(position);
+    }
+  },
+
+  getBreakpointPositionsCompressed: async function(query) {
+    const items = await this.getBreakpointPositions(query);
+    const compressed = {};
+    for (const { line, column } of items) {
+      if (!compressed[line]) {
+        compressed[line] = [];
+      }
+      compressed[line].push(column);
+    }
+    return compressed;
+  },
+
+  /**
+   * Handler for the "onSource" packet.
+   * @return Object
+   *         The return of this function contains a field `contentType`, and
+   *         a field `source`. `source` can either be an ArrayBuffer or
+   *         a LongString.
+   */
+  source: async function() {
+    try {
+      const { content, contentType } = await this._getSourceText();
+      if (
+        typeof content === "object" &&
+        content &&
+        content.constructor &&
+        content.constructor.name === "ArrayBuffer"
+      ) {
+        return {
+          source: new ArrayBufferActor(this.threadActor.conn, content),
+          contentType,
+        };
+      }
+
+      return {
+        source: new LongStringActor(this.threadActor.conn, content),
+        contentType,
+      };
+    } catch (error) {
+      reportError(error, "Got an exception during SA_onSource: ");
+      throw new Error(
+        "Could not load the source for " +
+          this.url +
+          ".\n" +
+          DevToolsUtils.safeErrorString(error)
+      );
+    }
+  },
+
+  /**
+   * Handler for the "blackbox" packet.
+   */
+  blackbox: function(range) {
+    this.sourcesManager.blackBox(this.url, range);
+    if (
+      this.threadActor.state == "paused" &&
+      this.threadActor.youngestFrame &&
+      this.threadActor.youngestFrame.script.url == this.url
+    ) {
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * Handler for the "unblackbox" packet.
+   */
+  unblackbox: function(range) {
+    this.sourcesManager.unblackBox(this.url, range);
+  },
+
+  /**
+   * Handler for the "setPausePoints" packet.
+   *
+   * @param Array pausePoints
+   *        A dictionary of pausePoint objects
+   *
+   *        type PausePoints = {
+   *          line: {
+   *            column: { break?: boolean, step?: boolean }
+   *          }
+   *        }
+   */
+  setPausePoints: function(pausePoints) {
+    const uncompressed = {};
+    const points = {
+      0: {},
+      1: { break: true },
+      2: { step: true },
+      3: { break: true, step: true },
+    };
+
+    for (const line in pausePoints) {
+      uncompressed[line] = {};
+      for (const col in pausePoints[line]) {
+        uncompressed[line][col] = points[pausePoints[line][col]];
+      }
+    }
+
+    this.pausePoints = uncompressed;
+  },
+
+  /*
+   * Ensure the given BreakpointActor is set as a breakpoint handler on all
+   * scripts that match its location in the generated source.
+   *
+   * @param BreakpointActor actor
+   *        The BreakpointActor to be set as a breakpoint handler.
+   *
+   * @returns A Promise that resolves to the given BreakpointActor.
+   */
+  applyBreakpoint: async function(actor) {
+    let { line, column } = actor.location;
+
+    // Find all entry points that correspond to the given location.
+    const entryPoints = [];
+    if (column === undefined) {
+      // Find all scripts that match the given source actor and line
+      // number.
+      const query = { start: { line }, end: { line } };
+      const scripts = this._findDebuggeeScripts(query).filter(
+        script => !actor.hasScript(script)
+      );
+
+      // This is a line breakpoint, so we add a breakpoint on the first
+      // breakpoint on the line.
+      const lineMatches = [];
+      for (const script of scripts) {
+        const possibleBreakpoints = script.getPossibleBreakpoints({ line });
+        for (const possibleBreakpoint of possibleBreakpoints) {
+          lineMatches.push({ ...possibleBreakpoint, script });
+        }
+      }
+      lineMatches.sort((a, b) => a.columnNumber - b.columnNumber);
+
+      if (lineMatches.length > 0) {
+        // A single Debugger.Source may have _multiple_ Debugger.Scripts
+        // at the same position from multiple evaluations of the source,
+        // so we explicitly want to take all of the matches for the matched
+        // column number.
+        const firstColumn = lineMatches[0].columnNumber;
+        const firstColumnMatches = lineMatches.filter(
+          m => m.columnNumber === firstColumn
+        );
+
+        for (const { script, offset } of firstColumnMatches) {
+          entryPoints.push({ script, offsets: [offset] });
+        }
+      }
+    } else {
+      // Adjust columns according to any inline script start column, to undo
+      // the adjustment performed when sending the breakpoint to the client and
+      // allow the breakpoint to be set correctly in the source (which treats
+      // the location after the <script> tag as column 0).
+      let adjusted = this._adjustInlineScriptLocation(
+        { line, column },
+        /* upward */ false
+      );
+      if (adjusted.then) {
+        adjusted = await adjusted;
+      }
+      line = adjusted.line;
+      column = adjusted.column;
+
+      // Find all scripts that match the given source actor, line,
+      // and column number.
+      const query = { start: { line, column }, end: { line, column } };
+      const scripts = this._findDebuggeeScripts(query).filter(
+        script => !actor.hasScript(script)
+      );
+
+      for (const script of scripts) {
+        // Check to see if the script contains a breakpoint position at
+        // this line and column.
+        const possibleBreakpoint = script
+          .getPossibleBreakpoints({
+            line,
+            minColumn: column,
+            maxColumn: column + 1,
+          })
+          .pop();
+
+        if (possibleBreakpoint) {
+          const { offset } = possibleBreakpoint;
+          entryPoints.push({ script, offsets: [offset] });
+        }
+      }
+    }
+
+    setBreakpointAtEntryPoints(actor, entryPoints);
+  },
+});
+
+exports.SourceActor = SourceActor;