Bug 1106695 - Part 1: Add toolkit/devtools/server/actors/utils/ScriptStore.js. r=jlongster

toolkit/devtools/DevToolsUtils.js

@@ -338,7 +338,7 @@ exports.dbg_assert = function dbg_assert(cond, e) {
   if (!cond) {
     return e;
   }
-}
+};
 
 
 /**

toolkit/devtools/server/actors/utils/ScriptStore.js

@@ -0,0 +1,207 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2; js-indent-level: 2 -*- */
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* 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 { noop } = require("devtools/toolkit/DevToolsUtils");
+
+/**
+ * A `ScriptStore` is a cache of `Debugger.Script` instances. It holds strong
+ * references to the cached scripts to alleviate the GC-sensitivity issues that
+ * plague `Debugger.prototype.findScripts`, but this means that its lifetime
+ * must be managed carefully. It is the `ScriptStore` user's responsibility to
+ * ensure that the `ScriptStore` stays up to date.
+ *
+ * Implementation Notes:
+ *
+ * The ScriptStore's prototype methods are very hot, in general. To help the
+ * JIT, they avoid ES6-isms and higher-order iteration functions, for the most
+ * part. You might be wondering why we don't maintain indices on, say,
+ * Debugger.Source for faster querying, if these methods are so hot. First, the
+ * hottest method is actually just getting all scripts; second, populating the
+ * store becomes prohibitively expensive. So we fall back to linear queries
+ * (which isn't so bad, because Debugger.prototype.findScripts is also linear).
+ */
+function ScriptStore() {
+  // Set of every Debugger.Script in the cache.
+  this._scripts = new NoDeleteSet;
+}
+
+module.exports = ScriptStore;
+
+ScriptStore.prototype = {
+  // Populating a ScriptStore.
+
+  /**
+   * Add one script to the cache.
+   *
+   * @param Debugger.Script script
+   */
+  addScript(script) {
+    this._scripts.add(script);
+  },
+
+  /**
+   * Add many scripts to the cache at once.
+   *
+   * @param Array scripts
+   *        The set of Debugger.Scripts to add to the cache.
+   */
+  addScripts(scripts) {
+    for (var i = 0, len = scripts.length; i < len; i++) {
+      this.addScript(scripts[i]);
+    }
+  },
+
+  // Querying a ScriptStore.
+
+  /**
+   * Get all the sources for which we have scripts cached.
+   *
+   * @returns Array of Debugger.Source
+   */
+  getSources() {
+    return [...new Set(this._scripts.items.map(s => s.source))];
+  },
+
+  /**
+   * Get all the scripts in the cache.
+   *
+   * @returns read-only Array of Debugger.Script.
+   *
+   * NB: The ScriptStore retains ownership of the returned array, and the
+   * ScriptStore's consumers MUST NOT MODIFY its contents!
+   */
+  getAllScripts() {
+    return this._scripts.items;
+  },
+
+  /**
+   * Get all scripts produced from the given source.
+   *
+   * @oaram Debugger.Source source
+   * @returns Array of Debugger.Script
+   */
+  getScriptsBySource(source) {
+    var results = [];
+    var scripts = this._scripts.items;
+    var length = scripts.length;
+    for (var i = 0; i < length; i++) {
+      if (scripts[i].source === source) {
+        results.push(scripts[i]);
+      }
+    }
+    return results;
+  },
+
+  /**
+   * Get all scripts produced from the given source whose source code definition
+   * spans the given line.
+   *
+   * @oaram Debugger.Source source
+   * @param Number line
+   * @returns Array of Debugger.Script
+   */
+  getScriptsBySourceAndLine(source, line) {
+    var results = [];
+    var scripts = this._scripts.items;
+    var length = scripts.length;
+    for (var i = 0; i < length; i++) {
+      var script = scripts[i];
+      if (script.source === source &&
+          script.startLine <= line &&
+          (script.startLine + script.lineCount) > line) {
+        results.push(script);
+      }
+    }
+    return results;
+  },
+
+  /**
+   * Get all scripts defined by a source at the given URL.
+   *
+   * @param String url
+   * @returns Array of Debugger.Script
+   */
+  getScriptsByURL(url) {
+    var results = [];
+    var scripts = this._scripts.items;
+    var length = scripts.length;
+    for (var i = 0; i < length; i++) {
+      if (scripts[i].url === url) {
+        results.push(scripts[i]);
+      }
+    }
+    return results;
+  },
+
+  /**
+   * Get all scripts defined by a source a the given URL and whose source code
+   * definition spans the given line.
+   *
+   * @param String url
+   * @param Number line
+   * @returns Array of Debugger.Script
+   */
+  getScriptsByURLAndLine(url, line) {
+    var results = [];
+    var scripts = this._scripts.items;
+    var length = scripts.length;
+    for (var i = 0; i < length; i++) {
+      var script = scripts[i];
+      if (script.url === url &&
+          script.startLine <= line &&
+          (script.startLine + script.lineCount) > line) {
+        results.push(script);
+      }
+    }
+    return results;
+  },
+};
+
+
+/**
+ * A set which can only grow, and does not support the delete operation.
+ * Provides faster iteration than the native Set by maintaining an array of all
+ * items, in addition to the internal set of all items, which allows direct
+ * iteration (without the iteration protocol and calling into C++, which are
+ * both expensive).
+ */
+function NoDeleteSet() {
+  this._set = new Set();
+  this.items = [];
+}
+
+NoDeleteSet.prototype = {
+  /**
+   * An array containing every item in the set for convenience and faster
+   * iteration. This is public for reading only, and consumers MUST NOT modify
+   * this array!
+   */
+  items: null,
+
+  /**
+   * Add an item to the set.
+   *
+   * @param any item
+   */
+  add(item) {
+    if (!this._set.has(item)) {
+      this._set.add(item);
+      this.items.push(item);
+    }
+  },
+
+  /**
+   * Return true if the item is in the set, false otherwise.
+   *
+   * @param any item
+   * @returns Boolean
+   */
+  has(item) {
+    return this._set.has(item);
+  }
+};

