--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -1027,17 +1027,16 @@ pref("devtools.commands.dir", "");
 
 // Toolbox preferences
 pref("devtools.toolbox.footer.height", 250);
 pref("devtools.toolbox.sidebar.width", 500);
 pref("devtools.toolbox.host", "bottom");
 pref("devtools.toolbox.selectedTool", "webconsole");
 pref("devtools.toolbox.toolbarSpec", '["paintflashing toggle","tilt toggle","scratchpad","resize toggle"]');
 pref("devtools.toolbox.sideEnabled", true);
-pref("devtools.toolbox.disabledTools", "[]");
 
 // Enable the Inspector
 pref("devtools.inspector.enabled", true);
 pref("devtools.inspector.activeSidebar", "ruleview");
 pref("devtools.inspector.markupPreview", false);
 
 // Enable the Layout View
 pref("devtools.layoutview.enabled", true);

--- a/browser/components/sessionstore/test/Makefile.in
+++ b/browser/components/sessionstore/test/Makefile.in
@@ -25,16 +25,17 @@ MOCHITEST_BROWSER_FILES = \
 	browser_dying_cache.js \
 	browser_form_restore_events.js \
 	browser_form_restore_events_sample.html \
 	browser_formdata_format.js \
 	browser_formdata_format_sample.html \
 	browser_input.js \
 	browser_input_sample.html \
 	browser_pageshow.js \
+	browser_windowRestore_perwindowpb.js \
 	browser_248970_b_perwindowpb.js \
 	browser_248970_b_sample.html \
 	browser_339445.js \
 	browser_339445_sample.html \
 	browser_345898.js \
 	browser_346337.js \
 	browser_346337_sample.html \
 	browser_350525.js \

