Backed out 2 changesets (bug 941012, bug 931921) for suspicion of breaking Mn on OSX. CLOSED TREE

Backed out changeset c50cca7d248a (bug 941012)
Backed out changeset eb8d750eabb3 (bug 931921)

browser/devtools/debugger/test/browser_dbg_globalactor.js

@@ -44,15 +44,26 @@ function test() {
           let extraPools = conn._extraPools;
           let globalPool;
 
-          let actorPrefix = conn._prefix + "test_one";
-          let count = 0;
           for (let pool of extraPools) {
-            count += Object.keys(pool._actors).filter(e => {
-              return e.startsWith(actorPrefix);
-            }).length;
+            if (Object.keys(pool._actors).some(e => {
+              // Tab actors are in the global pool.
+              let re = new RegExp(conn._prefix + "tab", "g");
+              return e.match(re) !== null;
+            })) {
+              globalPool = pool;
+              break;
+            }
           }
-          is(count, 2,
-            "Only two actor exists in all pools. One tab actor and one global.");
+
+          // Then we look if the global pool contains only one test actor.
+          let actorPrefix = conn._prefix + "test_one";
+          let actors = Object.keys(globalPool._actors).join();
+          info("Global actors: " + actors);
+
+          isnot(actors.indexOf(actorPrefix), -1,
+            "The test actor exists in the pool.");
+          is(actors.indexOf(actorPrefix), actors.lastIndexOf(actorPrefix),
+            "Only one actor exists in the pool.");
 
           gClient.close(finish);
         });

toolkit/devtools/Loader.jsm

@@ -35,7 +35,6 @@ let loaderGlobals = {
   btoa: btoa,
   console: console,
   _Iterator: Iterator,
-  ChromeWorker: ChromeWorker,
   loader: {
     lazyGetter: XPCOMUtils.defineLazyGetter.bind(XPCOMUtils),
     lazyImporter: XPCOMUtils.defineLazyModuleGetter.bind(XPCOMUtils),

toolkit/devtools/server/actors/root.js

@@ -258,11 +258,7 @@ RootActor.prototype = {
       }
 
       /* DebuggerServer.addGlobalActor support: create actors. */
-      if (!this._globalActorPool) {
-        this._globalActorPool = new ActorPool(this.conn);
-        this._createExtraActors(this._parameters.globalActorFactories, this._globalActorPool);
-        this.conn.addActorPool(this._globalActorPool);
-      }
+      this._createExtraActors(this._parameters.globalActorFactories, newActorPool);
 
       /*
        * Drop the old actorID -> actor map. Actors that still mattered were

toolkit/devtools/server/dbg-server.jsm

@@ -15,11 +15,31 @@ const Ci = Components.interfaces;
 const Cc = Components.classes;
 const Cu = Components.utils;
 
-const { devtools } = Cu.import("resource://gre/modules/devtools/Loader.jsm", {});
-
 this.EXPORTED_SYMBOLS = ["DebuggerServer", "ActorPool"];
 
-let server = devtools.require("devtools/server/main");
+var loadSubScript =
+  "function loadSubScript(aURL)\n" +
+  "{\n" +
+  "const Ci = Components.interfaces;\n" +
+  "const Cc = Components.classes;\n" +
+  "  try {\n" +
+  "    let loader = Cc[\"@mozilla.org/moz/jssubscript-loader;1\"]\n" +
+  "      .getService(Ci.mozIJSSubScriptLoader);\n" +
+  "    loader.loadSubScript(aURL, this);\n" +
+  "  } catch(e) {\n" +
+  "    dump(\"Error loading: \" + aURL + \": \" + e + \" - \" + e.stack + \"\\n\");\n" +
+  "    throw e;\n" +
+  "  }\n" +
+  "}";
 
-this.DebuggerServer = server.DebuggerServer;
-this.ActorPool = server.ActorPool;
+// Load the debugging server in a sandbox with its own compartment.
+var systemPrincipal = Cc["@mozilla.org/systemprincipal;1"]
+                      .createInstance(Ci.nsIPrincipal);
+
+var gGlobal = Cu.Sandbox(systemPrincipal);
+gGlobal.ChromeWorker = ChromeWorker;
+Cu.evalInSandbox(loadSubScript, gGlobal, "1.8");
+gGlobal.loadSubScript("resource://gre/modules/devtools/server/main.js");
+
+this.DebuggerServer = gGlobal.DebuggerServer;
+this.ActorPool = gGlobal.ActorPool;

toolkit/devtools/server/main.js

@@ -10,22 +10,36 @@
  * debugging global.
  */
 
-// Until all Debugger server code is converted to SDK modules,
-// imports Components.* alias from chrome module.
-var { Ci, Cc, CC, Cu, Cr } = require("chrome");
-// On B2G, `this` != Global scope, so `Ci` won't be binded on `this`
-// (i.e. this.Ci is undefined) Then later, when using loadSubScript,
-// Ci,... won't be defined for sub scripts.
-this.Ci = Ci;
-this.Cc = Cc;
-this.CC = CC;
-this.Cu = Cu;
-this.Cr = Cr;
-// Overload `Components` to prevent SDK loader exception on Components
-// object usage
-Object.defineProperty(this, "Components", {
-  get: function () require("chrome").components
-});
+// |this.require| is used to test if this file was loaded via the devtools
+// loader (as it is in DebuggerProcess.jsm) or via loadSubScript (as it is from
+// dbg-server.jsm).  Note that testing |require| is not safe in either
+// situation, as it causes a ReferenceError.
+var Ci, Cc, CC, Cu, Cr, Components;
+if (this.require) {
+  ({ Ci, Cc, CC, Cu, Cr, components: Components }) = require("chrome");
+} else {
+  ({
+    interfaces: Ci,
+    classes: Cc,
+    Constructor: CC,
+    utils: Cu,
+    results: Cr
+  }) = Components;
+}
+
+// On B2G, if |this.require| is undefined at this point, it remains undefined
+// later on when |DebuggerServer.registerModule| is called.  On desktop (and
+// perhaps other places), if |this.require| starts out undefined, it ends up
+// being set to some native code by the time we get to |registerModule|.  Here
+// we perform a test early on, and then cache the correct require function for
+// later use.
+var localRequire;
+if (this.require) {
+  localRequire = id => require(id);
+} else {
+  let { devtools } = Cu.import("resource://gre/modules/devtools/Loader.jsm", {});
+  localRequire = id => devtools.require(id);
+}
 
 const DBG_STRINGS_URI = "chrome://global/locale/devtools/debugger.properties";
 
@@ -54,12 +68,10 @@ function loadSubScript(aURL)
   }
 }
 