toolkit/devtools/server/moz.build

@@ -71,7 +71,8 @@ EXTRA_JS_MODULES.devtools.server.actors += [
 
 EXTRA_JS_MODULES.devtools.server.actors.utils += [
     'actors/utils/make-debugger.js',
-    'actors/utils/map-uri-to-addon-id.js'
+    'actors/utils/map-uri-to-addon-id.js',
+    'actors/utils/ScriptStore.js'
 ]
 
 FAIL_ON_WARNINGS = True

toolkit/devtools/server/tests/unit/test_ScriptStore.js

@@ -0,0 +1,168 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test the functionality of ScriptStore.
+
+const ScriptStore = devtools.require("devtools/server/actors/utils/ScriptStore");
+
+// Fixtures
+
+const firstSource = "firstSource";
+const secondSource = "secondSource";
+const thirdSource = "thirdSource";
+
+const scripts = new Set([
+  {
+    url: "a.js",
+    source: firstSource,
+    startLine: 1,
+    lineCount: 100,
+    global: "g1"
+  },
+  {
+    url: "a.js",
+    source: firstSource,
+    startLine: 1,
+    lineCount: 40,
+    global: "g1"
+  },
+  {
+    url: "a.js",
+    source: firstSource,
+    startLine: 50,
+    lineCount: 100,
+    global: "g1"
+  },
+  {
+    url: "a.js",
+    source: firstSource,
+    startLine: 60,
+    lineCount: 90,
+    global: "g1"
+  },
+  {
+    url: "index.html",
+    source: secondSource,
+    startLine: 150,
+    lineCount: 1,
+    global: "g2"
+  },
+  {
+    url: "index.html",
+    source: thirdSource,
+    startLine: 200,
+    lineCount: 100,
+    global: "g2"
+  },
+  {
+    url: "index.html",
+    source: thirdSource,
+    startLine: 250,
+    lineCount: 10,
+    global: "g2"
+  },
+  {
+    url: "index.html",
+    source: thirdSource,
+    startLine: 275,
+    lineCount: 5,
+    global: "g2"
+  }
+]);
+
+function contains(script, line) {
+  return script.startLine <= line &&
+    line < script.startLine + script.lineCount;
+}
+
+function run_test() {
+  testAddScript();
+  testAddScripts();
+  testGetSources();
+  testGetScriptsBySource();
+  testGetScriptsBySourceAndLine();
+  testGetScriptsByURL();
+  testGetScriptsByURLAndLine();
+}
+
+function testAddScript() {
+  const ss = new ScriptStore();
+
+  for (let s of scripts) {
+    ss.addScript(s);
+  }
+
+  equal(ss.getAllScripts().length, scripts.size);
+
+  for (let s of ss.getAllScripts()) {
+    ok(scripts.has(s));
+  }
+}
+
+function testAddScripts() {
+  const ss = new ScriptStore();
+  ss.addScripts([...scripts]);
+
+  equal(ss.getAllScripts().length, scripts.size);
+
+  for (let s of ss.getAllScripts()) {
+    ok(scripts.has(s));
+  }
+}
+
+function testGetSources() {
+  const ss = new ScriptStore();
+  ss.addScripts([...scripts])
+
+  const expected = new Set([firstSource, secondSource, thirdSource]);
+  const actual = ss.getSources();
+  equal(expected.size, actual.length);
+
+  for (let s of actual) {
+    ok(expected.has(s));
+    expected.delete(s);
+  }
+}
+
+function testGetScriptsBySource() {
+  const ss = new ScriptStore();
+  ss.addScripts([...scripts]);
+
+  const expected = [...scripts].filter(s => s.source === thirdSource);
+  const actual = ss.getScriptsBySource(thirdSource);
+
+  deepEqual(actual, expected);
+}
+
+function testGetScriptsBySourceAndLine() {
+  const ss = new ScriptStore();
+  ss.addScripts([...scripts]);
+
+  const expected = [...scripts].filter(
+    s => s.source === firstSource && contains(s, 65))
+  const actual = ss.getScriptsBySourceAndLine(firstSource, 65);
+
+  deepEqual(actual, expected);
+}
+
+function testGetScriptsByURL() {
+  const ss = new ScriptStore();
+  ss.addScripts([...scripts]);
+
+  const expected = [...scripts].filter(s => s.url === "index.html");
+  const actual = ss.getScriptsByURL("index.html");
+
+  deepEqual(actual, expected);
+}
+
+function testGetScriptsByURLAndLine() {
+  const ss = new ScriptStore();
+  ss.addScripts([...scripts]);
+
+  const expected = [...scripts].filter(
+    s => s.url === "index.html" && contains(s, 250))
+  const actual = ss.getScriptsByURLAndLine("index.html", 250);
+
+  deepEqual(actual, expected);
+}

toolkit/devtools/server/tests/unit/xpcshell.ini

@@ -18,6 +18,7 @@ support-files =
   tracerlocations.js
   hello-actor.js
 
+[test_ScriptStore.js]
 [test_actor-registry-actor.js]
 [test_nesting-01.js]
 [test_nesting-02.js]