new file mode 100644
--- /dev/null
+++ b/browser/components/sessionstore/test/browser_windowRestore_perwindowpb.js
@@ -0,0 +1,30 @@
+/* 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 test checks that closed private windows can't be restored
+
+function test() {
+  waitForExplicitFinish();
+
+  // Purging the list of closed windows
+  while(ss.getClosedWindowCount() > 0)
+    ss.forgetClosedWindow(0);
+
+  // Load a private window, then close it 
+  // and verify it doesn't get remembered for restoring
+  var win = OpenBrowserWindow({private: true});
+
+  whenWindowLoaded(win, function onload() {
+    info("The private window got loaded");
+    win.addEventListener("SSWindowClosing", function onclosing() {
+      win.removeEventListener("SSWindowClosing", onclosing, false);
+      executeSoon(function () {
+        is (ss.getClosedWindowCount(), 0,
+            "The private window should not have been stored");
+        finish();
+      });
+    }, false);
+    win.close();
+  });
+}

--- a/browser/devtools/commandline/BuiltinCommands.jsm
+++ b/browser/devtools/commandline/BuiltinCommands.jsm
@@ -4,22 +4,24 @@
 
 const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 
 const BRAND_SHORT_NAME = Cc["@mozilla.org/intl/stringbundle;1"]
                            .getService(Ci.nsIStringBundleService)
                            .createBundle("chrome://branding/locale/brand.properties")
                            .GetStringFromName("brandShortName");
 
-this.EXPORTED_SYMBOLS = [ "CmdAddonFlags", "CmdCommands" ];
+this.EXPORTED_SYMBOLS = [ "CmdAddonFlags", "CmdCommands", "DEFAULT_DEBUG_PORT", "connect" ];
 
-Cu.import("resource:///modules/devtools/gcli.jsm");
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
-Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://gre/modules/commonjs/sdk/core/promise.js");
+Cu.import("resource://gre/modules/osfile.jsm")
+
+Cu.import("resource://gre/modules/devtools/gcli.jsm");
 Cu.import("resource:///modules/devtools/shared/event-emitter.js");
 
 XPCOMUtils.defineLazyModuleGetter(this, "gDevTools",
                                   "resource:///modules/devtools/gDevTools.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "devtools",
                                   "resource:///modules/devtools/gDevTools.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "AppCacheUtils",
                                   "resource:///modules/devtools/AppCacheUtils.jsm");
@@ -32,26 +34,26 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 
   // We need to use an object in which to store any flags because a primitive
   // would remain undefined.
   module.CmdAddonFlags = {
     addonsLoaded: false
   };
 
   /**
-  * 'addon' command.
-  */
+   * 'addon' command.
+   */
   gcli.addCommand({
     name: "addon",
     description: gcli.lookup("addonDesc")
   });
 
   /**
-  * 'addon list' command.
-  */
+   * 'addon list' command.
+   */
   gcli.addCommand({
     name: "addon list",
     description: gcli.lookup("addonListDesc"),
     returnType: "addonsInfo",
     params: [{
       name: 'type',
       type: {
         name: 'selection',
@@ -256,21 +258,21 @@ XPCOMUtils.defineLazyModuleGetter(this, 
     * 'addon enable' command.
     */
     gcli.addCommand({
       name: "addon enable",
       description: gcli.lookup("addonEnableDesc"),
       params: [nameParameter],
       exec: function(aArgs, context) {
         /**
-        * Enables the addon in the passed list which has a name that matches
-        * according to the passed name comparer, and resolves the promise which
-        * is the scope (this) of this function to display the result of this
-        * enable attempt.
-        */
+         * Enables the addon in the passed list which has a name that matches
+         * according to the passed name comparer, and resolves the promise which
+         * is the scope (this) of this function to display the result of this
+         * enable attempt.
+         */
         function enable(aName, addons) {
           // Find the add-on.
           let addon = null;
           addons.some(function(candidate) {
             if (candidate.name == aName) {
               addon = candidate;
               return true;
             } else {
@@ -293,18 +295,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
         let deferred = context.defer();
         // List the installed add-ons, enable one when done listing.
         AddonManager.getAllAddons(enable.bind(deferred, aArgs.name));
         return deferred.promise;
       }
     });
 
     /**
-    * 'addon disable' command.
-    */
+     * 'addon disable' command.
+     */
     gcli.addCommand({
       name: "addon disable",
       description: gcli.lookup("addonDisableDesc"),
       params: [nameParameter],
       exec: function(aArgs, context) {
         /**
         * Like enable, but ... you know ... the exact opposite.
         */
@@ -405,32 +407,32 @@ XPCOMUtils.defineLazyModuleGetter(this, 
     JsDebugger.addDebuggerToGlobal(global);
 
     return global.Debugger;
   });
 
   let debuggers = [];
 
   /**
-  * 'calllog' command
-  */
+   * 'calllog' command
+   */
   gcli.addCommand({
     name: "calllog",
     description: gcli.lookup("calllogDesc")
   })
 
   /**
-  * 'calllog start' command
-  */
+   * 'calllog start' command
+   */
   gcli.addCommand({
     name: "calllog start",
     description: gcli.lookup("calllogStartDesc"),
 
     exec: function(args, context) {
-      let contentWindow = context.environment.contentDocument.defaultView;
+      let contentWindow = context.environment.window;
 
       let dbg = new Debugger(contentWindow);
       dbg.onEnterFrame = function(frame) {
         // BUG 773652 -  Make the output from the GCLI calllog command nicer
         contentWindow.console.log("Method call: " + this.callDescription(frame));
       }.bind(this);
 
       debuggers.push(dbg);
@@ -462,18 +464,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       if (typeof value !== "object" || value === null) {
         return uneval(value);
       }
       return "[object " + value.class + "]";
     }
   });
 
   /**
-  * 'calllog stop' command
-  */
+   * 'calllog stop' command
+   */
   gcli.addCommand({
     name: "calllog stop",
     description: gcli.lookup("calllogStopDesc"),
 
     exec: function(args, context) {
       let numDebuggers = debuggers.length;
       if (numDebuggers == 0) {
         return gcli.lookup("calllogStopNoLogging");
@@ -501,18 +503,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 
     return global.Debugger;
   });
 
   let debuggers = [];
   let sandboxes = [];
 
   /**
-  * 'calllog chromestart' command
-  */
+   * 'calllog chromestart' command
+   */
   gcli.addCommand({
     name: "calllog chromestart",
     description: gcli.lookup("calllogChromeStartDesc"),
     get hidden() gcli.hiddenByChromePref(),
     params: [
       {
         name: "sourceType",
         type: {
@@ -524,17 +526,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
         name: "source",
         type: "string",
         description: gcli.lookup("calllogChromeSourceTypeDesc"),
         manual: gcli.lookup("calllogChromeSourceTypeManual"),
       }
     ],
     exec: function(args, context) {
       let globalObj;
-      let contentWindow = context.environment.contentDocument.defaultView;
+      let contentWindow = context.environment.window;
 
       if (args.sourceType == "jsm") {
         try {
           globalObj = Cu.import(args.source);
         }
         catch (e) {
           return gcli.lookup("callLogChromeInvalidJSM");
         }
@@ -603,18 +605,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
     callDescription: function(frame) {
       let name = frame.callee.name || gcli.lookup("callLogChromeAnonFunction");
       let args = frame.arguments.map(this.valueToString).join(", ");
       return name + "(" + args + ")";
     }
   });
 
   /**
-  * 'calllog chromestop' command
-  */
+   * 'calllog chromestop' command
+   */
   gcli.addCommand({
     name: "calllog chromestop",
     description: gcli.lookup("calllogChromeStopDesc"),
     get hidden() gcli.hiddenByChromePref(),
     exec: function(args, context) {
       let numDebuggers = debuggers.length;
       if (numDebuggers == 0) {
         return gcli.lookup("calllogChromeStopNoLogging");
@@ -647,32 +649,32 @@ XPCOMUtils.defineLazyModuleGetter(this, 
   XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
                                     "resource://gre/modules/NetUtil.jsm");
   XPCOMUtils.defineLazyModuleGetter(this, "console",
                                     "resource://gre/modules/devtools/Console.jsm");
 
   const PREF_DIR = "devtools.commands.dir";
 
   /**
-  * A place to store the names of the commands that we have added as a result of
-  * calling refreshAutoCommands(). Used by refreshAutoCommands to remove the
-  * added commands.
-  */
+   * A place to store the names of the commands that we have added as a result of
+   * calling refreshAutoCommands(). Used by refreshAutoCommands to remove the
+   * added commands.
+   */
   let commands = [];
 
   /**
-  * Exported API
-  */
+   * Exported API
+   */
   this.CmdCommands = {
     /**
-    * Called to look in a directory pointed at by the devtools.commands.dir pref
-    * for *.mozcmd files which are then loaded.
-    * @param nsIPrincipal aSandboxPrincipal Scope object for the Sandbox in which
-    * we eval the script from the .mozcmd file. This should be a chrome window.
-    */
+     * Called to look in a directory pointed at by the devtools.commands.dir pref
+     * for *.mozcmd files which are then loaded.
+     * @param nsIPrincipal aSandboxPrincipal Scope object for the Sandbox in which
+     * we eval the script from the .mozcmd file. This should be a chrome window.
+     */
     refreshAutoCommands: function GC_refreshAutoCommands(aSandboxPrincipal) {
       // First get rid of the last set of commands
       commands.forEach(function(name) {
         gcli.removeCommand(name);
       });
 
       let dirName = prefBranch.getComplexValue(PREF_DIR,
                                               Ci.nsISupportsString).data.trim();
@@ -729,22 +731,22 @@ XPCOMUtils.defineLazyModuleGetter(this, 
             }
           );
         }
       );
     }
   };
 
   /**
-  * Load the commands from a single file
-  * @param OS.File.DirectoryIterator.Entry aFileEntry The DirectoryIterator
-  * Entry of the file containing the commands that we should read
-  * @param nsIPrincipal aSandboxPrincipal Scope object for the Sandbox in which
-  * we eval the script from the .mozcmd file. This should be a chrome window.
-  */
+   * Load the commands from a single file
+   * @param OS.File.DirectoryIterator.Entry aFileEntry The DirectoryIterator
+   * Entry of the file containing the commands that we should read
+   * @param nsIPrincipal aSandboxPrincipal Scope object for the Sandbox in which
+   * we eval the script from the .mozcmd file. This should be a chrome window.
+   */
   function loadCommandFile(aFileEntry, aSandboxPrincipal) {
     let promise = OS.File.read(aFileEntry.path);
     promise = promise.then(
       function onSuccess(array) {
         let decoder = new TextDecoder();
         let source = decoder.decode(array);
 
         let sandbox = new Cu.Sandbox(aSandboxPrincipal, {
@@ -768,27 +770,27 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       function onError(reason) {
         console.error("OS.File.read(" + aFileEntry.path + ") failed.");
         throw reason;
       }
     );
   }
 
   /**
-  * 'cmd' command
-  */
+   * 'cmd' command
+   */
   gcli.addCommand({
     name: "cmd",
     get hidden() { return !prefBranch.prefHasUserValue(PREF_DIR); },
     description: gcli.lookup("cmdDesc")
   });
 
   /**
-  * 'cmd refresh' command
-  */
+   * 'cmd refresh' command
+   */
   gcli.addCommand({
     name: "cmd refresh",
     description: gcli.lookup("cmdRefreshDesc"),
     get hidden() { return !prefBranch.prefHasUserValue(PREF_DIR); },
     exec: function Command_cmdRefresh(args, context) {
       let chromeWindow = context.environment.chromeDocument.defaultView;
       CmdCommands.refreshAutoCommands(chromeWindow);
     }
@@ -797,56 +799,55 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 
 /* CmdConsole -------------------------------------------------------------- */
 
 (function(module) {
   XPCOMUtils.defineLazyModuleGetter(this, "HUDService",
                                     "resource:///modules/HUDService.jsm");
 
   /**
-  * 'console' command
-  */
+   * 'console' command
+   */
   gcli.addCommand({
     name: "console",
     description: gcli.lookup("consoleDesc"),
     manual: gcli.lookup("consoleManual")
   });
 
   /**
-  * 'console clear' command
-  */
+   * 'console clear' command
+   */
   gcli.addCommand({
     name: "console clear",
     description: gcli.lookup("consoleclearDesc"),
     exec: function Command_consoleClear(args, context) {
-      let window = context.environment.contentDocument.defaultView;
-      let hud = HUDService.getHudByWindow(window);
+      let hud = HUDService.getHudByWindow(context.environment.window);
       // hud will be null if the web console has not been opened for this window
       if (hud) {
         hud.jsterm.clearOutput();
       }
     }
   });
 
   /**
-  * 'console close' command
-  */
+   * 'console close' command
+   */
   gcli.addCommand({
     name: "console close",
     description: gcli.lookup("consolecloseDesc"),
     exec: function Command_consoleClose(args, context) {
       let gBrowser = context.environment.chromeDocument.defaultView.gBrowser;
       let target = devtools.TargetFactory.forTab(gBrowser.selectedTab);
       return gDevTools.closeToolbox(target);
     }
   });
 
   /**
-  * 'console open' command
-  */
+   * 'console open' command
+   */
   gcli.addCommand({
     name: "console open",
     description: gcli.lookup("consoleopenDesc"),
     exec: function Command_consoleOpen(args, context) {
       let gBrowser = context.environment.chromeDocument.defaultView.gBrowser;
       let target = devtools.TargetFactory.forTab(gBrowser.selectedTab);
       return gDevTools.showToolbox(target, "webconsole");
     }
@@ -971,17 +972,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
    */
   gcli.addCommand({
     name: "cookie list",
     description: gcli.lookup("cookieListDesc"),
     manual: gcli.lookup("cookieListManual"),
     returnType: "cookies",
     exec: function Command_cookieList(args, context) {
       let host = context.environment.document.location.host;
-      if (host == null) {
+      if (host == null || host == "") {
         throw new Error(gcli.lookup("cookieListOutNonePage"));
       }
 
       let enm = cookieMgr.getCookiesFromHost(host);
 
       let cookies = [];
       while (enm.hasMoreElements()) {
         let cookie = enm.getNext().QueryInterface(Ci.nsICookie);
@@ -1018,17 +1019,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       }
     ],
     exec: function Command_cookieRemove(args, context) {
       let host = context.environment.document.location.host;
       let enm = cookieMgr.getCookiesFromHost(host);
 
       let cookies = [];
       while (enm.hasMoreElements()) {
-        let cookie = enm.getNext().QueryInterface(Components.interfaces.nsICookie);
+        let cookie = enm.getNext().QueryInterface(Ci.nsICookie);
         if (isCookieAtHost(cookie, host)) {
           if (cookie.name == args.name) {
             cookieMgr.remove(cookie.host, cookie.name, cookie.path, false);
           }
         }
       }
     }
   });
@@ -1151,55 +1152,31 @@ XPCOMUtils.defineLazyModuleGetter(this, 
           visible: true,
           typed: command
         });
       });
     }
   }
 }(this));
 
-/* CmdEcho ----------------------------------------------------------------- */
-
-(function(module) {
-  /**
-  * 'echo' command
-  */
-  gcli.addCommand({
-    name: "echo",
-    description: gcli.lookup("echoDesc"),
-    params: [
-      {
-        name: "message",
-        type: "string",
-        description: gcli.lookup("echoMessageDesc")
-      }
-    ],
-    returnType: "string",
-    hidden: true,
-    exec: function Command_echo(args, context) {
-      return args.message;
-    }
-  });
-}(this));
-
 /* CmdExport --------------------------------------------------------------- */
 
 (function(module) {
   /**
-  * 'export' command
-  */
+   * 'export' command
+   */
   gcli.addCommand({
     name: "export",
     description: gcli.lookup("exportDesc"),
   });
 
   /**
-  * The 'export html' command. This command allows the user to export the page to
-  * HTML after they do DOM changes.
-  */
+   * The 'export html' command. This command allows the user to export the page to
+   * HTML after they do DOM changes.
+   */
   gcli.addCommand({
     name: "export html",
     description: gcli.lookup("exportHtmlDesc"),
     exec: function(args, context) {
       let html = context.environment.document.documentElement.outerHTML;
       let url = 'data:text/plain;charset=utf8,' + encodeURIComponent(html);
       context.environment.window.open(url);
     }
@@ -1211,18 +1188,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 (function(module) {
   const XMLHttpRequest =
     Components.Constructor("@mozilla.org/xmlextras/xmlhttprequest;1");
 
   XPCOMUtils.defineLazyModuleGetter(this, "js_beautify",
                                     "resource:///modules/devtools/Jsbeautify.jsm");
 
   /**
-  * jsb command.
-  */
+   * jsb command.
+   */
   gcli.addCommand({
     name: 'jsb',
     description: gcli.lookup('jsbDesc'),
     returnValue:'string',
     params: [
       {
         name: 'url',
         type: 'string',
@@ -1338,27 +1315,27 @@ XPCOMUtils.defineLazyModuleGetter(this, 
     }
   });
 }(this));
 
 /* CmdPagemod -------------------------------------------------------------- */
 
 (function(module) {
   /**
-  * 'pagemod' command
-  */
+   * 'pagemod' command
+   */
   gcli.addCommand({
     name: "pagemod",
     description: gcli.lookup("pagemodDesc"),
   });
 
   /**
-  * The 'pagemod replace' command. This command allows the user to search and
-  * replace within text nodes and attributes.
-  */
+   * The 'pagemod replace' command. This command allows the user to search and
+   * replace within text nodes and attributes.
+   */
   gcli.addCommand({
     name: "pagemod replace",
     description: gcli.lookup("pagemodReplaceDesc"),
     params: [
       {
         name: "search",
         type: "string",
         description: gcli.lookup("pagemodReplaceSearchDesc"),
@@ -1398,27 +1375,26 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       {
         name: "attributes",
         type: "string",
         description: gcli.lookup("pagemodReplaceAttributesDesc"),
         defaultValue: null,
       },
     ],
     exec: function(args, context) {
-      let document = context.environment.contentDocument;
       let searchTextNodes = !args.attrOnly;
       let searchAttributes = !args.contentOnly;
       let regexOptions = args.ignoreCase ? 'ig' : 'g';
       let search = new RegExp(escapeRegex(args.search), regexOptions);
       let attributeRegex = null;
       if (args.attributes) {
         attributeRegex = new RegExp(args.attributes, regexOptions);
       }
 
-      let root = args.root || document;
+      let root = args.root || context.environment.document;
       let elements = root.querySelectorAll(args.selector);
       elements = Array.prototype.slice.call(elements);
 
       let replacedTextNodes = 0;
       let replacedAttributes = 0;
 
       function replaceAttribute() {
         replacedAttributes++;
@@ -1455,27 +1431,27 @@ XPCOMUtils.defineLazyModuleGetter(this, 
 
       return gcli.lookupFormat("pagemodReplaceResult",
                               [elements.length, replacedTextNodes,
                                 replacedAttributes]);
     }
   });
 
   /**
-  * 'pagemod remove' command
-  */
+   * 'pagemod remove' command
+   */
   gcli.addCommand({
     name: "pagemod remove",
     description: gcli.lookup("pagemodRemoveDesc"),
   });
 
 
   /**
-  * The 'pagemod remove element' command.
-  */
+   * The 'pagemod remove element' command.
+   */
   gcli.addCommand({
     name: "pagemod remove element",
     description: gcli.lookup("pagemodRemoveElementDesc"),
     params: [
       {
         name: "search",
         type: "string",
         description: gcli.lookup("pagemodRemoveElementSearchDesc"),
@@ -1493,18 +1469,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       },
       {
         name: 'ifEmptyOnly',
         type: 'boolean',
         description: gcli.lookup("pagemodRemoveElementIfEmptyOnlyDesc"),
       },
     ],
     exec: function(args, context) {
-      let document = context.environment.contentDocument;
-      let root = args.root || document;
+      let root = args.root || context.environment.document;
       let elements = Array.prototype.slice.call(root.querySelectorAll(args.search));
 
       let removed = 0;
       for (let i = 0; i < elements.length; i++) {
         let element = elements[i];
         let parentNode = element.parentNode;
         if (!parentNode || !element.removeChild) {
           continue;
@@ -1521,18 +1496,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       }
 
       return gcli.lookupFormat("pagemodRemoveElementResultMatchedAndRemovedElements",
                               [elements.length, removed]);
     }
   });
 
   /**
-  * The 'pagemod remove attribute' command.
-  */
+   * The 'pagemod remove attribute' command.
+   */
   gcli.addCommand({
     name: "pagemod remove attribute",
     description: gcli.lookup("pagemodRemoveAttributeDesc"),
     params: [
       {
         name: "searchAttributes",
         type: "string",
         description: gcli.lookup("pagemodRemoveAttributeSearchAttributesDesc"),
@@ -1550,19 +1525,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       },
       {
         name: "ignoreCase",
         type: "boolean",
         description: gcli.lookup("pagemodRemoveAttributeIgnoreCaseDesc"),
       },
     ],
     exec: function(args, context) {
-      let document = context.environment.contentDocument;
-
-      let root = args.root || document;
+      let root = args.root || context.environment.document;
       let regexOptions = args.ignoreCase ? 'ig' : 'g';
       let attributeRegex = new RegExp(args.searchAttributes, regexOptions);
       let elements = root.querySelectorAll(args.searchElements);
       elements = Array.prototype.slice.call(elements);
 
       let removed = 0;
       for (let i = 0; i < elements.length; i++) {
         let element = elements[i];
@@ -1581,23 +1554,23 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       }
 
       return gcli.lookupFormat("pagemodRemoveAttributeResult",
                               [elements.length, removed]);
     }
   });
 
   /**
-  * Make a given string safe to use  in a regular expression.
-  *
-  * @param string aString
-  *        The string you want to use in a regex.
-  * @return string
-  *         The equivalent of |aString| but safe to use in a regex.
-  */
+   * Make a given string safe to use  in a regular expression.
+   *
+   * @param string aString
+   *        The string you want to use in a regex.
+   * @return string
+   *         The equivalent of |aString| but safe to use in a regex.
+   */
   function escapeRegex(aString) {
     return aString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
   }
 }(this));
 
 /* CmdTools -------------------------------------------------------------- */
 
 (function(module) {
@@ -1617,32 +1590,31 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       {
         name: "srcdir",
         type: "string",
         description: gcli.lookup("toolsSrcdirDir")
       }
     ],
     returnType: "string",
     exec: function(args, context) {
-      let promise = context.createPromise();
-      let existsPromise = OS.File.exists(args.srcdir + "/CLOBBER");
-      existsPromise.then(function(exists) {
+      return OS.File.exists(args.srcdir + "/CLOBBER").then(function(exists) {
         if (exists) {
-          var str = Cc["@mozilla.org/supports-string;1"]
-            .createInstance(Ci.nsISupportsString);
+          let str = Cc["@mozilla.org/supports-string;1"]
+                    .createInstance(Ci.nsISupportsString);
           str.data = args.srcdir;
           Services.prefs.setComplexValue("devtools.loader.srcdir",
-              Components.interfaces.nsISupportsString, str);
+                                         Ci.nsISupportsString, str);
           devtools.reload();
-          promise.resolve(gcli.lookupFormat("toolsSrcdirReloaded", [args.srcdir]));
-          return;
+
+          let msg = gcli.lookupFormat("toolsSrcdirReloaded", [args.srcdir]);
+          throw new Error(msg);
         }
-        promise.reject(gcli.lookupFormat("toolsSrcdirNotFound", [args.srcdir]));
+
+        return gcli.lookupFormat("toolsSrcdirNotFound", [args.srcdir]);
       });
-      return promise;
     }
   });
 
   gcli.addCommand({
     name: "tools builtin",
     description: gcli.lookup("toolsBuiltinDesc"),
     manual: gcli.lookup("toolsBuiltinManual"),
     get hidden() gcli.hiddenByChromePref(),
@@ -1666,28 +1638,27 @@ XPCOMUtils.defineLazyModuleGetter(this, 
     }
   });
 }(this));
 
 /* CmdRestart -------------------------------------------------------------- */
 
 (function(module) {
   /**
-  * Restart command
-  *
-  * @param boolean nocache
-  *        Disables loading content from cache upon restart.
-  *
-  * Examples :
-  * >> restart
-  * - restarts browser immediately
-  * >> restart --nocache
-  * - restarts immediately and starts Firefox without using cache
-  */
-
+   * Restart command
+   *
+   * @param boolean nocache
+   *        Disables loading content from cache upon restart.
+   *
+   * Examples :
+   * >> restart
+   * - restarts browser immediately
+   * >> restart --nocache
+   * - restarts immediately and starts Firefox without using cache
+   */
   gcli.addCommand({
     name: "restart",
     description: gcli.lookupFormat("restartBrowserDesc", [BRAND_SHORT_NAME]),
     params: [
       {
         name: "nocache",
         type: "boolean",
         description: gcli.lookup("restartBrowserNocacheDesc")
@@ -1722,23 +1693,23 @@ XPCOMUtils.defineLazyModuleGetter(this, 
   XPCOMUtils.defineLazyModuleGetter(this, "LayoutHelpers",
                                     "resource:///modules/devtools/LayoutHelpers.jsm");
 
   // String used as an indication to generate default file name in the following
   // format: "Screen Shot yyyy-mm-dd at HH.MM.SS.png"
   const FILENAME_DEFAULT_VALUE = " ";
 
   /**
-  * 'screenshot' command
-  */
+   * 'screenshot' command
+   */
   gcli.addCommand({
     name: "screenshot",
     description: gcli.lookup("screenshotDesc"),
     manual: gcli.lookup("screenshotManual"),
-    returnType: "html",
+    returnType: "dom",
     params: [
       {
         name: "filename",
         type: "string",
         defaultValue: FILENAME_DEFAULT_VALUE,
         description: gcli.lookup("screenshotFilenameDesc"),
         manual: gcli.lookup("screenshotFilenameManual")
       },
@@ -1783,34 +1754,32 @@ XPCOMUtils.defineLazyModuleGetter(this, 
     exec: function Command_screenshot(args, context) {
       if (args.chrome && args.selector) {
         // Node screenshot with chrome option does not work as inteded
         // Refer https://bugzilla.mozilla.org/show_bug.cgi?id=659268#c7
         // throwing for now.
         throw new Error(gcli.lookup("screenshotSelectorChromeConflict"));
       }
       var document = args.chrome? context.environment.chromeDocument
-                                : context.environment.contentDocument;
+                                : context.environment.document;
       if (args.delay > 0) {
         var deferred = context.defer();
         document.defaultView.setTimeout(function Command_screenshotDelay() {
           let reply = this.grabScreen(document, args.filename, args.clipboard,
                                       args.fullpage);
           deferred.resolve(reply);
         }.bind(this), args.delay * 1000);
         return deferred.promise;
       }
       else {
         return this.grabScreen(document, args.filename, args.clipboard,
                               args.fullpage, args.selector);
       }
     },
-    grabScreen:
-    function Command_screenshotGrabScreen(document, filename, clipboard,
-                                          fullpage, node) {
+    grabScreen: function(document, filename, clipboard, fullpage, node) {
       let window = document.defaultView;
       let canvas = document.createElementNS("http://www.w3.org/1999/xhtml", "canvas");
       let left = 0;
       let top = 0;
       let width;
       let height;
       let div = document.createElementNS("http://www.w3.org/1999/xhtml", "div");
 
@@ -1943,23 +1912,63 @@ XPCOMUtils.defineLazyModuleGetter(this, 
                         "background-size: 256px " + previewHeight + "px;" +
                         "margin: 4px; display: block");
       div.appendChild(image);
       return div;
     }
   });
 }(this));
 
+
+/* Remoting ----------------------------------------------------------- */
+
+const { DebuggerServer } = Cu.import("resource://gre/modules/devtools/dbg-server.jsm", {});
+
+/**
+ * 'listen' command
+ */
+gcli.addCommand({
+  name: "listen",
+  description: gcli.lookup("listenDesc"),
+  manual: gcli.lookup("listenManual"),
+  params: [
+    {
+      name: "port",
+      type: "number",
+      get defaultValue() {
+        return Services.prefs.getIntPref("devtools.debugger.chrome-debugging-port");
+      },
+      description: gcli.lookup("listenPortDesc"),
+    }
+  ],
+  exec: function Command_screenshot(args, context) {
+    if (!DebuggerServer.initialized) {
+      DebuggerServer.init();
+      DebuggerServer.addBrowserActors();
+    }
+    var reply = DebuggerServer.openListener(args.port);
+    if (!reply) {
+      throw new Error(gcli.lookup("listenDisabledOutput"));
+    }
+
+    if (DebuggerServer.initialized) {
+      return gcli.lookupFormat("listenInitOutput", [ '' + args.port ]);
+    }
+
+    return gcli.lookup("listenNoInitOutput");
+  },
+});
+
+
 /* CmdPaintFlashing ------------------------------------------------------- */
 
 (function(module) {
   /**
-  * 'paintflashing' command
-  */
-
+   * 'paintflashing' command
+   */
   gcli.addCommand({
     name: 'paintflashing',
     description: gcli.lookup('paintflashingDesc')
   });
 
   gcli.addCommand({
     name: 'paintflashing on',
     description: gcli.lookup('paintflashingOnDesc'),
@@ -1971,25 +1980,23 @@ XPCOMUtils.defineLazyModuleGetter(this, 
           type: "boolean",
           name: "chrome",
           get hidden() gcli.hiddenByChromePref(),
           description: gcli.lookup("paintflashingChromeDesc"),
         }
       ]
     }],
     exec: function(args, context) {
-      var window;
-      if (args.chrome) {
-        window = context.environment.chromeDocument.defaultView;
-      } else {
-        window = context.environment.contentDocument.defaultView;
-      }
-      window.QueryInterface(Ci.nsIInterfaceRequestor).
-             getInterface(Ci.nsIDOMWindowUtils).
-             paintFlashing = true;
+      var window = args.chrome ?
+                  context.environment.chromeWindow :
+                  context.environment.window;
+
+      window.QueryInterface(Ci.nsIInterfaceRequestor)
+            .getInterface(Ci.nsIDOMWindowUtils)
+            .paintFlashing = true;
       onPaintFlashingChanged(context);
     }
   });
 
   gcli.addCommand({
     name: 'paintflashing off',
     description: gcli.lookup('paintflashingOffDesc'),
     manual: gcli.lookup('paintflashingManual'),
@@ -2000,24 +2007,23 @@ XPCOMUtils.defineLazyModuleGetter(this, 
           type: "boolean",
           name: "chrome",
           get hidden() gcli.hiddenByChromePref(),
           description: gcli.lookup("paintflashingChromeDesc"),
         }
       ]
     }],
     exec: function(args, context) {
-      if (args.chrome) {
-        var window = context.environment.chromeDocument.defaultView;
-      } else {
-        var window = context.environment.contentDocument.defaultView;
-      }
-      window.QueryInterface(Ci.nsIInterfaceRequestor).
-             getInterface(Ci.nsIDOMWindowUtils).
-             paintFlashing = false;
+      var window = args.chrome ?
+                  context.environment.chromeWindow :
+                  context.environment.window;
+
+      window.QueryInterface(Ci.nsIInterfaceRequestor)
+            .getInterface(Ci.nsIDOMWindowUtils)
+            .paintFlashing = false;
       onPaintFlashingChanged(context);
     }
   });
 
   gcli.addCommand({
     name: 'paintflashing toggle',
     hidden: true,
     buttonId: "command-button-paintflashing",
@@ -2036,17 +2042,17 @@ XPCOMUtils.defineLazyModuleGetter(this, 
       onChange: function(aTarget, aChangeHandler) {
         eventEmitter.on("changed", aChangeHandler);
       },
       offChange: function(aTarget, aChangeHandler) {
         eventEmitter.off("changed", aChangeHandler);
       },
     },
     tooltipText: gcli.lookup("paintflashingTooltip"),
-    description: gcli.lookup('paintflashingOnDesc'),
+    description: gcli.lookup('paintflashingToggleDesc'),
     manual: gcli.lookup('paintflashingManual'),
     exec: function(args, context) {
       var gBrowser = context.environment.chromeDocument.defaultView.gBrowser;
       var window = gBrowser.contentWindow;
       var wUtils = window.QueryInterface(Ci.nsIInterfaceRequestor).
                    getInterface(Ci.nsIDOMWindowUtils);
       wUtils.paintFlashing = !wUtils.paintFlashing;
       onPaintFlashingChanged(context);
@@ -2066,18 +2072,18 @@ XPCOMUtils.defineLazyModuleGetter(this, 
     target.once("navigate", fireChange);
   }
 }(this));
 
 /* CmdAppCache ------------------------------------------------------- */
 
 (function(module) {
   /**
-  * 'appcache' command
-  */
+   * 'appcache' command
+   */
 
   gcli.addCommand({
     name: 'appcache',
     description: gcli.lookup('appCacheDesc')
   });
 
   gcli.addConverter({
     from: "appcacheerrors",
@@ -2120,101 +2126,88 @@ XPCOMUtils.defineLazyModuleGetter(this, 
           name: "uri",
           description: gcli.lookup("appCacheValidateUriDesc"),
           defaultValue: null,
         }
       ]
     }],
     exec: function(args, context) {
       let utils;
-      let promise = context.createPromise();
+      let deferred = context.defer();
 
       if (args.uri) {
         utils = new AppCacheUtils(args.uri);
       } else {
-        let doc = context.environment.contentDocument;
-        utils = new AppCacheUtils(doc);
+        utils = new AppCacheUtils(context.environment.document);
       }
 
       utils.validateManifest().then(function(errors) {
-        promise.resolve([errors, utils.manifestURI || "-"]);
+        deferred.resolve([errors, utils.manifestURI || "-"]);
       });
 
-      return promise;
+      return deferred.promise;
     }
   });
 
   gcli.addCommand({
     name: 'appcache clear',
     description: gcli.lookup('appCacheClearDesc'),
     manual: gcli.lookup('appCacheClearManual'),
     exec: function(args, context) {
       let utils = new AppCacheUtils(args.uri);
       utils.clearAll();
 
       return gcli.lookup("appCacheClearCleared");
     }
   });
 
+  let appcacheListEntries = "" +
+    "<ul class='gcli-appcache-list'>" +
+    "  <li foreach='entry in ${entries}'>" +
+    "    <table class='gcli-appcache-detail'>" +
+    "      <tr>" +
+    "        <td>" + gcli.lookup("appCacheListKey") + "</td>" +
+    "        <td>${entry.key}</td>" +
+    "      </tr>" +
+    "      <tr>" +
+    "        <td>" + gcli.lookup("appCacheListFetchCount") + "</td>" +
+    "        <td>${entry.fetchCount}</td>" +
+    "      </tr>" +
+    "      <tr>" +
+    "        <td>" + gcli.lookup("appCacheListLastFetched") + "</td>" +
+    "        <td>${entry.lastFetched}</td>" +
+    "      </tr>" +
+    "      <tr>" +
+    "        <td>" + gcli.lookup("appCacheListLastModified") + "</td>" +
+    "        <td>${entry.lastModified}</td>" +
+    "      </tr>" +
+    "      <tr>" +
+    "        <td>" + gcli.lookup("appCacheListExpirationTime") + "</td>" +
+    "        <td>${entry.expirationTime}</td>" +
+    "      </tr>" +
+    "      <tr>" +
+    "        <td>" + gcli.lookup("appCacheListDataSize") + "</td>" +
+    "        <td>${entry.dataSize}</td>" +
+    "      </tr>" +
+    "      <tr>" +
+    "        <td>" + gcli.lookup("appCacheListDeviceID") + "</td>" +
+    "        <td>${entry.deviceID} <span class='gcli-out-shortcut' " +
+    "onclick='${onclick}' ondblclick='${ondblclick}' " +
+    "data-command='appcache viewentry ${entry.key}'" +
+    ">" + gcli.lookup("appCacheListViewEntry") + "</span>" +
+    "        </td>" +
+    "      </tr>" +
+    "    </table>" +
+    "  </li>" +
+    "</ul>";
+
   gcli.addConverter({
     from: "appcacheentries",
     to: "view",
     exec: function(entries, context) {
-      if (!entries) {
-        return context.createView({
-          html: "<span>" + gcli.lookup("appCacheManifestContainsErrors") + "</span>"
-        });
-      }
-
-      if (entries.length == 0) {
-        return context.createView({
-          html: "<span>" + gcli.lookup("appCacheNoResults") + "</span>"
-        });
-      }
-
-      let appcacheListEntries = "" +
-        "<ul class='gcli-appcache-list'>" +
-        "  <li foreach='entry in ${entries}'>" +
-        "    <table class='gcli-appcache-detail'>" +
-        "      <tr>" +
-        "        <td>" + gcli.lookup("appCacheListKey") + "</td>" +
-        "        <td>${entry.key}</td>" +
-        "      </tr>" +
-        "      <tr>" +
-        "        <td>" + gcli.lookup("appCacheListFetchCount") + "</td>" +
-        "        <td>${entry.fetchCount}</td>" +
-        "      </tr>" +
-        "      <tr>" +
-        "        <td>" + gcli.lookup("appCacheListLastFetched") + "</td>" +
-        "        <td>${entry.lastFetched}</td>" +
-        "      </tr>" +
-        "      <tr>" +
-        "        <td>" + gcli.lookup("appCacheListLastModified") + "</td>" +
-        "        <td>${entry.lastModified}</td>" +
-        "      </tr>" +
-        "      <tr>" +
-        "        <td>" + gcli.lookup("appCacheListExpirationTime") + "</td>" +
-        "        <td>${entry.expirationTime}</td>" +
-        "      </tr>" +
-        "      <tr>" +
-        "        <td>" + gcli.lookup("appCacheListDataSize") + "</td>" +
-        "        <td>${entry.dataSize}</td>" +
-        "      </tr>" +
-        "      <tr>" +
-        "        <td>" + gcli.lookup("appCacheListDeviceID") + "</td>" +
-        "        <td>${entry.deviceID} <span class='gcli-out-shortcut' " +
-        "onclick='${onclick}' ondblclick='${ondblclick}' " +
-        "data-command='appcache viewentry ${entry.key}'" +
-        ">" + gcli.lookup("appCacheListViewEntry") + "</span>" +
-        "        </td>" +
-        "      </tr>" +
-        "    </table>" +
-        "  </li>" +
-        "</ul>";
-
       return context.createView({
         html: appcacheListEntries,
         data: {
           entries: entries,
           onclick: createUpdateHandler(context),
           ondblclick: createExecuteHandler(context),
         }
       });
@@ -2233,44 +2226,36 @@ XPCOMUtils.defineLazyModuleGetter(this, 
           type: "string",
           name: "search",
           description: gcli.lookup("appCacheListSearchDesc"),
           defaultValue: null,
         },
       ]
     }],
     exec: function(args, context) {
-      let doc = context.environment.contentDocument;
       let utils = new AppCacheUtils();
-
-      let entries = utils.listEntries(args.search);
-      return entries;
+      return utils.listEntries(args.search);
     }
   });
 
   gcli.addCommand({
     name: 'appcache viewentry',
     description: gcli.lookup('appCacheViewEntryDesc'),
     manual: gcli.lookup('appCacheViewEntryManual'),
     params: [
       {
         type: "string",
         name: "key",
         description: gcli.lookup("appCacheViewEntryKey"),
         defaultValue: null,
       }
     ],
     exec: function(args, context) {
-      let doc = context.environment.contentDocument;
       let utils = new AppCacheUtils();
-
-      let result = utils.viewEntry(args.key);
-      if (result) {
-        return result;
-      }
+      return utils.viewEntry(args.key);
     }
   });
 
   /**
    * Helper to find the 'data-command' attribute and call some action on it.
    * @see |updateCommand()| and |executeCommand()|
    */
   function withCommand(element, action) {

--- a/browser/devtools/commandline/test/Makefile.in
+++ b/browser/devtools/commandline/test/Makefile.in
@@ -26,16 +26,17 @@ MOCHITEST_BROWSER_FILES = \
   browser_cmd_appcache_valid.js \
   browser_cmd_appcache_valid_appcache.appcache \
   browser_cmd_appcache_valid_appcache.appcache^headers^ \
   browser_cmd_appcache_valid_index.html \
   browser_cmd_appcache_valid_page1.html \
   browser_cmd_appcache_valid_page2.html \
   browser_cmd_appcache_valid_page3.html \
   browser_cmd_commands.js \
+  browser_cmd_cookie.html \
   browser_cmd_cookie.js \
   browser_cmd_jsb.js \
   browser_cmd_jsb_script.jsi \
   browser_cmd_pagemod_export.html \
   browser_cmd_pagemod_export.js \
   browser_cmd_pref.js \
   browser_cmd_restart.js \
   browser_cmd_screenshot.html \

--- a/browser/devtools/commandline/test/browser_cmd_addon.js
+++ b/browser/devtools/commandline/test/browser_cmd_addon.js
@@ -11,23 +11,18 @@ function test() {
   helpers.addTabWithToolbar("about:blank", function(options) {
     return helpers.runTests(options, tests);
   }).then(finish);
 }
 
 tests.gatTest = function(options) {
   let deferred = Promise.defer();
 
-  // hack to reduce stack size as a result of bug 842347
-  let onGatReadyInterjection = function() {
-    executeSoon(onGatReady);
-  };
-
   let onGatReady = function() {
-    Services.obs.removeObserver(onGatReadyInterjection, "gcli_addon_commands_ready");
+    Services.obs.removeObserver(onGatReady, "gcli_addon_commands_ready");
     info("gcli_addon_commands_ready notification received, running tests");
 
     let auditDone = helpers.audit(options, [
       {
         setup: 'addon list dictionary',
         check: {
           input:  'addon list dictionary',
           hints:                       '',
@@ -116,17 +111,17 @@ tests.gatTest = function(options) {
       }
     ]);
 
     auditDone.then(function() {
       deferred.resolve();
     });
   };
 
-  Services.obs.addObserver(onGatReadyInterjection, "gcli_addon_commands_ready", false);
+  Services.obs.addObserver(onGatReady, "gcli_addon_commands_ready", false);
 
   if (CmdAddonFlags.addonsLoaded) {
     info("The call to AddonManager.getAllAddons in BuiltinCommands.jsm is done.");
     info("Send the gcli_addon_commands_ready notification ourselves.");
 
     Services.obs.notifyObservers(null, "gcli_addon_commands_ready", null);
   } else {
     info("Waiting for gcli_addon_commands_ready notification.");

--- a/browser/devtools/commandline/test/browser_cmd_appcache_valid.js
+++ b/browser/devtools/commandline/test/browser_cmd_appcache_valid.js
@@ -26,16 +26,35 @@ function test() {
             input:  'appcache',
             markup: 'IIIIIIII',
             status: 'ERROR',
             args: {}
           },
         },
 
         {
+          setup: function() {
+            Services.prefs.setBoolPref("browser.cache.disk.enable", false);
+            helpers.setInput(options, 'appcache list', 13);
+          },
+          check: {
+            input:  'appcache list',
+            markup: 'VVVVVVVVVVVVV',
+            status: 'VALID',
+            args: {},
+          },
+          exec: {
+            output: [ /cache is disabled/ ]
+          },
+          post: function(output) {
+            Services.prefs.setBoolPref("browser.cache.disk.enable", true);
+          }
+        },
+
+        {
           setup: 'appcache list',
           check: {
             input:  'appcache list',
             markup: 'VVVVVVVVVVVVV',
             status: 'VALID',
             args: {},
           },
           exec: {
@@ -51,18 +70,18 @@ function test() {
             status: 'VALID',
             args: {
               search: { value: 'page' },
             }
           },
           exec: {
             output: [ /page1/, /page2/, /page3/ ]
           },
-          post: function(output) {
-            ok(!output.contains("index"), "index is not contained in output");
+          post: function(output, text) {
+            ok(!text.contains("index"), "index is not contained in output");
           }
         },
 
         {
           setup: 'appcache validate',
           check: {
             input:  'appcache validate',
             markup: 'VVVVVVVVVVVVVVVVV',
@@ -113,21 +132,21 @@ function test() {
             input:  'appcache list',
             markup: 'VVVVVVVVVVVVV',
             status: 'VALID',
             args: {},
           },
           exec: {
             output: [ /no results/ ]
           },
-          post: function(output) {
-            ok(!output.contains("index"), "index is not contained in output");
-            ok(!output.contains("page1"), "page1 is not contained in output");
-            ok(!output.contains("page2"), "page1 is not contained in output");
-            ok(!output.contains("page3"), "page1 is not contained in output");
+          post: function(output, text) {
+            ok(!text.contains("index"), "index is not contained in output");
+            ok(!text.contains("page1"), "page1 is not contained in output");
+            ok(!text.contains("page2"), "page1 is not contained in output");
+            ok(!text.contains("page3"), "page1 is not contained in output");
           }
         },
 
         {
           setup: 'appcache viewentry --key ' + TEST_URI,
           check: {
             input:  'appcache viewentry --key ' + TEST_URI,
                   // appcache viewentry --key http://sub1.test2.example.com/browser/browser/devtools/commandline/test/browser_cmd_appcache_valid_index.html

--- a/browser/devtools/commandline/test/browser_cmd_commands.js
+++ b/browser/devtools/commandline/test/browser_cmd_commands.js
@@ -10,27 +10,16 @@ const TEST_URI = "data:text/html;charset
 let tests = {};
 
 function test() {
   helpers.addTabWithToolbar(TEST_URI, function(options) {
     return helpers.runTests(options, tests);
   }).then(finish);
 }
 
-tests.testEcho = function(options) {
-  return helpers.audit(options, [
-    {
-      setup: "echo message",
-      exec: {
-        output: "message",
-      }
-    }
-  ]);
-};
-
 tests.testConsole = function(options) {
   let deferred = Promise.defer();
   let hud = null;
 
   let onWebConsoleOpen = function(subject) {
     Services.obs.removeObserver(onWebConsoleOpen, "web-console-created");
 
     subject.QueryInterface(Ci.nsISupportsString);
@@ -62,22 +51,17 @@ tests.testConsole = function(options) {
         exec: {
           output: ""
         },
         post: function() {
           ok(!(hud.hudId in HUDService.hudReferences), "console closed");
         }
       }
     ]).then(function() {
-      // FIXME: Remove this hack once bug 842347 is fixed
-      // Gak - our promises impl causes so many stack frames that we blow up the
-      // JS engine. Jumping to a new event with a truncated stack solves this.
-      executeSoon(function() {
-        deferred.resolve();
-      });
+      deferred.resolve();
     });
   };
 
   helpers.audit(options, [
     {
       setup: "console open",
       exec: { }
     }

new file mode 100644
--- /dev/null
+++ b/browser/devtools/commandline/test/browser_cmd_cookie.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>GCLI cookie command test</title>
+</head>
+<body>
+
+  <p>Cookie test</p>
+  <p id=result></p>
+  <script type="text/javascript">
+    document.cookie = "zap=zep";
+    document.cookie = "zip=zop";
+    document.getElementById("result").innerHTML = document.cookie;
+  </script>
+
+</body>
+</html>

--- a/browser/devtools/commandline/test/browser_cmd_cookie.js
+++ b/browser/devtools/commandline/test/browser_cmd_cookie.js
@@ -1,14 +1,15 @@
 /* Any copyright is dedicated to the Public Domain.
 * http://creativecommons.org/publicdomain/zero/1.0/ */
 
 // Tests that the cookie commands works as they should
 
-const TEST_URI = "data:text/html;charset=utf-8,gcli-cookie";
+const TEST_URI = "http://example.com/browser/browser/devtools/commandline/"+
+                 "test/browser_cmd_cookie.html";
 
 function test() {
   helpers.addTabWithToolbar(TEST_URI, function(options) {
     return helpers.audit(options, [
       {
         setup: 'cookie',
         check: {
           input:  'cookie',
@@ -74,49 +75,81 @@ function test() {
             value: { value: 'ban' },
             secure: { value: false },
           }
         },
       },
       {
         setup: "cookie list",
         exec: {
-          output: 'No cookies found for host'
+          output: [ /zap=zep/, /zip=zop/, /Edit/ ]
         }
       },
       {
-        setup: "cookie set fruit banana",
+        setup: "cookie set zup banana",
         check: {
           args: {
-            name: { value: 'fruit' },
+            name: { value: 'zup' },
             value: { value: 'banana' },
           }
         },
         exec: {
           output: ""
         }
       },
       {
         setup: "cookie list",
         exec: {
-          output: [ /fruit=banana/, /Expires:/, /Edit/ ]
+          output: [ /zap=zep/, /zip=zop/, /zup=banana/, /Edit/ ]
         }
       },
       {
-        setup: "cookie remove fruit",
-        check: {
-          args: {
-            name: { value: 'fruit' },
-          }
+        setup: "cookie remove zip",
+        exec: { },
+      },
+      {
+        setup: "cookie list",
+        exec: {
+          output: [ /zap=zep/, /zup=banana/, /Edit/ ]
         },
-        exec: {
-          output: ""
+        post: function(output, text) {
+          ok(!text.contains("zip"), "");
+          ok(!text.contains("zop"), "");
         }
       },
       {
+        setup: "cookie remove zap",
+        exec: { },
+      },
+      {
         setup: "cookie list",
         exec: {
-          output: 'No cookies found for host'
+          output: [ /zup=banana/, /Edit/ ]
+        },
+        post: function(output, text) {
+          ok(!text.contains("zap"), "");
+          ok(!text.contains("zep"), "");
+          ok(!text.contains("zip"), "");
+          ok(!text.contains("zop"), "");
+        }
+      },
+      {
+        setup: "cookie remove zup",
+        exec: { }
+      },
+      {
+        setup: "cookie list",
+        exec: {
+          output: 'No cookies found for host example.com'
+        },
+        post: function(output, text) {
+          ok(!text.contains("zap"), "");
+          ok(!text.contains("zep"), "");
+          ok(!text.contains("zip"), "");
+          ok(!text.contains("zop"), "");
+          ok(!text.contains("zup"), "");
+          ok(!text.contains("banana"), "");
+          ok(!text.contains("Edit"), "");
         }
       },
     ]);
   }).then(finish);
 }

--- a/browser/devtools/commandline/test/browser_gcli_canon.js
+++ b/browser/devtools/commandline/test/browser_gcli_canon.js
@@ -33,16 +33,17 @@ function test() {
 
 // <INJECTED SOURCE:END>
 
 'use strict';
 
 // var helpers = require('gclitest/helpers');
 var canon = require('gcli/canon');
 // var assert = require('test/assert');
+var Canon = canon.Canon;
 
 var startCount = undefined;
 var events = undefined;
 
 var canonChange = function(ev) {
   events++;
 };
 
@@ -152,18 +153,16 @@ exports.testAddRemove2 = function(option
   assert.is(canon.getCommands().length,
             startCount + 1,
             'rereadd command success');
   assert.is(events, 4, 'rereadd event');
 
   return helpers.audit(options, [
     {
       setup: 'testadd',
-      check: {
-      },
       exec: {
         output: /^3$/
       },
       post: function() {
         canon.removeCommand({
           name: 'testadd'
         });
 
@@ -194,9 +193,79 @@ exports.testAddRemove3 = function(option
   assert.is(canon.getCommands().length,
             startCount,
             'nonexistant2 command success');
   assert.is(events, 5, 'nonexistant2 event');
 
   canon.onCanonChange.remove(canonChange);
 };
 
+exports.testAltCanon = function(options) {
+  var altCanon = new Canon();
+
+  var tss = {
+    name: 'tss',
+    params: [
+      { name: 'str', type: 'string' },
+      { name: 'num', type: 'number' },
+      { name: 'opt', type: { name: 'selection', data: [ '1', '2', '3' ] } },
+    ],
+    exec: function(args, context) {
+      return context.commandName + ':' +
+              args.str + ':' + args.num + ':' + args.opt;
+    }
+  };
+  altCanon.addCommand(tss);
+
+  var commandSpecs = altCanon.getCommandSpecs();
+  assert.is(JSON.stringify(commandSpecs),
+            '{"tss":{"name":"tss","params":[' +
+              '{"name":"str","type":"string"},' +
+              '{"name":"num","type":"number"},' +
+              '{"name":"opt","type":{"name":"selection","data":["1","2","3"]}}]}}',
+            'JSON.stringify(commandSpecs)');
+
+  var remoter = function(args, context) {
+    assert.is(context.commandName, 'tss', 'commandName is tss');
+
+    var cmd = altCanon.getCommand(context.commandName);
+    return cmd.exec(args, context);
+  };
+
+  canon.addProxyCommands('proxy', commandSpecs, remoter, 'test');
+
+  var parent = canon.getCommand('proxy');
+  assert.is(parent.name, 'proxy', 'Parent command called proxy');
+
+  var child = canon.getCommand('proxy tss');
+  assert.is(child.name, 'proxy tss', 'child command called proxy tss');
+
+  return helpers.audit(options, [
+    {
+      setup:    'proxy tss foo 6 3',
+      check: {
+        input:  'proxy tss foo 6 3',
+        hints:                    '',
+        markup: 'VVVVVVVVVVVVVVVVV',
+        cursor: 17,
+        status: 'VALID',
+        args: {
+          str: { value: 'foo', status: 'VALID' },
+          num: { value: 6, status: 'VALID' },
+          opt: { value: '3', status: 'VALID' }
+        }
+      },
+      exec: {
+        output: 'tss:foo:6:3'
+      },
+      post: function() {
+        canon.removeCommand('proxy');
+        canon.removeCommand('proxy tss');
+
+        assert.is(canon.getCommand('proxy'), undefined, 'remove proxy');
+        assert.is(canon.getCommand('proxy tss'), undefined, 'remove proxy tss');
+      }
+    }
+  ]);
+};
+
+
 // });

--- a/browser/devtools/commandline/test/browser_gcli_cli.js
+++ b/browser/devtools/commandline/test/browser_gcli_cli.js
@@ -753,17 +753,16 @@ exports.testSingleFloat = function(optio
       check: {
         input:  'tsf',
         hints:     ' <num>',
         markup: 'VVV',
         cursor: 3,
         current: '__command',
         status: 'ERROR',
         error: '',
-        predictions: [ ],
         unassigned: [ ],
         args: {
           command: { name: 'tsf' },
           num: {
             value: undefined,
             arg: '',
             status: 'INCOMPLETE',
             message: ''

--- a/browser/devtools/commandline/test/browser_gcli_completion.js
+++ b/browser/devtools/commandline/test/browser_gcli_completion.js
@@ -514,19 +514,19 @@ exports.testSpaceComplete = function(opt
         current: 'sel2',
         status: 'ERROR',
         tooltipState: 'true:importantFieldFlag',
         args: {
           command: { name: 'tslong' },
           msg: { status: 'INCOMPLETE', message: '' },
           num: { status: 'VALID' },
           sel: { status: 'VALID' },
-          bool: { value: false,status: 'VALID' },
+          bool: { value: false, status: 'VALID' },
           num2: { status: 'VALID' },
-          bool2: { value: false,status: 'VALID' },
+          bool2: { value: false, status: 'VALID' },
           sel2: {
             value: 'with space',
             arg: ' --sel2 \'with space\' ',
             status: 'VALID'
           }
         }
       }
     }

new file mode 100644
--- /dev/null
+++ b/browser/devtools/commandline/test/browser_gcli_context.js
@@ -0,0 +1,276 @@
+/*
+ * Copyright 2012, Mozilla Foundation and contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// define(function(require, exports, module) {
+
+// <INJECTED SOURCE:START>
+
+// THIS FILE IS GENERATED FROM SOURCE IN THE GCLI PROJECT
+// DO NOT EDIT IT DIRECTLY
+
+var exports = {};
+
+const TEST_URI = "data:text/html;charset=utf-8,<p id='gcli-input'>gcli-testContext.js</p>";
+
+function test() {
+  helpers.addTabWithToolbar(TEST_URI, function(options) {
+    return helpers.runTests(options, exports);
+  }).then(finish);
+}
+
+// <INJECTED SOURCE:END>
+
+'use strict';
+
+// var helpers = require('gclitest/helpers');
+// var mockCommands = require('gclitest/mockCommands');
+var cli = require('gcli/cli');
+
+var origLogErrors = undefined;
+
+exports.setup = function(options) {
+  mockCommands.setup();
+
+  origLogErrors = cli.logErrors;
+  cli.logErrors = false;
+};
+
+exports.shutdown = function(options) {
+  mockCommands.shutdown();
+
+  cli.logErrors = origLogErrors;
+  origLogErrors = undefined;
+};
+
+exports.testBaseline = function(options) {
+  helpers.audit(options, [
+    // These 3 establish a baseline for comparison when we have used the
+    // context command
+    {
+      setup:    'ext',
+      check: {
+        input:  'ext',
+        hints:     ' -> context',
+        markup: 'III',
+        message: '',
+        predictions: [ 'context', 'tsn ext', 'tsn exte', 'tsn exten', 'tsn extend' ],
+        unassigned: [ ],
+      }
+    },
+    {
+      setup:    'ext test',
+      check: {
+        input:  'ext test',
+        hints:          '',
+        markup: 'IIIVEEEE',
+        status: 'ERROR',
+        message: 'Too many arguments',
+        unassigned: [ ' test' ],
+      }
+    },
+    {
+      setup:    'tsn',
+      check: {
+        input:  'tsn',
+        hints:     '',
+        markup: 'III',
+        cursor: 3,
+        current: '__command',
+        status: 'ERROR',
+        predictionsContains: [ 'tsn', 'tsn deep', 'tsn ext', 'tsn exte' ],
+        args: {
+          command: { name: 'tsn' },
+        }
+      }
+    }
+  ]);
+};
+
+exports.testContext = function(options) {
+  helpers.audit(options, [
+    // Use the 'tsn' context
+    {
+      setup:    'context tsn',
+      check: {
+        input:  'context tsn',
+        hints:             '',
+        markup: 'VVVVVVVVVVV',
+        message: '',
+        predictionsContains: [ 'tsn', 'tsn deep', 'tsn ext', 'tsn exte' ],
+        args: {
+          command: { name: 'context' },
+          prefix: {
+            value: mockCommands.commands.tsn,
+            status: 'VALID',
+            message: ''
+          },
+        }
+      },
+      exec: {
+        output: 'Using tsn as a command prefix',
+        completed: true,
+      }
+    },
+    // For comparison with earlier
+    {
+      setup:    'ext',
+      check: {
+        input:  'ext',
+        hints:     ' <text>',
+        markup: 'VVV',
+        predictions: [ 'tsn ext', 'tsn exte', 'tsn exten', 'tsn extend' ],
+        args: {
+          command: { name: 'tsn ext' },
+          text: {
+            value: undefined,
+            arg: '',
+            status: 'INCOMPLETE',
+            message: ''
+          },
+        }
+      }
+    },
+    {
+      setup:    'ext test',
+      check: {
+        input:  'ext test',
+        hints:          '',
+        markup: 'VVVVVVVV',
+        args: {
+          command: { name: 'tsn ext' },
+          text: {
+            value: 'test',
+            arg: ' test',
+            status: 'VALID',
+            message: ''
+          },
+        }
+      },
+      exec: {
+        output: 'Exec: tsnExt text=test',
+        completed: true,
+      }
+    },
+    {
+      setup:    'tsn',
+      check: {
+        input:  'tsn',
+        hints:     '',
+        markup: 'III',
+        message: '',
+        predictionsContains: [ 'tsn', 'tsn deep', 'tsn ext', 'tsn exte' ],
+        args: {
+          command: { name: 'tsn' },
+        }
+      }
+    },
+    // Does it actually work?
+    {
+      setup:    'tsb true',
+      check: {
+        input:  'tsb true',
+        hints:          '',
+        markup: 'VVVVVVVV',
+        options: [ 'true' ],
+        message: '',
+        predictions: [ 'true' ],
+        unassigned: [ ],
+        args: {
+          command: { name: 'tsb' },
+          toggle: { value: true, arg: ' true', status: 'VALID', message: '' },
+        }
+      }
+    },
+    {
+      // Bug 866710 - GCLI should allow argument merging for non-string parameters
+      setup: 'context tsn ext',
+      skip: true
+    },
+    {
+      setup:    'context "tsn ext"',
+      check: {
+        input:  'context "tsn ext"',
+        hints:                   '',
+        markup: 'VVVVVVVVVVVVVVVVV',
+        message: '',
+        predictions: [ ],
+        unassigned: [ ],
+        args: {
+          command: { name: 'context' },
+          prefix: {
+            value: mockCommands.commands.tsnExt,
+            status: 'VALID',
+            message: ''
+          }
+        }
+      },
+      exec: {
+        output: 'Error: Can\'t use \'tsn ext\' as a prefix because it is not a parent command.',
+        completed: true,
+        error: true
+      }
+    },
+    /*
+    {
+      setup:    'context "tsn deep"',
+      check: {
+        input:  'context "tsn deep"',
+        hints:                    '',
+        markup: 'VVVVVVVVVVVVVVVVVV',
+        status: 'ERROR',
+        message: '',
+        predictions: [ 'tsn deep' ],
+        unassigned: [ ],
+        args: {
+          command: { name: 'context' },
+          prefix: {
+            value: mockCommands.commands.tsnDeep,
+            status: 'VALID',
+            message: ''
+          }
+        }
+      },
+      exec: {
+        output: '',
+        completed: true,
+      }
+    },
+    */
+    {
+      setup:    'context',
+      check: {
+        input:  'context',
+        hints:         ' [prefix]',
+        markup: 'VVVVVVV',
+        status: 'VALID',
+        unassigned: [ ],
+        args: {
+          command: { name: 'context' },
+          prefix: { value: undefined, arg: '', status: 'VALID', message: '' },
+        }
+      },
+      exec: {
+        output: 'Command prefix is unset',
+        completed: true,
+        type: 'string',
+        error: false
+      }
+    }
+  ]);
+};
+
+
+// });

new file mode 100644
--- /dev/null
+++ b/browser/devtools/commandline/test/browser_gcli_fail.js
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+// define(function(require, exports, module) {
+
+// <INJECTED SOURCE:START>
+
+// THIS FILE IS GENERATED FROM SOURCE IN THE GCLI PROJECT
+// DO NOT EDIT IT DIRECTLY
+
+var exports = {};
+
+const TEST_URI = "data:text/html;charset=utf-8,<p id='gcli-input'>gcli-testFail.js</p>";
+
+function test() {
+  helpers.addTabWithToolbar(TEST_URI, function(options) {
+    return helpers.runTests(options, exports);
+  }).then(finish);
+}
+
+// <INJECTED SOURCE:END>
+
+'use strict';
+
+// var helpers = require('gclitest/helpers');
+// var mockCommands = require('gclitest/mockCommands');
+var cli = require('gcli/cli');
+
+var origLogErrors = undefined;
+
+exports.setup = function(options) {
+  mockCommands.setup();
+
+  origLogErrors = cli.logErrors;
+  cli.logErrors = false;
+};
+
+exports.shutdown = function(options) {
+  mockCommands.shutdown();
+
+  cli.logErrors = origLogErrors;
+  origLogErrors = undefined;
+};
+
+exports.testBasic = function(options) {
+  return helpers.audit(options, [
+    {
+      setup: 'tsfail reject',
+      exec: {
+        completed: false,
+        output: 'rejected promise',
+        type: 'error',
+        error: true
+      }
+    },
+    {
+      setup: 'tsfail rejecttyped',
+      exec: {
+        completed: false,
+        output: '54',
+        type: 'number',
+        error: true
+      }
+    },
+    {
+      setup: 'tsfail throwerror',
+      exec: {
+        completed: true,
+        output: 'Error: thrown error',
+        type: 'error',
+        error: true
+      }
+    },
+    {
+      setup: 'tsfail throwstring',
+      exec: {
+        completed: true,
+        output: 'thrown string',
+        type: 'error',
+        error: true
+      }
+    },
+    {
+      setup: 'tsfail noerror',
+      exec: {
+        completed: true,
+        output: 'no error',
+        type: 'string',
+        error: false
+      }
+    }
+  ]);
+};
+
+
+// });

--- a/browser/devtools/commandline/test/browser_gcli_inputter.js
+++ b/browser/devtools/commandline/test/browser_gcli_inputter.js
@@ -35,48 +35,40 @@ function test() {
 
 'use strict';
 
 var KeyEvent = require('util/util').KeyEvent;
 // var assert = require('test/assert');
 // var mockCommands = require('gclitest/mockCommands');
 
 var latestEvent = undefined;
-var latestOutput = undefined;
 var latestData = undefined;
 
 var outputted = function(ev) {
-  function updateData() {
-    latestData = latestOutput.data;
-  }
+  latestEvent = ev;
 
-  if (latestOutput != null) {
-    ev.output.onChange.remove(updateData);
-  }
-
-  latestEvent = ev;
-  latestOutput = ev.output;
-
-  ev.output.onChange.add(updateData);
+  ev.output.promise.then(function() {
+    latestData = ev.output.data;
+    ev.output.onClose();
+  });
 };
 
 
 exports.setup = function(options) {
   mockCommands.setup();
   options.display.requisition.commandOutputManager.onOutput.add(outputted);
 };
 
 exports.shutdown = function(options) {
   mockCommands.shutdown();
   options.display.requisition.commandOutputManager.onOutput.remove(outputted);
 };
 
 exports.testOutput = function(options) {
   latestEvent = undefined;
-  latestOutput = undefined;
   latestData = undefined;
 
   var inputter = options.display.inputter;
   var focusManager = options.display.focusManager;
 
   inputter.setInput('tss');
 
   var ev0 = { keyCode: KeyEvent.DOM_VK_RETURN };
@@ -98,18 +90,16 @@ exports.testOutput = function(options) {
     var ev2 = { keyCode: KeyEvent.DOM_VK_F1 };
     return inputter.handleKeyUp(ev2).then(function() {
       assert.ok(!focusManager._recentOutput, 'no recent output happened post F1');
       assert.ok(focusManager._helpRequested, 'F1 = help');
 
       var ev3 = { keyCode: KeyEvent.DOM_VK_ESCAPE };
       return inputter.handleKeyUp(ev3).then(function() {
         assert.ok(!focusManager._helpRequested, 'ESCAPE = anti help');
-
-        latestOutput.onClose();
       });
     });
 
   });
 };
 
 
 // });

--- a/browser/devtools/commandline/test/browser_gcli_resource.js
+++ b/browser/devtools/commandline/test/browser_gcli_resource.js
@@ -56,87 +56,87 @@ exports.shutdown = function(options) {
 };
 
 exports.testAllPredictions1 = function(options) {
   if (options.isFirefox || options.isJsdom) {
     assert.log('Skipping checks due to jsdom/firefox document.stylsheets support.');
     return;
   }
 
-  var resource = types.getType('resource');
+  var resource = types.createType('resource');
   return resource.getLookup().then(function(opts) {
     assert.ok(opts.length > 1, 'have all resources');
 
     return util.promiseEach(opts, function(prediction) {
       return checkPrediction(resource, prediction);
     });
   });
 };
 
 exports.testScriptPredictions = function(options) {
   if (options.isFirefox || options.isJsdom) {
     assert.log('Skipping checks due to jsdom/firefox document.stylsheets support.');
     return;
   }
 
-  var resource = types.getType({ name: 'resource', include: 'text/javascript' });
+  var resource = types.createType({ name: 'resource', include: 'text/javascript' });
   return resource.getLookup().then(function(opts) {
     assert.ok(opts.length > 1, 'have js resources');
 
     return util.promiseEach(opts, function(prediction) {
       return checkPrediction(resource, prediction);
     });
   });
 };
 
 exports.testStylePredictions = function(options) {
   if (options.isFirefox || options.isJsdom) {
     assert.log('Skipping checks due to jsdom/firefox document.stylsheets support.');
     return;
   }
 
-  var resource = types.getType({ name: 'resource', include: 'text/css' });
+  var resource = types.createType({ name: 'resource', include: 'text/css' });
   return resource.getLookup().then(function(opts) {
     assert.ok(opts.length >= 1, 'have css resources');
 
     return util.promiseEach(opts, function(prediction) {
       return checkPrediction(resource, prediction);
     });
   });
 };
 
 exports.testAllPredictions2 = function(options) {
   if (options.isJsdom) {
     assert.log('Skipping checks due to jsdom document.stylsheets support.');
     return;
   }
 
-  var scriptRes = types.getType({ name: 'resource', include: 'text/javascript' });
+  var scriptRes = types.createType({ name: 'resource', include: 'text/javascript' });
   return scriptRes.getLookup().then(function(scriptOptions) {
-    var styleRes = types.getType({ name: 'resource', include: 'text/css' });
+    var styleRes = types.createType({ name: 'resource', include: 'text/css' });
     return styleRes.getLookup().then(function(styleOptions) {
-      var allRes = types.getType({ name: 'resource' });
+      var allRes = types.createType({ name: 'resource' });
       return allRes.getLookup().then(function(allOptions) {
         assert.is(scriptOptions.length + styleOptions.length,
                   allOptions.length,
                   'split');
       });
     });
   });
 };
 
 exports.testAllPredictions3 = function(options) {
   if (options.isJsdom) {
     assert.log('Skipping checks due to jsdom document.stylsheets support.');
     return;
   }
 
-  var res1 = types.getType({ name: 'resource' });
+  var res1 = types.createType({ name: 'resource' });
   return res1.getLookup().then(function(options1) {
-    var res2 = types.getType('resource');
+    var res2 = types.createType('resource');
     return res2.getLookup().then(function(options2) {
       assert.is(options1.length, options2.length, 'type spec');
     });
   });
 };
 
 function checkPrediction(res, prediction) {
   var name = prediction.name;

--- a/browser/devtools/commandline/test/browser_gcli_split.js
+++ b/browser/devtools/commandline/test/browser_gcli_split.js
@@ -31,68 +31,69 @@ function test() {
   }).then(finish);
 }
 
 // <INJECTED SOURCE:END>
 
 'use strict';
 
 // var assert = require('test/assert');
+var cli = require('gcli/cli');
 var Requisition = require('gcli/cli').Requisition;
 var canon = require('gcli/canon');
 // var mockCommands = require('gclitest/mockCommands');
 
 exports.setup = function(options) {
   mockCommands.setup();
 };
 
 exports.shutdown = function(options) {
   mockCommands.shutdown();
 };
 
 
 exports.testSplitSimple = function(options) {
   var args;
-  var requ = new Requisition();
+  var requisition = new Requisition();
 
-  args = requ._tokenize('s');
-  requ._split(args);
+  args = cli.tokenize('s');
+  requisition._split(args);
   assert.is(0, args.length);
-  assert.is('s', requ.commandAssignment.arg.text);
+  assert.is('s', requisition.commandAssignment.arg.text);
 };
 
 exports.testFlatCommand = function(options) {
   var args;
-  var requ = new Requisition();
+  var requisition = new Requisition();
 
-  args = requ._tokenize('tsv');
-  requ._split(args);
+  args = cli.tokenize('tsv');
+  requisition._split(args);
   assert.is(0, args.length);
-  assert.is('tsv', requ.commandAssignment.value.name);
+  assert.is('tsv', requisition.commandAssignment.value.name);
 
-  args = requ._tokenize('tsv a b');
-  requ._split(args);
-  assert.is('tsv', requ.commandAssignment.value.name);
+  args = cli.tokenize('tsv a b');
+  requisition._split(args);
+  assert.is('tsv', requisition.commandAssignment.value.name);
   assert.is(2, args.length);
   assert.is('a', args[0].text);
   assert.is('b', args[1].text);
 };
 
 exports.testJavascript = function(options) {
   if (!canon.getCommand('{')) {
     assert.log('Skipping testJavascript because { is not registered');
     return;
   }
 
   var args;
-  var requ = new Requisition();
+  var requisition = new Requisition();
 
-  args = requ._tokenize('{');
-  requ._split(args);
+  args = cli.tokenize('{');
+  requisition._split(args);
   assert.is(1, args.length);
   assert.is('', args[0].text);
-  assert.is('', requ.commandAssignment.arg.text);
-  assert.is('{', requ.commandAssignment.value.name);
+  assert.is('', requisition.commandAssignment.arg.text);
+  assert.is('{', requisition.commandAssignment.value.name);
 };
 
 // BUG 663081 - add tests for sub commands
 
 // });

--- a/browser/devtools/commandline/test/browser_gcli_tokenize.js
+++ b/browser/devtools/commandline/test/browser_gcli_tokenize.js
@@ -31,172 +31,167 @@ function test() {
   }).then(finish);
 }
 
 // <INJECTED SOURCE:END>
 
 'use strict';
 
 // var assert = require('test/assert');
-var Requisition = require('gcli/cli').Requisition;
+var cli = require('gcli/cli');
 
 exports.testBlanks = function(options) {
   var args;
-  var requ = new Requisition();
 
-  args = requ._tokenize('');
+  args = cli.tokenize('');
   assert.is(1, args.length);
   assert.is('', args[0].text);
   assert.is('', args[0].prefix);
   assert.is('', args[0].suffix);
 
-  args = requ._tokenize(' ');
+  args = cli.tokenize(' ');
   assert.is(1, args.length);
   assert.is('', args[0].text);
   assert.is(' ', args[0].prefix);
   assert.is('', args[0].suffix);
 };
 
 exports.testTokSimple = function(options) {
   var args;
-  var requ = new Requisition();
 
-  args = requ._tokenize('s');
+  args = cli.tokenize('s');
   assert.is(1, args.length);
   assert.is('s', args[0].text);
   assert.is('', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('Argument', args[0].type);
 
-  args = requ._tokenize('s s');
+  args = cli.tokenize('s s');
   assert.is(2, args.length);
   assert.is('s', args[0].text);
   assert.is('', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('Argument', args[0].type);
   assert.is('s', args[1].text);
   assert.is(' ', args[1].prefix);
   assert.is('', args[1].suffix);
   assert.is('Argument', args[1].type);
 };
 
 exports.testJavascript = function(options) {
   var args;
-  var requ = new Requisition();
 
-  args = requ._tokenize('{x}');
+  args = cli.tokenize('{x}');
   assert.is(1, args.length);
   assert.is('x', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('{ x }');
+  args = cli.tokenize('{ x }');
   assert.is(1, args.length);
   assert.is('x', args[0].text);
   assert.is('{ ', args[0].prefix);
   assert.is(' }', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('{x} {y}');
+  args = cli.tokenize('{x} {y}');
   assert.is(2, args.length);
   assert.is('x', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
   assert.is('y', args[1].text);
   assert.is(' {', args[1].prefix);
   assert.is('}', args[1].suffix);
   assert.is('ScriptArgument', args[1].type);
 
-  args = requ._tokenize('{x}{y}');
+  args = cli.tokenize('{x}{y}');
   assert.is(2, args.length);
   assert.is('x', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
   assert.is('y', args[1].text);
   assert.is('{', args[1].prefix);
   assert.is('}', args[1].suffix);
   assert.is('ScriptArgument', args[1].type);
 
-  args = requ._tokenize('{');
+  args = cli.tokenize('{');
   assert.is(1, args.length);
   assert.is('', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('{ ');
+  args = cli.tokenize('{ ');
   assert.is(1, args.length);
   assert.is('', args[0].text);
   assert.is('{ ', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('{x');
+  args = cli.tokenize('{x');
   assert.is(1, args.length);
   assert.is('x', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 };
 
 exports.testRegularNesting = function(options) {
   var args;
-  var requ = new Requisition();
 
-  args = requ._tokenize('{"x"}');
+  args = cli.tokenize('{"x"}');
   assert.is(1, args.length);
   assert.is('"x"', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('{\'x\'}');
+  args = cli.tokenize('{\'x\'}');
   assert.is(1, args.length);
   assert.is('\'x\'', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('"{x}"');
+  args = cli.tokenize('"{x}"');
   assert.is(1, args.length);
   assert.is('{x}', args[0].text);
   assert.is('"', args[0].prefix);
   assert.is('"', args[0].suffix);
   assert.is('Argument', args[0].type);
 
-  args = requ._tokenize('\'{x}\'');
+  args = cli.tokenize('\'{x}\'');
   assert.is(1, args.length);
   assert.is('{x}', args[0].text);
   assert.is('\'', args[0].prefix);
   assert.is('\'', args[0].suffix);
   assert.is('Argument', args[0].type);
 };
 
 exports.testDeepNesting = function(options) {
   var args;
-  var requ = new Requisition();
 
-  args = requ._tokenize('{{}}');
+  args = cli.tokenize('{{}}');
   assert.is(1, args.length);
   assert.is('{}', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('{{x} {y}}');
+  args = cli.tokenize('{{x} {y}}');
   assert.is(1, args.length);
   assert.is('{x} {y}', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
-  args = requ._tokenize('{{w} {{{x}}}} {y} {{{z}}}');
+  args = cli.tokenize('{{w} {{{x}}}} {y} {{{z}}}');
 
   assert.is(3, args.length);
 
   assert.is('{w} {{{x}}}', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
@@ -205,65 +200,63 @@ exports.testDeepNesting = function(optio
   assert.is('}', args[1].suffix);
   assert.is('ScriptArgument', args[1].type);
 
   assert.is('{{z}}', args[2].text);
   assert.is(' {', args[2].prefix);
   assert.is('}', args[2].suffix);
   assert.is('ScriptArgument', args[2].type);
 
-  args = requ._tokenize('{{w} {{{x}}} {y} {{{z}}}');
+  args = cli.tokenize('{{w} {{{x}}} {y} {{{z}}}');
 
   assert.is(1, args.length);
 
   assert.is('{w} {{{x}}} {y} {{{z}}}', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 };
 
 exports.testStrangeNesting = function(options) {
   var args;
-  var requ = new Requisition();
 
   // Note: When we get real JS parsing this should break
-  args = requ._tokenize('{"x}"}');
+  args = cli.tokenize('{"x}"}');
 
   assert.is(2, args.length);
 
   assert.is('"x', args[0].text);
   assert.is('{', args[0].prefix);
   assert.is('}', args[0].suffix);
   assert.is('ScriptArgument', args[0].type);
 
   assert.is('}', args[1].text);
   assert.is('"', args[1].prefix);
   assert.is('', args[1].suffix);
   assert.is('Argument', args[1].type);
 };
 
 exports.testComplex = function(options) {
   var args;
-  var requ = new Requisition();
 
-  args = requ._tokenize(' 1234  \'12 34\'');
+  args = cli.tokenize(' 1234  \'12 34\'');
 
   assert.is(2, args.length);
 
   assert.is('1234', args[0].text);
   assert.is(' ', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('Argument', args[0].type);
 
   assert.is('12 34', args[1].text);
   assert.is('  \'', args[1].prefix);
   assert.is('\'', args[1].suffix);
   assert.is('Argument', args[1].type);
 
-  args = requ._tokenize('12\'34 "12 34" \\'); // 12'34 "12 34" \
+  args = cli.tokenize('12\'34 "12 34" \\'); // 12'34 "12 34" \
 
   assert.is(3, args.length);
 
   assert.is('12\'34', args[0].text);
   assert.is('', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('Argument', args[0].type);
 
@@ -275,19 +268,18 @@ exports.testComplex = function(options) 
   assert.is('\\', args[2].text);
   assert.is(' ', args[2].prefix);
   assert.is('', args[2].suffix);
   assert.is('Argument', args[2].type);
 };
 
 exports.testPathological = function(options) {
   var args;
-  var requ = new Requisition();
 
-  args = requ._tokenize('a\\ b \\t\\n\\r \\\'x\\\" \'d'); // a_b \t\n\r \'x\" 'd
+  args = cli.tokenize('a\\ b \\t\\n\\r \\\'x\\\" \'d'); // a_b \t\n\r \'x\" 'd
 
   assert.is(4, args.length);
 
   assert.is('a b', args[0].text);
   assert.is('', args[0].prefix);
   assert.is('', args[0].suffix);
   assert.is('Argument', args[0].type);
 

--- a/browser/devtools/commandline/test/browser_gcli_types.js
+++ b/browser/devtools/commandline/test/browser_gcli_types.js
@@ -44,25 +44,32 @@ function forEachType(options, typeSpec, 
     typeSpec.requisition = options.display.requisition;
 
     // Provide some basic defaults to help selection/delegate/array work
     if (name === 'selection') {
       typeSpec.data = [ 'a', 'b' ];
     }
     else if (name === 'delegate') {
       typeSpec.delegateType = function() {
-        return types.getType('string');
+        return types.createType('string');
       };
     }
     else if (name === 'array') {
       typeSpec.subtype = 'string';
     }
 
-    var type = types.getType(typeSpec);
+    var type = types.createType(typeSpec);
     callback(type);
+
+    // Clean up
+    delete typeSpec.name;
+    delete typeSpec.requisition;
+    delete typeSpec.data;
+    delete typeSpec.delegateType;
+    delete typeSpec.subtype;
   });
 }
 
 exports.testDefault = function(options) {
   if (options.isJsdom) {
     assert.log('Skipping tests due to issues with resource type.');
     return;
   }

--- a/browser/devtools/commandline/test/helpers.js
+++ b/browser/devtools/commandline/test/helpers.js
@@ -16,21 +16,20 @@
 //   };
 // Now GCLI will emit output on every keypress that both explains the state
 // of GCLI and can be run as a test case.
 
 this.EXPORTED_SYMBOLS = [ 'helpers' ];
 var helpers = {};
 this.helpers = helpers;
 let require = (Cu.import("resource://gre/modules/devtools/Require.jsm", {})).require;
-Components.utils.import("resource:///modules/devtools/gcli.jsm", {});
+Components.utils.import("resource://gre/modules/devtools/gcli.jsm", {});
 
 let console = (Cu.import("resource://gre/modules/devtools/Console.jsm", {})).console;
-let devtools = (Cu.import("resource:///modules/devtools/gDevTools.jsm", {})).devtools;
-let TargetFactory = devtools.TargetFactory;
+let TargetFactory = (Cu.import("resource:///modules/devtools/gDevTools.jsm", {})).devtools.TargetFactory;
 
 let Promise = (Cu.import("resource://gre/modules/commonjs/sdk/core/promise.js", {})).Promise;
 let assert = { ok: ok, is: is, log: info };
 
 var util = require('util/util');
 
 var converters = require('gcli/converters');
 
@@ -153,16 +152,17 @@ helpers.addTabWithToolbar = function(url
  * their return values resolved
  */
 helpers.runTests = function(options, tests) {
   var testNames = Object.keys(tests).filter(function(test) {
     return test != "setup" && test != "shutdown";
   });
 
   var recover = function(error) {
+    ok(false, error);
     console.error(error);
   };
 
   info("SETUP");
   var setupDone = (tests.setup != null) ?
       Promise.resolve(tests.setup(options)) :
       Promise.resolve();
 
@@ -336,17 +336,17 @@ helpers._createDebugCheck = function(opt
 
     output += '      input:  \'' + input + '\',\n';
     output += '      hints:  ' + padding + '\'' + hints + '\',\n';
     output += '      markup: \'' + helpers._actual.markup(options) + '\',\n';
     output += '      cursor: ' + cursor + ',\n';
     output += '      current: \'' + helpers._actual.current(options) + '\',\n';
     output += '      status: \'' + helpers._actual.status(options) + '\',\n';
     output += '      options: ' + outputArray(helpers._actual.options(options)) + ',\n';
-    output += '      error: \'' + helpers._actual.message(options) + '\',\n';
+    output += '      message: \'' + helpers._actual.message(options) + '\',\n';
     output += '      predictions: ' + outputArray(predictions) + ',\n';
     output += '      unassigned: ' + outputArray(requisition._unassigned) + ',\n';
     output += '      outputState: \'' + helpers._actual.outputState(options) + '\',\n';
     output += '      tooltipState: \'' + helpers._actual.tooltipState(options) + '\'' +
               (command ? ',' : '') +'\n';
 
     if (command) {
       output += '      args: {\n';
@@ -373,16 +373,18 @@ helpers._createDebugCheck = function(opt
 
       output += '      }\n';
     }
 
     output += '    },\n';
     output += '    exec: {\n';
     output += '      output: \'\',\n';
     output += '      completed: true,\n';
+    output += '      type: \'string\',\n';
+    output += '      error: false\n';
     output += '    }\n';
     output += '  }\n';
     output += ']);';
 
     return output;
   }.bind(this), util.errorHandler);
 };
 
@@ -697,43 +699,55 @@ helpers._check = function(options, name,
  * Helper for helpers.audit() to ensure that all the 'exec' properties work.
  * See helpers.audit for more information.
  * @param name The name to use in error messages
  * @param expected See helpers.audit for a list of available exec checks
  * @return A promise which resolves to undefined when the checks are complete
  */
 helpers._exec = function(options, name, expected) {
   if (expected == null) {
-    return Promise.resolve();
+    return Promise.resolve({});
   }
 
   var output = options.display.requisition.exec({ hidden: true });
 
   if ('completed' in expected) {
     assert.is(output.completed,
               expected.completed,
               'output.completed false for: ' + name);
   }
 
   if (!options.window.document.createElement) {
     assert.log('skipping output tests (missing doc.createElement) for ' + name);
-    return Promise.resolve();
+    return Promise.resolve({ output: output });
   }
 
   if (!('output' in expected)) {
-    return Promise.resolve();
+    return Promise.resolve({ output: output });
   }
 
-  var deferred = Promise.defer();
-
   var checkOutput = function() {
     var div = options.window.document.createElement('div');
-    var nodePromise = converters.convert(output.data, output.type, 'dom',
-                                         options.display.requisition.context);
-    nodePromise.then(function(node) {
+    var conversionContext = options.display.requisition.conversionContext;
+
+    if ('type' in expected) {
+      assert.is(output.type,
+                expected.type,
+                'output.type for: ' + name);
+    }
+
+    if ('error' in expected) {
+      assert.is(output.error,
+                expected.error,
+                'output.error for: ' + name);
+    }
+
+    var convertPromise = converters.convert(output.data, output.type, 'dom',
+                                            conversionContext);
+    return convertPromise.then(function(node) {
       div.appendChild(node);
       var actualOutput = div.textContent.trim();
 
       var doTest = function(match, against) {
         if (match.test(against)) {
           assert.ok(true, 'html output for ' + name + ' should match ' +
                           match.source);
         } else {
@@ -752,57 +766,44 @@ helpers._exec = function(options, name, 
         expected.output.forEach(function(match) {
           doTest(match, actualOutput);
         });
       }
       else {
         doTest(expected.output, actualOutput);
       }
 
-      deferred.resolve(actualOutput);
+      return { output: output, text: actualOutput };
     });
   };
 
-  if (output.completed !== false) {
-    checkOutput();
-  }
-  else {
-    var changed = function() {
-      if (output.completed !== false) {
-        checkOutput();
-        output.onChange.remove(changed);
-      }
-    };
-    output.onChange.add(changed);
-  }
-
-  return deferred.promise;
+  return output.promise.then(checkOutput, checkOutput);
 };
 
 /**
  * Helper to setup the test
  */
 helpers._setup = function(options, name, action) {
   if (typeof action === 'string') {
     return helpers.setInput(options, action);
   }
 
   if (typeof action === 'function') {
     return Promise.resolve(action());
   }
 
-  return Promise.reject('setup must be a string or a function');
+  return Promise.reject('\'setup\' property must be a string or a function. Is ' + action);
 };
 
 /**
  * Helper to shutdown the test
  */
-helpers._post = function(name, action, output) {
+helpers._post = function(name, action, data) {
   if (typeof action === 'function') {
-    return Promise.resolve(action(output));
+    return Promise.resolve(action(data.output, data.text));
   }
   return Promise.resolve(action);
 };
 
 /*
  * We do some basic response time stats so we can see if we're getting slow
  */
 var totalResponseTime = 0;
@@ -938,39 +939,41 @@ helpers.audit = function(options, audits
     var start = new Date().getTime();
 
     var setupDone = helpers._setup(options, name, audit.setup);
     return setupDone.then(function(chunkLen) {
 
       if (typeof chunkLen !== 'number') {
         chunkLen = 1;
       }
-      var responseTime = (new Date().getTime() - start) / chunkLen;
-      totalResponseTime += responseTime;
-      if (responseTime > maxResponseTime) {
-        maxResponseTime = responseTime;
-        maxResponseCulprit = assert.currentTest + '/' + name;
+
+      if (assert.currentTest) {
+        var responseTime = (new Date().getTime() - start) / chunkLen;
+        totalResponseTime += responseTime;
+        if (responseTime > maxResponseTime) {
+          maxResponseTime = responseTime;
+          maxResponseCulprit = assert.currentTest + '/' + name;
+        }
+        averageOver++;
       }
-      averageOver++;
 
       var checkDone = helpers._check(options, name, audit.check);
       return checkDone.then(function() {
         var execDone = helpers._exec(options, name, audit.exec);
-        return execDone.then(function(output) {
-          return helpers._post(name, audit.post, output).then(function() {
+        return execDone.then(function(data) {
+          return helpers._post(name, audit.post, data).then(function() {
             if (assert.testLogging) {
               log('- END \'' + name + '\' in ' + assert.currentTest);
             }
           });
         });
       });
     });
-  }).then(null, function(ex) {
-    console.error(ex.stack);
-    throw(ex);
+  }).then(function() {
+    return options.display.inputter.setInput('');
   });
 };
 
 /**
  * Compare 2 arrays.
  */
 helpers._arrayIs = function(actual, expected, message) {
   assert.ok(Array.isArray(actual), 'actual is not an array: ' + message);

--- a/browser/devtools/commandline/test/mockCommands.js
+++ b/browser/devtools/commandline/test/mockCommands.js
@@ -18,270 +18,193 @@
 
 // <INJECTED SOURCE:START>
 
 // THIS FILE IS GENERATED FROM SOURCE IN THE GCLI PROJECT
 // DO NOT EDIT IT DIRECTLY
 
 const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 let { require: require, define: define } = Cu.import("resource://gre/modules/devtools/Require.jsm", {});
-Cu.import("resource:///modules/devtools/gcli.jsm", {});
+Cu.import("resource://gre/modules/devtools/gcli.jsm", {});
 
 // <INJECTED SOURCE:END>
 
 var mockCommands = {};
 
+// We use an alias for exports here because this module is used in Firefox
+// mochitests where we don't have define/require
+
+'use strict';
+
 var util = require('util/util');
 var canon = require('gcli/canon');
-
 var types = require('gcli/types');
-var SelectionType = require('gcli/types/selection').SelectionType;
-var DelegateType = require('gcli/types/basic').DelegateType;
-
-
-/**
- * Registration and de-registration.
- */
-mockCommands.setup = function(opts) {
-  // setup/shutdown needs to register/unregister types, however that means we
-  // need to re-initialize mockCommands.option1 and mockCommands.option2 with
-  // the actual types
-  mockCommands.option1.type = types.getType('string');
-  mockCommands.option2.type = types.getType('number');
-
-  types.registerType(mockCommands.optionType);
-  types.registerType(mockCommands.optionValue);
-
-  canon.addCommand(mockCommands.tsv);
-  canon.addCommand(mockCommands.tsr);
-  canon.addCommand(mockCommands.tso);
-  canon.addCommand(mockCommands.tse);
-  canon.addCommand(mockCommands.tsj);
-  canon.addCommand(mockCommands.tsb);
-  canon.addCommand(mockCommands.tss);
-  canon.addCommand(mockCommands.tsu);
-  canon.addCommand(mockCommands.tsf);
-  canon.addCommand(mockCommands.tsn);
-  canon.addCommand(mockCommands.tsnDif);
-  canon.addCommand(mockCommands.tsnExt);
-  canon.addCommand(mockCommands.tsnExte);
-  canon.addCommand(mockCommands.tsnExten);
-  canon.addCommand(mockCommands.tsnExtend);
-  canon.addCommand(mockCommands.tsnDeep);
-  canon.addCommand(mockCommands.tsnDeepDown);
-  canon.addCommand(mockCommands.tsnDeepDownNested);
-  canon.addCommand(mockCommands.tsnDeepDownNestedCmd);
-  canon.addCommand(mockCommands.tselarr);
-  canon.addCommand(mockCommands.tsm);
-  canon.addCommand(mockCommands.tsg);
-  canon.addCommand(mockCommands.tshidden);
-  canon.addCommand(mockCommands.tscook);
-  canon.addCommand(mockCommands.tslong);
-};
 
-mockCommands.shutdown = function(opts) {
-  canon.removeCommand(mockCommands.tsv);
-  canon.removeCommand(mockCommands.tsr);
-  canon.removeCommand(mockCommands.tso);
-  canon.removeCommand(mockCommands.tse);
-  canon.removeCommand(mockCommands.tsj);
-  canon.removeCommand(mockCommands.tsb);
-  canon.removeCommand(mockCommands.tss);
-  canon.removeCommand(mockCommands.tsu);
-  canon.removeCommand(mockCommands.tsf);
-  canon.removeCommand(mockCommands.tsn);
-  canon.removeCommand(mockCommands.tsnDif);
-  canon.removeCommand(mockCommands.tsnExt);
-  canon.removeCommand(mockCommands.tsnExte);
-  canon.removeCommand(mockCommands.tsnExten);
-  canon.removeCommand(mockCommands.tsnExtend);
-  canon.removeCommand(mockCommands.tsnDeep);
-  canon.removeCommand(mockCommands.tsnDeepDown);
-  canon.removeCommand(mockCommands.tsnDeepDownNested);
-  canon.removeCommand(mockCommands.tsnDeepDownNestedCmd);
-  canon.removeCommand(mockCommands.tselarr);
-  canon.removeCommand(mockCommands.tsm);
-  canon.removeCommand(mockCommands.tsg);
-  canon.removeCommand(mockCommands.tshidden);
-  canon.removeCommand(mockCommands.tscook);
-  canon.removeCommand(mockCommands.tslong);
+mockCommands.option1 = { };
+mockCommands.option2 = { };
+mockCommands.option3 = { };
 
-  types.deregisterType(mockCommands.optionType);
-  types.deregisterType(mockCommands.optionValue);
-};
-
-
-mockCommands.option1 = { type: types.getType('string') };
-mockCommands.option2 = { type: types.getType('number') };
-mockCommands.option3 = { type: types.getType({
-  name: 'selection',
-  lookup: [
-    { name: 'one', value: 1 },
-    { name: 'two', value: 2 },
-    { name: 'three', value: 3 }
-  ]
-})};
-
-mockCommands.optionType = new SelectionType({
+mockCommands.optionType = {
   name: 'optionType',
+  parent: 'selection',
   lookup: [
     { name: 'option1', value: mockCommands.option1 },
     { name: 'option2', value: mockCommands.option2 },
     { name: 'option3', value: mockCommands.option3 }
   ]
-});
+};
 
-mockCommands.optionValue = new DelegateType({
+mockCommands.optionValue = {
   name: 'optionValue',
-  delegateType: function(context) {
-    if (context != null) {
-      var option = context.getArgsObject().optionType;
+  parent: 'delegate',
+  delegateType: function(executionContext) {
+    if (executionContext != null) {
+      var option = executionContext.getArgsObject().optionType;
       if (option != null) {
         return option.type;
       }
     }
-    return types.getType('blank');
+    return types.createType('blank');
   }
-});
+};
 
 mockCommands.onCommandExec = util.createEvent('commands.onCommandExec');
 
 function createExec(name) {
-  return function(args, context) {
+  return function(args, executionContext) {
     var data = {
-      command: mockCommands[name],
       args: args,
-      context: context
+      context: executionContext
     };
     mockCommands.onCommandExec(data);
     var argsOut = Object.keys(args).map(function(key) {
       return key + '=' + args[key];
     }).join(', ');
     return 'Exec: ' + name + ' ' + argsOut;
   };
 }
 
-mockCommands.tsv = {
+var tsv = {
   name: 'tsv',
   params: [
     { name: 'optionType', type: 'optionType' },
     { name: 'optionValue', type: 'optionValue' }
   ],
   exec: createExec('tsv')
 };
 
-mockCommands.tsr = {
+var tsr = {
   name: 'tsr',
   params: [ { name: 'text', type: 'string' } ],
   exec: createExec('tsr')
 };
 
-mockCommands.tso = {
+var tso = {
   name: 'tso',
   params: [ { name: 'text', type: 'string', defaultValue: null } ],
   exec: createExec('tso')
 };
 
-mockCommands.tse = {
+var tse = {
   name: 'tse',
   params: [
     { name: 'node', type: 'node' },
     {
       group: 'options',
       params: [
         { name: 'nodes', type: { name: 'nodelist' } },
         { name: 'nodes2', type: { name: 'nodelist', allowEmpty: true } }
       ]
     }
   ],
   exec: createExec('tse')
 };
 
-mockCommands.tsj = {
+var tsj = {
   name: 'tsj',
   params: [ { name: 'javascript', type: 'javascript' } ],
   exec: createExec('tsj')
 };
 
-mockCommands.tsb = {
+var tsb = {
   name: 'tsb',
   params: [ { name: 'toggle', type: 'boolean' } ],
   exec: createExec('tsb')
 };
 
-mockCommands.tss = {
+var tss = {
   name: 'tss',
   exec: createExec('tss')
 };
 
-mockCommands.tsu = {
+var tsu = {
   name: 'tsu',
   params: [ { name: 'num', type: { name: 'number', max: 10, min: -5, step: 3 } } ],
   exec: createExec('tsu')
 };
 
-mockCommands.tsf = {
+var tsf = {
   name: 'tsf',
   params: [ { name: 'num', type: { name: 'number', allowFloat: true, max: 11.5, min: -6.5, step: 1.5 } } ],
   exec: createExec('tsf')
 };
 
-mockCommands.tsn = {
+var tsn = {
   name: 'tsn'
 };
 
-mockCommands.tsnDif = {
+var tsnDif = {
   name: 'tsn dif',
   description: 'tsn dif',
   params: [ { name: 'text', type: 'string', description: 'tsn dif text' } ],
   exec: createExec('tsnDif')
 };
 
-mockCommands.tsnExt = {
+var tsnExt = {
   name: 'tsn ext',
   params: [ { name: 'text', type: 'string' } ],
   exec: createExec('tsnExt')
 };
 
-mockCommands.tsnExte = {
+var tsnExte = {
   name: 'tsn exte',
   params: [ { name: 'text', type: 'string' } ],
   exec: createExec('tsnExte')
 };
 
-mockCommands.tsnExten = {
+var tsnExten = {
   name: 'tsn exten',
   params: [ { name: 'text', type: 'string' } ],
   exec: createExec('tsnExten')
 };
 
-mockCommands.tsnExtend = {
+var tsnExtend = {
   name: 'tsn extend',
   params: [ { name: 'text', type: 'string' } ],
   exec: createExec('tsnExtend')
 };
 
-mockCommands.tsnDeep = {
+var tsnDeep = {
   name: 'tsn deep'
 };
 
-mockCommands.tsnDeepDown = {
+var tsnDeepDown = {
   name: 'tsn deep down'
 };
 
-mockCommands.tsnDeepDownNested = {
+var tsnDeepDownNested = {
   name: 'tsn deep down nested'
 };
 
-mockCommands.tsnDeepDownNestedCmd = {
+var tsnDeepDownNestedCmd = {
   name: 'tsn deep down nested cmd',
   exec: createExec('tsnDeepDownNestedCmd')
 };
 
-mockCommands.tshidden = {
+var tshidden = {
   name: 'tshidden',
   hidden: true,
   params: [
     {
       group: 'Options',
       params: [
         {
           name: 'visible',
@@ -303,37 +226,37 @@ mockCommands.tshidden = {
           hidden: true
         }
       ]
     }
   ],
   exec: createExec('tshidden')
 };
 
-mockCommands.tselarr = {
+var tselarr = {
   name: 'tselarr',
   params: [
     { name: 'num', type: { name: 'selection', data: [ '1', '2', '3' ] } },
     { name: 'arr', type: { name: 'array', subtype: 'string' } }
   ],
   exec: createExec('tselarr')
 };
 
-mockCommands.tsm = {
+var tsm = {
   name: 'tsm',
   description: 'a 3-param test selection|string|number',
   params: [
     { name: 'abc', type: { name: 'selection', data: [ 'a', 'b', 'c' ] } },
     { name: 'txt', type: 'string' },
     { name: 'num', type: { name: 'number', max: 42, min: 0 } }
   ],
   exec: createExec('tsm')
 };
 
-mockCommands.tsg = {
+var tsg = {
   name: 'tsg',
   description: 'a param group test',
   params: [
     {
       name: 'solo',
       type: { name: 'selection', data: [ 'aaa', 'bbb', 'ccc' ] },
       description: 'solo param'
     },
@@ -366,17 +289,17 @@ mockCommands.tsg = {
       defaultValue: 42,
       description: 'num param',
       option: 'Second'
     }
   ],
   exec: createExec('tsg')
 };
 
-mockCommands.tscook = {
+var tscook = {
   name: 'tscook',
   description: 'param group test to catch problems with cookie command',
   params: [
     {
       name: 'key',
       type: 'string',
       description: 'tscookKeyDesc'
     },
@@ -406,20 +329,19 @@ mockCommands.tscook = {
           description: 'tscookSecureDesc'
         }
       ]
     }
   ],
   exec: createExec('tscook')
 };
 
-mockCommands.tslong = {
+var tslong = {
   name: 'tslong',
   description: 'long param tests to catch problems with the jsb command',
-  returnValue:'string',
   params: [
     {
       name: 'msg',
       type: 'string',
       description: 'msg Desc'
     },
     {
       group: "Options Desc",
@@ -468,10 +390,151 @@ mockCommands.tslong = {
           defaultValue: "collapse"
         }
       ]
     }
   ],
   exec: createExec('tslong')
 };
 
+var tsfail = {
+  name: 'tsfail',
+  description: 'test errors',
+  params: [
+    {
+      name: 'method',
+      type: {
+        name: 'selection',
+        data: [
+          'reject', 'rejecttyped',
+          'throwerror', 'throwstring', 'throwinpromise',
+          'noerror'
+        ]
+      }
+    }
+  ],
+  exec: function(args, context) {
+    if (args.method === 'reject') {
+      var deferred = context.defer();
+      setTimeout(function() {
+        deferred.reject('rejected promise');
+      }, 10);
+      return deferred.promise;
+    }
+
+    if (args.method === 'rejecttyped') {
+      var deferred = context.defer();
+      setTimeout(function() {
+        deferred.reject(context.typedData('number', 54));
+      }, 10);
+      return deferred.promise;
+    }
+
+    if (args.method === 'throwinpromise') {
+      var deferred = context.defer();
+      setTimeout(function() {
+        deferred.resolve('should be lost');
+      }, 10);
+      return deferred.promise.then(function() {
+        var t = null;
+        return t.foo;
+      });
+    }
+
+    if (args.method === 'throwerror') {
+      throw new Error('thrown error');
+    }
+
+    if (args.method === 'throwstring') {
+      throw 'thrown string';
+    }
+
+    return 'no error';
+  }
+};
+
+mockCommands.commands = {};
+
+/**
+ * Registration and de-registration.
+ */
+mockCommands.setup = function(opts) {
+  // setup/shutdown needs to register/unregister types, however that means we
+  // need to re-initialize mockCommands.option1 and mockCommands.option2 with
+  // the actual types
+  mockCommands.option1.type = types.createType('string');
+  mockCommands.option2.type = types.createType('number');
+  mockCommands.option3.type = types.createType({
+    name: 'selection',
+    lookup: [
+      { name: 'one', value: 1 },
+      { name: 'two', value: 2 },
+      { name: 'three', value: 3 }
+    ]
+  });
+
+  types.addType(mockCommands.optionType);
+  types.addType(mockCommands.optionValue);
+
+  mockCommands.commands.tsv = canon.addCommand(tsv);
+  mockCommands.commands.tsr = canon.addCommand(tsr);
+  mockCommands.commands.tso = canon.addCommand(tso);
+  mockCommands.commands.tse = canon.addCommand(tse);
+  mockCommands.commands.tsj = canon.addCommand(tsj);
+  mockCommands.commands.tsb = canon.addCommand(tsb);
+  mockCommands.commands.tss = canon.addCommand(tss);
+  mockCommands.commands.tsu = canon.addCommand(tsu);
+  mockCommands.commands.tsf = canon.addCommand(tsf);
+  mockCommands.commands.tsn = canon.addCommand(tsn);
+  mockCommands.commands.tsnDif = canon.addCommand(tsnDif);
+  mockCommands.commands.tsnExt = canon.addCommand(tsnExt);
+  mockCommands.commands.tsnExte = canon.addCommand(tsnExte);
+  mockCommands.commands.tsnExten = canon.addCommand(tsnExten);
+  mockCommands.commands.tsnExtend = canon.addCommand(tsnExtend);
+  mockCommands.commands.tsnDeep = canon.addCommand(tsnDeep);
+  mockCommands.commands.tsnDeepDown = canon.addCommand(tsnDeepDown);
+  mockCommands.commands.tsnDeepDownNested = canon.addCommand(tsnDeepDownNested);
+  mockCommands.commands.tsnDeepDownNestedCmd = canon.addCommand(tsnDeepDownNestedCmd);
+  mockCommands.commands.tselarr = canon.addCommand(tselarr);
+  mockCommands.commands.tsm = canon.addCommand(tsm);
+  mockCommands.commands.tsg = canon.addCommand(tsg);
+  mockCommands.commands.tshidden = canon.addCommand(tshidden);
+  mockCommands.commands.tscook = canon.addCommand(tscook);
+  mockCommands.commands.tslong = canon.addCommand(tslong);
+  mockCommands.commands.tsfail = canon.addCommand(tsfail);
+};
+
+mockCommands.shutdown = function(opts) {
+  canon.removeCommand(tsv);
+  canon.removeCommand(tsr);
+  canon.removeCommand(tso);
+  canon.removeCommand(tse);
+  canon.removeCommand(tsj);
+  canon.removeCommand(tsb);
+  canon.removeCommand(tss);
+  canon.removeCommand(tsu);
+  canon.removeCommand(tsf);
+  canon.removeCommand(tsn);
+  canon.removeCommand(tsnDif);
+  canon.removeCommand(tsnExt);
+  canon.removeCommand(tsnExte);
+  canon.removeCommand(tsnExten);
+  canon.removeCommand(tsnExtend);
+  canon.removeCommand(tsnDeep);
+  canon.removeCommand(tsnDeepDown);
+  canon.removeCommand(tsnDeepDownNested);
+  canon.removeCommand(tsnDeepDownNestedCmd);
+  canon.removeCommand(tselarr);
+  canon.removeCommand(tsm);
+  canon.removeCommand(tsg);
+  canon.removeCommand(tshidden);
+  canon.removeCommand(tscook);
+  canon.removeCommand(tslong);
+  canon.removeCommand(tsfail);
+
+  types.removeType(mockCommands.optionType);
+  types.removeType(mockCommands.optionValue);
+
+  mockCommands.commands = {};
+};
+
 
 // });

--- a/browser/devtools/debugger/CmdDebugger.jsm
+++ b/browser/devtools/debugger/CmdDebugger.jsm
@@ -1,16 +1,16 @@
 /* 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/. */
 
 const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
 this.EXPORTED_SYMBOLS = [ ];
 
-Cu.import("resource:///modules/devtools/gcli.jsm");
+Cu.import("resource://gre/modules/devtools/gcli.jsm");
 Cu.import('resource://gre/modules/XPCOMUtils.jsm');
 
 XPCOMUtils.defineLazyModuleGetter(this, "gDevTools",
                                   "resource:///modules/devtools/gDevTools.jsm");
 
 XPCOMUtils.defineLazyModuleGetter(this, "console",
                                   "resource://gre/modules/devtools/Console.jsm");
 
@@ -152,17 +152,17 @@ gcli.addCommand({
       description: gcli.lookup("breakaddlineFileDesc")
     },
     {
       name: "line",
       type: { name: "number", min: 1, step: 10 },
       description: gcli.lookup("breakaddlineLineDesc")
     }
   ],
-  returnType: "html",
+  returnType: "string",
   exec: function(args, context) {
     args.type = "line";
 
     let dbg = getPanel(context, "jsdebugger");
     if (!dbg) {
       return gcli.lookup("debuggerStopped");
     }
     var deferred = context.defer();
@@ -196,17 +196,17 @@ gcli.addCommand({
           return dbg == null ?
               null :
               Object.keys(dbg.getAllBreakpoints()).length - 1;
         },
       },
       description: gcli.lookup("breakdelBreakidDesc")
     }
   ],
-  returnType: "html",
+  returnType: "string",
   exec: function(args, context) {
     let dbg = getPanel(context, "jsdebugger");
     if (!dbg) {
       return gcli.lookup("debuggerStopped");
     }
 
     let breakpoints = dbg.getAllBreakpoints();
     let id = Object.keys(breakpoints)[args.breakid];
@@ -376,17 +376,17 @@ gcli.addCommand({
 
 /**
  * 'dbg list' command
  */
 gcli.addCommand({
   name: "dbg list",
   description: gcli.lookup("dbgListSourcesDesc"),
   params: [],
-  returnType: "html",
+  returnType: "dom",
   exec: function(args, context) {
     let dbg = getPanel(context, "jsdebugger");
     let doc = context.environment.chromeDocument;
     if (!dbg) {
       return gcli.lookup("debuggerClosed");
     }
     let sources = dbg._view.Sources.values;
     let div = createXHTMLElement(doc, "div");

--- a/browser/devtools/debugger/debugger-controller.js
+++ b/browser/devtools/debugger/debugger-controller.js
@@ -792,17 +792,19 @@ StackFrames.prototype = {
     aScope._fetched = true;
     let env = aScope._sourceEnvironment;
 
     switch (env.type) {
       case "with":
       case "object":
         // Add nodes for every variable in scope.
         this.activeThread.pauseGrip(env.object).getPrototypeAndProperties(function(aResponse) {
-          this._insertScopeVariables(aResponse.ownProperties, aScope);
+          let { ownProperties, safeGetterValues } = aResponse;
+          this._mergeSafeGetterValues(ownProperties, safeGetterValues);
+          this._insertScopeVariables(ownProperties, aScope);
 
           // Signal that variables have been fetched.
           window.dispatchEvent(document, "Debugger:FetchedVariables");
           DebuggerView.Variables.commitHierarchy();
         }.bind(this));
         break;
       case "block":
       case "function":
@@ -898,19 +900,21 @@ StackFrames.prototype = {
     // Fetch the properties only once.
     if (aVar._fetched) {
       return;
     }
     aVar._fetched = true;
     let grip = aVar._sourceGrip;
 
     this.activeThread.pauseGrip(grip).getPrototypeAndProperties(function(aResponse) {
-      let { ownProperties, prototype } = aResponse;
+      let { ownProperties, prototype, safeGetterValues } = aResponse;
       let sortable = VariablesView.NON_SORTABLE_CLASSES.indexOf(grip.class) == -1;
 
+      this._mergeSafeGetterValues(ownProperties, safeGetterValues);
+
       // Add all the variable properties.
       if (ownProperties) {
         aVar.addProperties(ownProperties, {
           // Not all variables need to force sorted properties.
           sorted: sortable,
           // Expansion handlers must be set after the properties are added.
           callback: this._addVarExpander
         });
@@ -928,16 +932,43 @@ StackFrames.prototype = {
 
       // Signal that properties have been fetched.
       window.dispatchEvent(document, "Debugger:FetchedProperties");
       DebuggerView.Variables.commitHierarchy();
     }.bind(this));
   },
 
   /**
+   * Merge the safe getter values descriptors into the "own properties" object
+   * that comes from a "prototypeAndProperties" response packet. This is needed
+   * for Variables View.
+   *
+   * @private
+   * @param object aOwnProperties
+   *        The |ownProperties| object that will get the new safe getter values.
+   * @param object aSafeGetterValues
+   *        The |safeGetterValues| object.
+   */
+  _mergeSafeGetterValues:
+  function SF__mergeSafeGetterValues(aOwnProperties, aSafeGetterValues) {
+    // Merge the safe getter values into one object such that we can use it
+    // in VariablesView.
+    for (let name of Object.keys(aSafeGetterValues)) {
+      if (name in aOwnProperties) {
+        aOwnProperties[name].getterValue = aSafeGetterValues[name].getterValue;
+        aOwnProperties[name].getterPrototypeLevel = aSafeGetterValues[name]
+                                                    .getterPrototypeLevel;
+      }
+      else {
+        aOwnProperties[name] = aSafeGetterValues[name];
+      }
+    }
+  },
+
+  /**
    * Adds the specified stack frame to the list.
    *
    * @param object aFrame
    *        The new frame to add.
    */
   _addFrame: function SF__addFrame(aFrame) {
     let depth = aFrame.depth;
     let { url, line } = aFrame.where;

--- a/browser/devtools/debugger/debugger-toolbar.js
+++ b/browser/devtools/debugger/debugger-toolbar.js
@@ -401,17 +401,16 @@ create({ constructor: StackFramesView, p
   addFrame: function DVSF_addFrame(aFrameTitle, aSourceLocation, aLineNumber, aDepth) {
     // Create the element node and menu entry for the stack frame item.
     let frameView = this._createFrameView.apply(this, arguments);
     let menuEntry = this._createMenuEntry.apply(this, arguments);
 
     // Append a stack frame item to this container.
     let stackframeItem = this.push(frameView, {
       index: 0, /* specifies on which position should the item be appended */
-      relaxed: true, /* this container should allow dupes & degenerates */
       attachment: {
         popup: menuEntry,
         depth: aDepth
       },
       attributes: [
         ["contextmenu", "stackframesMenupopup"],
         ["tooltiptext", aSourceLocation]
       ],
@@ -941,17 +940,17 @@ FilterView.prototype = {
     }
     // Synchronize with the view's filtered sources container.
     DebuggerView.FilteredSources.syncFileSearch();
 
     // Hide all the groups with no visible children.
     view.node.hideEmptyGroups();
 
     // Ensure the currently selected item is visible.
-    view.node.ensureSelectionIsVisible(true);
+    view.node.ensureSelectionIsVisible({ withGroup: true });
 
     // Remember the previously searched file to avoid redundant filtering.
     this._prevSearchedFile = aFile;
   },
 
   /**
    * Performs a line search if necessary.
    * (Jump to lines in the currently visible source).

--- a/browser/devtools/debugger/test/browser_dbg_propertyview-09.js
+++ b/browser/devtools/debugger/test/browser_dbg_propertyview-09.js
@@ -51,20 +51,23 @@ function testFrameParameters()
         "Should have three frames.");
 
       is(globalNodes[1].querySelector(".name").getAttribute("value"), "SpecialPowers",
         "Should have the right property name for |SpecialPowers|.");
 
       is(globalNodes[1].querySelector(".value").getAttribute("value"), "[object Object]",
         "Should have the right property value for |SpecialPowers|.");
 
-      is(globalNodes[3].querySelector(".name").getAttribute("value"), "document",
+      let globalScopeObject = gDebugger.DebuggerView.Variables.getScopeForNode(globalScope);
+      let documentNode = globalScopeObject.get("document");
+
+      is(documentNode.target.querySelector(".name").getAttribute("value"), "document",
         "Should have the right property name for |document|.");
 
-      is(globalNodes[3].querySelector(".value").getAttribute("value"), "[object HTMLDocument]",
+      is(documentNode.target.querySelector(".value").getAttribute("value"), "[object HTMLDocument]",
         "Should have the right property value for |document|.");
 
       let len = globalNodes.length - 1;
       is(globalNodes[len].querySelector(".name").getAttribute("value"), "window",
         "Should have the right property name for |window|.");
 
       is(globalNodes[len].querySelector(".value").getAttribute("value"), "[object Window]",
         "Should have the right property value for |window|.");

--- a/browser/devtools/debugger/test/browser_dbg_propertyview-10.js
+++ b/browser/devtools/debugger/test/browser_dbg_propertyview-10.js
@@ -56,20 +56,23 @@ function testWithFrame()
       is(scopes.childNodes.length, 5, "Should have 5 variable scopes.");
 
       is(innerNodes[1].querySelector(".name").getAttribute("value"), "one",
         "Should have the right property name for |one|.");
 
       is(innerNodes[1].querySelector(".value").getAttribute("value"), "1",
         "Should have the right property value for |one|.");
 
-      is(globalNodes[3].querySelector(".name").getAttribute("value"), "document",
+      let globalScopeObject = gDebugger.DebuggerView.Variables.getScopeForNode(globalScope);
+      let documentNode = globalScopeObject.get("document");
+
+      is(documentNode.target.querySelector(".name").getAttribute("value"), "document",
         "Should have the right property name for |document|.");
 
-      is(globalNodes[3].querySelector(".value").getAttribute("value"), "[object HTMLDocument]",
+      is(documentNode.target.querySelector(".value").getAttribute("value"), "[object HTMLDocument]",
         "Should have the right property value for |document|.");
 
       let len = globalNodes.length - 1;
       is(globalNodes[len].querySelector(".name").getAttribute("value"), "window",
         "Should have the right property name for |window|.");
 
       is(globalNodes[len].querySelector(".value").getAttribute("value"), "[object Window]",
         "Should have the right property value for |window|.");

--- a/browser/devtools/debugger/test/browser_dbg_propertyview-11.js
+++ b/browser/devtools/debugger/test/browser_dbg_propertyview-11.js
@@ -56,25 +56,27 @@ function testFrameParameters()
         "Should have the right property value for |button|.");
 
       is(anonymousNodes[2].querySelector(".name").getAttribute("value"), "buttonAsProto",
         "Should have the right property name for |buttonAsProto|.");
 
       is(anonymousNodes[2].querySelector(".value").getAttribute("value"), "[object Object]",
         "Should have the right property value for |buttonAsProto|.");
 
-      is(globalNodes[3].querySelector(".name").getAttribute("value"), "document",
+      let globalScopeObject = gVars.getScopeForNode(globalScope);
+      let documentNode = globalScopeObject.get("document");
+
+      is(documentNode.target.querySelector(".name").getAttribute("value"), "document",
         "Should have the right property name for |document|.");
 
-      is(globalNodes[3].querySelector(".value").getAttribute("value"), "[object HTMLDocument]",
+      is(documentNode.target.querySelector(".value").getAttribute("value"), "[object HTMLDocument]",
         "Should have the right property value for |document|.");
 
       let buttonNode = gVars.getItemForNode(anonymousNodes[1]);
       let buttonAsProtoNode = gVars.getItemForNode(anonymousNodes[2]);
-      let documentNode = gVars.getItemForNode(globalNodes[3]);
 
       is(buttonNode.expanded, false,
         "The buttonNode should not be expanded at this point.");
       is(buttonAsProtoNode.expanded, false,
         "The buttonAsProtoNode should not be expanded at this point.");
       is(documentNode.expanded, false,
         "The documentNode should not be expanded at this point.");
 
@@ -126,133 +128,90 @@ function testFrameParameters()
 
         is(documentNode.get("__proto__").target.querySelector(".name")
            .getAttribute("value"), "__proto__",
           "Should have the right property name for '__proto__' in documentNode.");
         ok(documentNode.get("__proto__").target.querySelector(".value")
            .getAttribute("value").search(/object/) != -1,
           "'__proto__' in documentNode should be an object.");
 
-        let buttonProtoNode = buttonNode.get("__proto__");
+        // Now the main course: make sure that the native getters for WebIDL
+        // attributes have been called and a value has been returned.
+        is(buttonNode.get("type").target.querySelector(".name")
+           .getAttribute("value"), "type",
+          "Should have the right property name for 'type' in buttonProtoNode.");
+        is(buttonNode.get("type").target.querySelector(".value")
+           .getAttribute("value"), '"submit"',
+          "'type' in buttonProtoNode should have the right value.");
+        is(buttonNode.get("formMethod").target.querySelector(".name")
+           .getAttribute("value"), "formMethod",
+          "Should have the right property name for 'formMethod' in buttonProtoNode.");
+        is(buttonNode.get("formMethod").target.querySelector(".value")
+           .getAttribute("value"), '""',
+          "'formMethod' in buttonProtoNode should have the right value.");
+
+        is(documentNode.get("domain").target.querySelector(".name")
+           .getAttribute("value"), "domain",
+          "Should have the right property name for 'domain' in documentProtoNode.");
+        is(documentNode.get("domain").target.querySelector(".value")
+           .getAttribute("value"), '"example.com"',
+          "'domain' in documentProtoNode should have the right value.");
+        is(documentNode.get("cookie").target.querySelector(".name")
+           .getAttribute("value"), "cookie",
+          "Should have the right property name for 'cookie' in documentProtoNode.");
+        is(documentNode.get("cookie").target.querySelector(".value")
+           .getAttribute("value"), '""',
+          "'cookie' in documentProtoNode should have the right value.");
+
         let buttonAsProtoProtoNode = buttonAsProtoNode.get("__proto__");
-        let documentProtoNode = documentNode.get("__proto__");
 
-        is(buttonProtoNode.expanded, false,
-          "The buttonProtoNode should not be expanded at this point.");
         is(buttonAsProtoProtoNode.expanded, false,
           "The buttonAsProtoProtoNode should not be expanded at this point.");
-        is(documentProtoNode.expanded, false,
-          "The documentProtoNode should not be expanded at this point.");
 
         // Expand the prototypes of 'button', 'buttonAsProto' and 'document'
         // tree nodes. This causes their properties to be retrieved and
         // displayed.
-        buttonProtoNode.expand();
         buttonAsProtoProtoNode.expand();
-        documentProtoNode.expand();
 
-        is(buttonProtoNode.expanded, true,
-          "The buttonProtoNode should be expanded at this point.");
         is(buttonAsProtoProtoNode.expanded, true,
           "The buttonAsProtoProtoNode should be expanded at this point.");
-        is(documentProtoNode.expanded, true,
-          "The documentProtoNode should be expanded at this point.");
 
 
         // Poll every few milliseconds until the properties are retrieved.
         // It's important to set the timer in the chrome window, because the
         // content window timers are disabled while the debuggee is paused.
         let count2 = 0;
         let intervalID1 = window.setInterval(function(){
           info("count2: " + count2);
           if (++count2 > 50) {
             ok(false, "Timed out while polling for the properties.");
             window.clearInterval(intervalID1);
             return resumeAndFinish();
           }
-          if (!buttonProtoNode._retrieved ||
-              !buttonAsProtoProtoNode._retrieved ||
-              !documentProtoNode._retrieved) {
+          if (!buttonAsProtoProtoNode._retrieved) {
             return;
           }
           window.clearInterval(intervalID1);
 
-          // Now the main course: make sure that the native getters for WebIDL
-          // attributes have been called and a value has been returned.
-          is(buttonProtoNode.get("type").target.querySelector(".name")
+          // Test this more involved case that reuses an object that is
+          // present in another cache line.
+          is(buttonAsProtoProtoNode.get("type").target.querySelector(".name")
              .getAttribute("value"), "type",
-            "Should have the right property name for 'type' in buttonProtoNode.");
-          is(buttonProtoNode.get("type").target.querySelector(".value")
+            "Should have the right property name for 'type' in buttonAsProtoProtoProtoNode.");
+          is(buttonAsProtoProtoNode.get("type").target.querySelector(".value")
              .getAttribute("value"), '"submit"',
-            "'type' in buttonProtoNode should have the right value.");
-          is(buttonProtoNode.get("formMethod").target.querySelector(".name")
+            "'type' in buttonAsProtoProtoProtoNode should have the right value.");
+          is(buttonAsProtoProtoNode.get("formMethod").target.querySelector(".name")
              .getAttribute("value"), "formMethod",
-            "Should have the right property name for 'formMethod' in buttonProtoNode.");
-          is(buttonProtoNode.get("formMethod").target.querySelector(".value")
+            "Should have the right property name for 'formMethod' in buttonAsProtoProtoProtoNode.");
+          is(buttonAsProtoProtoNode.get("formMethod").target.querySelector(".value")
              .getAttribute("value"), '""',
-            "'formMethod' in buttonProtoNode should have the right value.");
-
-          is(documentProtoNode.get("domain").target.querySelector(".name")
-             .getAttribute("value"), "domain",
-            "Should have the right property name for 'domain' in documentProtoNode.");
-          is(documentProtoNode.get("domain").target.querySelector(".value")
-             .getAttribute("value"), '"example.com"',
-            "'domain' in documentProtoNode should have the right value.");
-          is(documentProtoNode.get("cookie").target.querySelector(".name")
-             .getAttribute("value"), "cookie",
-            "Should have the right property name for 'cookie' in documentProtoNode.");
-          is(documentProtoNode.get("cookie").target.querySelector(".value")
-             .getAttribute("value"), '""',
-            "'cookie' in documentProtoNode should have the right value.");
-
-          let buttonAsProtoProtoProtoNode = buttonAsProtoProtoNode.get("__proto__");
-
-          is(buttonAsProtoProtoProtoNode.expanded, false,
-            "The buttonAsProtoProtoProtoNode should not be expanded at this point.");
-
-          // Expand the prototype of the prototype of 'buttonAsProto' tree
-          // node. This causes its properties to be retrieved and displayed.
-          buttonAsProtoProtoProtoNode.expand();
+            "'formMethod' in buttonAsProtoProtoProtoNode should have the right value.");
 
-          is(buttonAsProtoProtoProtoNode.expanded, true,
-            "The buttonAsProtoProtoProtoNode should be expanded at this point.");
-
-          // Poll every few milliseconds until the properties are retrieved.
-          // It's important to set the timer in the chrome window, because the
-          // content window timers are disabled while the debuggee is paused.
-          let count3 = 0;
-          let intervalID2 = window.setInterval(function(){
-            info("count3: " + count3);
-            if (++count3 > 50) {
-              ok(false, "Timed out while polling for the properties.");
-              window.clearInterval(intervalID2);
-              return resumeAndFinish();
-            }
-            if (!buttonAsProtoProtoProtoNode._retrieved) {
-              return;
-            }
-            window.clearInterval(intervalID2);
-
-            // Test this more involved case that reuses an object that is
-            // present in another cache line.
-            is(buttonAsProtoProtoProtoNode.get("type").target.querySelector(".name")
-               .getAttribute("value"), "type",
-              "Should have the right property name for 'type' in buttonAsProtoProtoProtoNode.");
-            is(buttonAsProtoProtoProtoNode.get("type").target.querySelector(".value")
-               .getAttribute("value"), '"submit"',
-              "'type' in buttonAsProtoProtoProtoNode should have the right value.");
-            is(buttonAsProtoProtoProtoNode.get("formMethod").target.querySelector(".name")
-               .getAttribute("value"), "formMethod",
-              "Should have the right property name for 'formMethod' in buttonAsProtoProtoProtoNode.");
-            is(buttonAsProtoProtoProtoNode.get("formMethod").target.querySelector(".value")
-               .getAttribute("value"), '""',
-              "'formMethod' in buttonAsProtoProtoProtoNode should have the right value.");
-
-            resumeAndFinish();
-          }, 100);
+          resumeAndFinish();
         }, 100);
       }, 100);
     }}, 0);
   }, false);
 
   EventUtils.sendMouseEvent({ type: "click" },
     content.document.querySelector("button"),
     content.window);