-let {defer, resolve, reject, promised, all} = require("sdk/core/promise");
-this.defer = defer;
-this.resolve = resolve;
-this.reject = reject;
-this.promised = promised;
-this.all = all;
+let loaderRequire = this.require;
+this.require = null;
+loadSubScript.call(this, "resource://gre/modules/commonjs/sdk/core/promise.js");
+this.require = loaderRequire;
 
 Cu.import("resource://gre/modules/devtools/SourceMap.jsm");
 
@@ -70,14 +82,12 @@ function dumpn(str) {
     dump("DBG-SERVER: " + str + "\n");
   }
 }
-this.dumpn = dumpn;
 
 function dbg_assert(cond, e) {
   if (!cond) {
     return e;
   }
 }
-this.dbg_assert = dbg_assert;
 
 loadSubScript.call(this, "resource://gre/modules/devtools/server/transport.js");
 
@@ -314,7 +324,7 @@ var DebuggerServer = {
     }
 
     let moduleAPI = ModuleAPI();
-    let mod = require(id);
+    let mod = localRequire(id);
     mod.register(moduleAPI);
     gRegisteredModules[id] = { module: mod, api: moduleAPI };
   },
@@ -678,8 +688,6 @@ var DebuggerServer = {
 if (this.exports) {
   exports.DebuggerServer = DebuggerServer;
 }
-// Needed on B2G (See header note)
-this.DebuggerServer = DebuggerServer;
 
 /**
  * Construct an ActorPool.
@@ -698,8 +706,6 @@ function ActorPool(aConnection)
 if (this.exports) {
   exports.ActorPool = ActorPool;
 }
-// Needed on B2G (See header note)
-this.ActorPool = ActorPool;
 
 ActorPool.prototype = {
   /**

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

@@ -27,7 +27,6 @@ function run_test()
   add_test(test_pre_init_tab_actor);
   add_test(test_post_init_global_actor);
   add_test(test_post_init_tab_actor);
-  add_test(test_stable_global_actor_instances);
   add_test(close_client);
   run_next_test();
 }
@@ -83,25 +82,6 @@ function test_post_init_tab_actor()
   );
 }
 
-// Get the object object, from the server side, for a given actor ID
-function getActorInstance(connID, actorID) {
-  return DebuggerServer._connections[connID].getActor(actorID);
-}
-
-function test_stable_global_actor_instances()
-{
-  // Consider that there is only one connection,
-  // and the first one is ours
-  let connID = Object.keys(DebuggerServer._connections)[0];
-  let postInitGlobalActor = getActorInstance(connID, gActors.postInitGlobalActor);
-  let preInitGlobalActor = getActorInstance(connID, gActors.preInitGlobalActor);
-  gClient.listTabs(function onListTabs(aResponse) {
-    do_check_eq(postInitGlobalActor, getActorInstance(connID, aResponse.postInitGlobalActor));
-    do_check_eq(preInitGlobalActor, getActorInstance(connID, aResponse.preInitGlobalActor));
-    run_next_test();
-  });
-}
-
 function close_client() {
   gClient.close(() => run_next_test());
 }