Rename Debug to Debugger.
authorJason Orendorff <jorendorff@mozilla.com>
Tue, 05 Jul 2011 07:48:26 -0500
changeset 74497 67018148d71d7504446d509b8452dc0d4fd6b4fe
parent 74496 821e5b01b1b1c5d5dddb8312f273679f67d0cbf3
child 74498 f413efa2723b906d713a5d6425aac0156b0d3287
push id2
push userbsmedberg@mozilla.com
push dateFri, 19 Aug 2011 14:38:13 +0000
milestone7.0a1
Rename Debug to Debugger.
js/src/jit-test/tests/debug/Debug-clearAllBreakpoints-01.js
js/src/jit-test/tests/debug/Debug-ctor-01.js
js/src/jit-test/tests/debug/Debug-ctor-02.js
js/src/jit-test/tests/debug/Debug-ctor-03.js
js/src/jit-test/tests/debug/Debug-debuggees-01.js
js/src/jit-test/tests/debug/Debug-debuggees-02.js
js/src/jit-test/tests/debug/Debug-debuggees-03.js
js/src/jit-test/tests/debug/Debug-debuggees-04.js
js/src/jit-test/tests/debug/Debug-debuggees-05.js
js/src/jit-test/tests/debug/Debug-debuggees-06.js
js/src/jit-test/tests/debug/Debug-debuggees-07.js
js/src/jit-test/tests/debug/Debug-debuggees-08.js
js/src/jit-test/tests/debug/Debug-debuggees-09.js
js/src/jit-test/tests/debug/Debug-debuggees-10.js
js/src/jit-test/tests/debug/Debug-debuggees-11.js
js/src/jit-test/tests/debug/Debug-debuggees-12.js
js/src/jit-test/tests/debug/Debug-debuggees-13.js
js/src/jit-test/tests/debug/Debug-debuggees-14.js
js/src/jit-test/tests/debug/Debug-debuggees-15.js
js/src/jit-test/tests/debug/Debug-debuggees-16.js
js/src/jit-test/tests/debug/Debug-enabled-01.js
js/src/jit-test/tests/debug/Debug-getYoungestFrame-01.js
js/src/jit-test/tests/debug/Debug-getYoungestFrame-02.js
js/src/jit-test/tests/debug/Debug-multi-01.js
js/src/jit-test/tests/debug/Debug-multi-02.js
js/src/jit-test/tests/debug/Debug-multi-03.js
js/src/jit-test/tests/debug/Debugger-clearAllBreakpoints-01.js
js/src/jit-test/tests/debug/Debugger-ctor-01.js
js/src/jit-test/tests/debug/Debugger-ctor-02.js
js/src/jit-test/tests/debug/Debugger-ctor-03.js
js/src/jit-test/tests/debug/Debugger-debuggees-01.js
js/src/jit-test/tests/debug/Debugger-debuggees-02.js
js/src/jit-test/tests/debug/Debugger-debuggees-03.js
js/src/jit-test/tests/debug/Debugger-debuggees-04.js
js/src/jit-test/tests/debug/Debugger-debuggees-05.js
js/src/jit-test/tests/debug/Debugger-debuggees-06.js
js/src/jit-test/tests/debug/Debugger-debuggees-07.js
js/src/jit-test/tests/debug/Debugger-debuggees-08.js
js/src/jit-test/tests/debug/Debugger-debuggees-09.js
js/src/jit-test/tests/debug/Debugger-debuggees-10.js
js/src/jit-test/tests/debug/Debugger-debuggees-11.js
js/src/jit-test/tests/debug/Debugger-debuggees-12.js
js/src/jit-test/tests/debug/Debugger-debuggees-13.js
js/src/jit-test/tests/debug/Debugger-debuggees-14.js
js/src/jit-test/tests/debug/Debugger-debuggees-15.js
js/src/jit-test/tests/debug/Debugger-debuggees-16.js
js/src/jit-test/tests/debug/Debugger-enabled-01.js
js/src/jit-test/tests/debug/Debugger-getYoungestFrame-01.js
js/src/jit-test/tests/debug/Debugger-getYoungestFrame-02.js
js/src/jit-test/tests/debug/Debugger-multi-01.js
js/src/jit-test/tests/debug/Debugger-multi-02.js
js/src/jit-test/tests/debug/Debugger-multi-03.js
js/src/jit-test/tests/debug/Frame-01.js
js/src/jit-test/tests/debug/Frame-02.js
js/src/jit-test/tests/debug/Frame-03.js
js/src/jit-test/tests/debug/Frame-arguments-01.js
js/src/jit-test/tests/debug/Frame-arguments-02.js
js/src/jit-test/tests/debug/Frame-arguments-03.js
js/src/jit-test/tests/debug/Frame-arguments-04.js
js/src/jit-test/tests/debug/Frame-arguments-05.js
js/src/jit-test/tests/debug/Frame-arguments-06.js
js/src/jit-test/tests/debug/Frame-eval-01.js
js/src/jit-test/tests/debug/Frame-eval-02.js
js/src/jit-test/tests/debug/Frame-eval-03.js
js/src/jit-test/tests/debug/Frame-eval-04.js
js/src/jit-test/tests/debug/Frame-eval-05.js
js/src/jit-test/tests/debug/Frame-eval-06.js
js/src/jit-test/tests/debug/Frame-eval-07.js
js/src/jit-test/tests/debug/Frame-eval-08.js
js/src/jit-test/tests/debug/Frame-eval-09.js
js/src/jit-test/tests/debug/Frame-eval-10.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-01.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-02.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-03.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-04.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-05.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-06.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-07.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-08.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-09.js
js/src/jit-test/tests/debug/Frame-evalWithBindings-10.js
js/src/jit-test/tests/debug/Frame-identity-01.js
js/src/jit-test/tests/debug/Frame-identity-02.js
js/src/jit-test/tests/debug/Frame-identity-03.js
js/src/jit-test/tests/debug/Frame-identity-04.js
js/src/jit-test/tests/debug/Frame-live-01.js
js/src/jit-test/tests/debug/Frame-live-02.js
js/src/jit-test/tests/debug/Frame-live-03.js
js/src/jit-test/tests/debug/Frame-live-04.js
js/src/jit-test/tests/debug/Frame-offset-01.js
js/src/jit-test/tests/debug/Frame-offset-02.js
js/src/jit-test/tests/debug/Frame-older-01.js
js/src/jit-test/tests/debug/Frame-script-01.js
js/src/jit-test/tests/debug/Frame-script-02.js
js/src/jit-test/tests/debug/Frame-this-01.js
js/src/jit-test/tests/debug/Frame-this-02.js
js/src/jit-test/tests/debug/Frame-this-03.js
js/src/jit-test/tests/debug/Frame-this-04.js
js/src/jit-test/tests/debug/Object-01.js
js/src/jit-test/tests/debug/Object-02.js
js/src/jit-test/tests/debug/Object-apply-01.js
js/src/jit-test/tests/debug/Object-apply-02.js
js/src/jit-test/tests/debug/Object-apply-03.js
js/src/jit-test/tests/debug/Object-apply-04.js
js/src/jit-test/tests/debug/Object-callable.js
js/src/jit-test/tests/debug/Object-class.js
js/src/jit-test/tests/debug/Object-gc-01.js
js/src/jit-test/tests/debug/Object-identity-01.js
js/src/jit-test/tests/debug/Object-identity-02.js
js/src/jit-test/tests/debug/Object-identity-03.js
js/src/jit-test/tests/debug/Object-name-01.js
js/src/jit-test/tests/debug/Object-name-02.js
js/src/jit-test/tests/debug/Object-parameterNames.js
js/src/jit-test/tests/debug/Object-proto.js
js/src/jit-test/tests/debug/Object-script.js
js/src/jit-test/tests/debug/Script-01.js
js/src/jit-test/tests/debug/Script-02.js
js/src/jit-test/tests/debug/Script-clearBreakpoint-01.js
js/src/jit-test/tests/debug/Script-clearBreakpoint-02.js
js/src/jit-test/tests/debug/Script-clearBreakpoint-03.js
js/src/jit-test/tests/debug/Script-clearBreakpoint-04.js
js/src/jit-test/tests/debug/Script-gc-01.js
js/src/jit-test/tests/debug/Script-gc-02.js
js/src/jit-test/tests/debug/Script-gc-03.js
js/src/jit-test/tests/debug/Script-getBreakpoints-01.js
js/src/jit-test/tests/debug/Script-getBreakpoints-02.js
js/src/jit-test/tests/debug/Script-getChildScripts-01.js
js/src/jit-test/tests/debug/Script-getChildScripts-02.js
js/src/jit-test/tests/debug/Script-getLineOffsets-01.js
js/src/jit-test/tests/debug/Script-getLineOffsets-02.js
js/src/jit-test/tests/debug/Script-getLineOffsets-03.js
js/src/jit-test/tests/debug/Script-getLineOffsets-04.js
js/src/jit-test/tests/debug/Script-getLineOffsets-05.js
js/src/jit-test/tests/debug/Script-getLineOffsets-06.js
js/src/jit-test/tests/debug/Script-getOffsetLine-01.js
js/src/jit-test/tests/debug/Script-getOffsetLine-02.js
js/src/jit-test/tests/debug/breakpoint-01.js
js/src/jit-test/tests/debug/breakpoint-02.js
js/src/jit-test/tests/debug/breakpoint-03.js
js/src/jit-test/tests/debug/breakpoint-04.js
js/src/jit-test/tests/debug/breakpoint-05.js
js/src/jit-test/tests/debug/breakpoint-06.js
js/src/jit-test/tests/debug/breakpoint-07.js
js/src/jit-test/tests/debug/breakpoint-08.js
js/src/jit-test/tests/debug/breakpoint-gc-01.js
js/src/jit-test/tests/debug/breakpoint-gc-02.js
js/src/jit-test/tests/debug/breakpoint-multi-01.js
js/src/jit-test/tests/debug/breakpoint-multi-02.js
js/src/jit-test/tests/debug/breakpoint-multi-03.js
js/src/jit-test/tests/debug/breakpoint-multi-04.js
js/src/jit-test/tests/debug/breakpoint-resume-01.js
js/src/jit-test/tests/debug/breakpoint-resume-02.js
js/src/jit-test/tests/debug/breakpoint-resume-03.js
js/src/jit-test/tests/debug/dispatch-01.js
js/src/jit-test/tests/debug/dispatch-02.js
js/src/jit-test/tests/debug/gc-01.js
js/src/jit-test/tests/debug/gc-02.js
js/src/jit-test/tests/debug/gc-03.js
js/src/jit-test/tests/debug/gc-04.js
js/src/jit-test/tests/debug/gc-05.js
js/src/jit-test/tests/debug/gc-06.js
js/src/jit-test/tests/debug/gc-07.js
js/src/jit-test/tests/debug/gc-08.js
js/src/jit-test/tests/debug/gc-compartment-01.js
js/src/jit-test/tests/debug/gc-compartment-02.js
js/src/jit-test/tests/debug/hooks-debuggerHandler-01.js
js/src/jit-test/tests/debug/hooks-debuggerHandler-02.js
js/src/jit-test/tests/debug/hooks-debuggerHandler-03.js
js/src/jit-test/tests/debug/hooks-deleted.js
js/src/jit-test/tests/debug/hooks-throw-01.js
js/src/jit-test/tests/debug/hooks-throw-02.js
js/src/jit-test/tests/debug/hooks-throw-03.js
js/src/jit-test/tests/debug/hooks-throw-04.js
js/src/jit-test/tests/debug/hooks-throw-05.js
js/src/jit-test/tests/debug/hooks-throw-06.js
js/src/jit-test/tests/debug/resumption-01.js
js/src/jit-test/tests/debug/resumption-02.js
js/src/jit-test/tests/debug/resumption-03.js
js/src/jit-test/tests/debug/resumption-04.js
js/src/jit-test/tests/debug/resumption-05.js
js/src/jit-test/tests/debug/surfaces-01.js
js/src/jit-test/tests/debug/surfaces-02.js
js/src/jit-test/tests/debug/surfaces-03.js
js/src/jit-test/tests/debug/surfaces-offsets.js
js/src/jit-test/tests/debug/uncaughtExceptionHook-01.js
js/src/jit-test/tests/debug/uncaughtExceptionHook-02.js
js/src/jit-test/tests/debug/uncaughtExceptionHook-03.js
js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-01.js
js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-02.js
js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-03.js
js/src/jsapi-tests/testDebugger.cpp
js/src/jscntxt.h
js/src/jscompartment.cpp
js/src/jscompartment.h
js/src/jsdbg.cpp
js/src/jsdbg.h
js/src/jsdbgapi.cpp
js/src/jsdbgapi.h
js/src/jsgc.cpp
js/src/jsinterp.cpp
js/src/jsprvtd.h
js/src/jsscript.cpp
js/src/methodjit/Compiler.cpp
js/src/methodjit/InvokeHelpers.cpp
js/src/methodjit/StubCalls.cpp
js/src/methodjit/StubCalls.h
js/src/shell/js.cpp
js/src/vm/GlobalObject.cpp
js/src/vm/GlobalObject.h
rename from js/src/jit-test/tests/debug/Debug-clearAllBreakpoints-01.js
rename to js/src/jit-test/tests/debug/Debugger-clearAllBreakpoints-01.js
--- a/js/src/jit-test/tests/debug/Debug-clearAllBreakpoints-01.js
+++ b/js/src/jit-test/tests/debug/Debugger-clearAllBreakpoints-01.js
@@ -1,15 +1,15 @@
-// clearAllBreakpoints clears breakpoints for the current Debug object only.
+// clearAllBreakpoints clears breakpoints for the current Debugger object only.
 
 var g = newGlobal('new-compartment');
 
 var hits = 0;
 function attach(i) {
-    var dbg = Debug(g);
+    var dbg = Debugger(g);
     var handler = {
         hit: function (frame) {
             hits++;
             dbg.clearAllBreakpoints(handler);
         }
     };
 
     dbg.hooks = {
rename from js/src/jit-test/tests/debug/Debug-ctor-01.js
rename to js/src/jit-test/tests/debug/Debugger-ctor-01.js
--- a/js/src/jit-test/tests/debug/Debug-ctor-01.js
+++ b/js/src/jit-test/tests/debug/Debugger-ctor-01.js
@@ -1,21 +1,21 @@
 load(libdir + 'asserts.js');
 
-// Debug rejects arguments that aren't cross-compartment wrappers.
-assertThrowsInstanceOf(function () { Debug(null); }, TypeError);
-assertThrowsInstanceOf(function () { Debug(true); }, TypeError);
-assertThrowsInstanceOf(function () { Debug(42); }, TypeError);
-assertThrowsInstanceOf(function () { Debug("bad"); }, TypeError);
-assertThrowsInstanceOf(function () { Debug(function () {}); }, TypeError);
-assertThrowsInstanceOf(function () { Debug(this); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(null); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(true); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(42); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug("bad"); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(function () {}); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(this); }, TypeError);
+// Debugger rejects arguments that aren't cross-compartment wrappers.
+assertThrowsInstanceOf(function () { Debugger(null); }, TypeError);
+assertThrowsInstanceOf(function () { Debugger(true); }, TypeError);
+assertThrowsInstanceOf(function () { Debugger(42); }, TypeError);
+assertThrowsInstanceOf(function () { Debugger("bad"); }, TypeError);
+assertThrowsInstanceOf(function () { Debugger(function () {}); }, TypeError);
+assertThrowsInstanceOf(function () { Debugger(this); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(null); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(true); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(42); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger("bad"); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(function () {}); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(this); }, TypeError);
 
-// From the main compartment, creating a Debug on a sandbox compartment.
+// From the main compartment, creating a Debugger on a sandbox compartment.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
-assertEq(dbg instanceof Debug, true);
-assertEq(Object.getPrototypeOf(dbg), Debug.prototype);
+var dbg = new Debugger(g);
+assertEq(dbg instanceof Debugger, true);
+assertEq(Object.getPrototypeOf(dbg), Debugger.prototype);
rename from js/src/jit-test/tests/debug/Debug-ctor-02.js
rename to js/src/jit-test/tests/debug/Debugger-ctor-02.js
--- a/js/src/jit-test/tests/debug/Debug-ctor-02.js
+++ b/js/src/jit-test/tests/debug/Debugger-ctor-02.js
@@ -1,17 +1,17 @@
 // |jit-test| debug
-// Test creating a Debug in a sandbox, debugging the initial global.
+// Test creating a Debugger in a sandbox, debugging the initial global.
 //
 // This requires debug mode to already be on in the initial global, since it's
 // always on the stack in the shell. Hence the |jit-test| tag.
 
 load(libdir + 'asserts.js');
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
-g.eval("var dbg = new Debug(debuggeeGlobal);");
-assertEq(g.eval("dbg instanceof Debug"), true);
+g.eval("var dbg = new Debugger(debuggeeGlobal);");
+assertEq(g.eval("dbg instanceof Debugger"), true);
 
-// The Debug constructor from this compartment will not accept as its argument
+// The Debugger constructor from this compartment will not accept as its argument
 // an Object from this compartment. Shenanigans won't fool the membrane.
 g.parent = this;
-assertThrowsInstanceOf(function () { g.eval("parent.Debug(parent.Object())"); }, TypeError);
+assertThrowsInstanceOf(function () { g.eval("parent.Debugger(parent.Object())"); }, TypeError);
rename from js/src/jit-test/tests/debug/Debug-ctor-03.js
rename to js/src/jit-test/tests/debug/Debugger-ctor-03.js
--- a/js/src/jit-test/tests/debug/Debug-ctor-03.js
+++ b/js/src/jit-test/tests/debug/Debugger-ctor-03.js
@@ -10,10 +10,10 @@ if (typeof setDebugMode === 'function') 
     }
 }
 
 if (!canEnable) {
     var g = newGlobal('new-compartment');
     g.libdir = libdir;
     g.eval("load(libdir + 'asserts.js');");
     g.parent = this;
-    g.eval("assertThrowsInstanceOf(function () { new Debug(parent); }, Error);");
+    g.eval("assertThrowsInstanceOf(function () { new Debugger(parent); }, Error);");
 }
rename from js/src/jit-test/tests/debug/Debug-debuggees-01.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-01.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-01.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-01.js
@@ -1,5 +1,5 @@
-// A Debug object created with no argument initially has no debuggees.
-var dbg = new Debug;
+// A Debugger object created with no argument initially has no debuggees.
+var dbg = new Debugger;
 var debuggees = dbg.getDebuggees();
 assertEq(Array.isArray(debuggees), true);
 assertEq(debuggees.length, 0);
rename from js/src/jit-test/tests/debug/Debug-debuggees-02.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-02.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-02.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-02.js
@@ -1,10 +1,10 @@
 // The array returned by getDebuggees is just a snapshot, not live.
-var dbg = new Debug;
+var dbg = new Debugger;
 var a1 = dbg.getDebuggees();
 var g = newGlobal('new-compartment');
 var gw = dbg.addDebuggee(g);
-assertEq(gw instanceof Debug.Object, true);
+assertEq(gw instanceof Debugger.Object, true);
 var a2 = dbg.getDebuggees();
 assertEq(a2.length, 1);
 assertEq(a2[0], gw);
 assertEq(a1.length, 0);
rename from js/src/jit-test/tests/debug/Debug-debuggees-03.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-03.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-03.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-03.js
@@ -1,18 +1,18 @@
-// Debug hooks fire based on debuggees.
+// Debugger hooks fire based on debuggees.
 
 var g1 = newGlobal('new-compartment');
 g1.eval("var g2 = newGlobal('same-compartment')");
 var g2 = g1.g2;
 g1.eval("function f() { debugger; g2.g(); }");
 g2.eval("function g() { debugger; }");
 
 var log;
-var dbg = new Debug;
+var dbg = new Debugger;
 dbg.hooks = {debuggerHandler: function (frame) { log += frame.callee.name; }};
 
 // No debuggees: the debuggerHandler is not called.
 log = '';
 g1.f();
 assertEq(log, '');
 
 // Add a debuggee and check that the handler is called.
rename from js/src/jit-test/tests/debug/Debug-debuggees-04.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-04.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-04.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-04.js
@@ -1,16 +1,16 @@
 // hasDebuggee tests.
 
 var g1 = newGlobal('new-compartment'), g1w;
 g1.eval("var g2 = newGlobal('same-compartment')");
 var g2 = g1.g2;
 var g1w, g2w;
 
-var dbg = new Debug;
+var dbg = new Debugger;
 function checkHas(hasg1, hasg2) {
     assertEq(dbg.hasDebuggee(g1), hasg1);
     if (typeof g1w === 'object')
         assertEq(dbg.hasDebuggee(g1w), hasg1);
     assertEq(dbg.hasDebuggee(g2), hasg2);
     if (typeof g2w === 'object')
         assertEq(dbg.hasDebuggee(g2w), hasg2);
 }
rename from js/src/jit-test/tests/debug/Debug-debuggees-05.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-05.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-05.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-05.js
@@ -1,8 +1,8 @@
-// addDebuggee returns different Debug.Object wrappers for different Debug objects.
+// addDebuggee returns different Debugger.Object wrappers for different Debugger objects.
 
 var g = newGlobal('new-compartment');
-var dbg1 = new Debug;
+var dbg1 = new Debugger;
 var gw1 = dbg1.addDebuggee(g);
-var dbg2 = new Debug;
+var dbg2 = new Debugger;
 var gw2 = dbg2.addDebuggee(g);
 assertEq(gw1 !== gw2, true);
rename from js/src/jit-test/tests/debug/Debug-debuggees-06.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-06.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-06.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-06.js
@@ -1,26 +1,26 @@
 // {has,add,remove}Debuggee throw a TypeError if the argument is invalid.
 
 load(libdir + "asserts.js");
 
-var dbg = new Debug;
+var dbg = new Debugger;
 
 function check(val) {
     assertThrowsInstanceOf(function () { dbg.hasDebuggee(val); }, TypeError);
     assertThrowsInstanceOf(function () { dbg.addDebuggee(val); }, TypeError);
     assertThrowsInstanceOf(function () { dbg.removeDebuggee(val); }, TypeError);
 }
 
 // Primitive values are invalid.
 check(undefined);
 check(null);
 check(false);
 check(1);
 check(NaN);
 check("ok");
 
-// A Debug.Object that belongs to a different Debug object is invalid.
+// A Debugger.Object that belongs to a different Debugger object is invalid.
 var g = newGlobal('new-compartment');
-var dbg2 = new Debug;
+var dbg2 = new Debugger;
 var w = dbg2.addDebuggee(g);
-assertEq(w instanceof Debug.Object, true);
+assertEq(w instanceof Debugger.Object, true);
 check(w);
rename from js/src/jit-test/tests/debug/Debug-debuggees-07.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-07.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-07.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-07.js
@@ -1,13 +1,13 @@
 // Handle proto-less objects passed to addDebuggee.
 
 var g = newGlobal('new-compartment');
 var obj = g.eval("Object.create(null)");
-var dbg = new Debug;
+var dbg = new Debugger;
 
 // hasDebuggee and removeDebuggee must tolerate proto-less objects.
 assertEq(dbg.hasDebuggee(obj), false);
 
 // addDebuggee may either succeed or throw a TypeError. Don't care.
 var added;
 try {
     dbg.addDebuggee(obj);
rename from js/src/jit-test/tests/debug/Debug-debuggees-08.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-08.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-08.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-08.js
@@ -1,15 +1,15 @@
 // addDebuggee(obj), where obj is not global, adds obj's global.
 // Adding a debuggee more than once is redundant.
 
-var dbg = new Debug;
+var dbg = new Debugger;
 var g = newGlobal('new-compartment');
 var w = dbg.addDebuggee(g);
-assertEq(w instanceof Debug.Object, true);
+assertEq(w instanceof Debugger.Object, true);
 
 function usual() {
     assertEq(dbg.hasDebuggee(g), true);
     assertEq(dbg.hasDebuggee(w), true);
     var arr = dbg.getDebuggees();
     assertEq(arr.length, 1);
     assertEq(arr[0], w);
 }
@@ -19,19 +19,19 @@ assertEq(dbg.addDebuggee(g), w);
 usual();
 assertEq(dbg.addDebuggee(w), w);
 usual();
 dbg.addDebuggee(g.Math);
 usual();
 dbg.addDebuggee(g.eval("(function () {})"));
 usual();
 
-// w2 is a Debug.Object in g. Treat it like any other object in g; don't auto-unwrap it.
+// w2 is a Debugger.Object in g. Treat it like any other object in g; don't auto-unwrap it.
 g.g2 = newGlobal('new-compartment');
-g.eval("var w2 = new Debug().addDebuggee(g2)");
+g.eval("var w2 = new Debugger().addDebuggee(g2)");
 dbg.addDebuggee(g.w2);
 usual();
 assertEq(!dbg.hasDebuggee(g.g2), true);
 assertEq(dbg.hasDebuggee(g.w2), true);
 
 // Removing the debuggee once is enough.
 assertEq(dbg.removeDebuggee(g), undefined);
 assertEq(dbg.hasDebuggee(g), false);
rename from js/src/jit-test/tests/debug/Debug-debuggees-09.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-09.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-09.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-09.js
@@ -1,13 +1,13 @@
 // |jit-test| debug
 // Random objects can be the argument to hasDebuggee and removeDebuggee.
 // If hasDebuggee(x) is false, removeDebuggee(x) does nothing.
 
-var dbg = new Debug;
+var dbg = new Debugger;
 
 function check(obj) {
     // If obj is something we could never debug, hasDebuggee(obj) is false.
     assertEq(dbg.hasDebuggee(obj), false);
 
     // If hasDebuggee(x) is false, removeDebuggee(x) does nothing.
     assertEq(dbg.removeDebuggee(obj), undefined);
 }
@@ -17,11 +17,11 @@ check(this);
 check({});
 var g1 = newGlobal('same-compartment');
 check(g1);
 check(g1.eval("({})"));
 
 // objects in a compartment that is already debugging us
 var g2 = newGlobal('new-compartment');
 g2.parent = this;
-g2.eval("var dbg = new Debug(parent);");
+g2.eval("var dbg = new Debugger(parent);");
 check(g2);
 check(g2.dbg);
rename from js/src/jit-test/tests/debug/Debug-debuggees-10.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-10.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-10.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-10.js
@@ -1,17 +1,17 @@
 // Allow diamonds in the graph of the compartment "debugs" relation.
 var program = newGlobal('new-compartment');
 var d1 = newGlobal('new-compartment');
 d1.top = this;
 var d2 = newGlobal('new-compartment');
 d2.top = this;
-var dbg = new Debug(d1, d2);
-d1.eval("var dbg = new Debug(top.program)");
-d2.eval("var dbg = new Debug(top.program)");
+var dbg = new Debugger(d1, d2);
+d1.eval("var dbg = new Debugger(top.program)");
+d2.eval("var dbg = new Debugger(top.program)");
 
 // mess with the edges a little bit -- all this should be fine, no cycles
 d1.dbg.removeDebuggee(program);
 d1.dbg.addDebuggee(program);
 dbg.addDebuggee(program);
 d1.dbg.addDebuggee(d2);
 dbg.removeDebuggee(d2);
 dbg.addDebuggee(d2);
rename from js/src/jit-test/tests/debug/Debug-debuggees-11.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-11.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-11.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-11.js
@@ -1,26 +1,26 @@
 // |jit-test| debug
 // Don't allow cycles in the graph of the compartment "debugs" relation.
 
 load(libdir + "asserts.js");
 
 // trivial cycles
-var dbg = new Debug;
+var dbg = new Debugger;
 assertThrowsInstanceOf(function () { dbg.addDebuggee(this); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(this); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(this); }, TypeError);
 var g = newGlobal('same-compartment');
 assertThrowsInstanceOf(function () { dbg.addDebuggee(g); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(g); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(g); }, TypeError);
 
 // cycles of length 2
 var d1 = newGlobal('new-compartment');
 d1.top = this;
-d1.eval("var dbg = new Debug(top)");
+d1.eval("var dbg = new Debugger(top)");
 assertThrowsInstanceOf(function () { dbg.addDebuggee(d1); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(d1); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(d1); }, TypeError);
 
 // cycles of length 3
 var d2 = newGlobal('new-compartment');
 d2.top = this;
-d2.eval("var dbg = new Debug(top.d1)");
+d2.eval("var dbg = new Debugger(top.d1)");
 assertThrowsInstanceOf(function () { dbg.addDebuggee(d2); }, TypeError);
-assertThrowsInstanceOf(function () { new Debug(d2); }, TypeError);
+assertThrowsInstanceOf(function () { new Debugger(d2); }, TypeError);
rename from js/src/jit-test/tests/debug/Debug-debuggees-12.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-12.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-12.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-12.js
@@ -1,10 +1,10 @@
 // Events in a non-debuggee are ignored, even if a debuggee is in the same compartment.
 var g1 = newGlobal('new-compartment');
 var g2 = g1.eval("newGlobal('same-compartment')");
-var dbg = new Debug(g1);
+var dbg = new Debugger(g1);
 var hits = 0;
 dbg.hooks = {debuggerHandler: function () { hits++; }};
 g1.eval("debugger;");
 assertEq(hits, 1);
 g2.eval("debugger;");
 assertEq(hits, 1);
rename from js/src/jit-test/tests/debug/Debug-debuggees-13.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-13.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-13.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-13.js
@@ -1,9 +1,9 @@
 // Removing a debuggee does not detach the debugger from a compartment if another debuggee is in it.
 var g1 = newGlobal('new-compartment');
 var g2 = g1.eval("newGlobal('same-compartment')");
-var dbg = new Debug(g1, g2);
+var dbg = new Debugger(g1, g2);
 var hits = 0;
 dbg.hooks = {debuggerHandler: function (frame) { hits++; }};
 dbg.removeDebuggee(g1);
 g2.eval("debugger;");
 assertEq(hits, 1);
rename from js/src/jit-test/tests/debug/Debug-debuggees-14.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-14.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-14.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-14.js
@@ -1,7 +1,7 @@
 // Adding a debuggee in a compartment that is already in debug mode works
 // even if a script from that compartment is on the stack.
 var g = newGlobal('new-compartment');
-var dbg1 = Debug(g);
-var dbg2 = Debug();
+var dbg1 = Debugger(g);
+var dbg2 = Debugger();
 g.parent = this;
 g.eval("parent.dbg2.addDebuggee(this);");
rename from js/src/jit-test/tests/debug/Debug-debuggees-15.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-15.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-15.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-15.js
@@ -1,7 +1,7 @@
-// Debug mode can be disabled for a compartment even if it has scripts running.
+// Debugger mode can be disabled for a compartment even if it has scripts running.
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 g.parent = this;
 var n = 2;
 g.eval("parent.dbg.removeDebuggee(this); parent.n += 2");
 assertEq(n, 4);
rename from js/src/jit-test/tests/debug/Debug-debuggees-16.js
rename to js/src/jit-test/tests/debug/Debugger-debuggees-16.js
--- a/js/src/jit-test/tests/debug/Debug-debuggees-16.js
+++ b/js/src/jit-test/tests/debug/Debugger-debuggees-16.js
@@ -2,25 +2,25 @@
 
 var dbgs = [];
 var nonDebugGlobals = [];
 var f = gc;
 for (var i = 0; i < 4; i++) {
     // Create two globals, one debuggee.
     var g1 = newGlobal('new-compartment');
     var g2 = g1.eval("newGlobal('same-compartment')");
-    var dbg = Debug(g1);
+    var dbg = Debugger(g1);
     dbg.hooks = {debuggerHandler: function () {}};
 
     // Thread a chain of functions through the non-debuggee globals.
     g2.eval("function f() { return g() + 1; }");
     g2.g = f;
     f = g2.f;
 
-    // Root the Debug objects and non-debuggee globals.
+    // Root the Debugger objects and non-debuggee globals.
     dbgs[i] = dbg;
     nonDebugGlobals[i] = g2;
 }
 
 // Call the chain of functions. At the end of the chain is gc. This will
 // collect (some or all of) the debuggee globals, leaving non-debuggee
 // globals. It should disable debug mode in those debuggee compartments.
 nonDebugGlobals[nonDebugGlobals.length - 1].f();
rename from js/src/jit-test/tests/debug/Debug-enabled-01.js
rename to js/src/jit-test/tests/debug/Debugger-enabled-01.js
--- a/js/src/jit-test/tests/debug/Debug-enabled-01.js
+++ b/js/src/jit-test/tests/debug/Debugger-enabled-01.js
@@ -1,15 +1,15 @@
-var desc = Object.getOwnPropertyDescriptor(Debug.prototype, "enabled");
+var desc = Object.getOwnPropertyDescriptor(Debugger.prototype, "enabled");
 assertEq(typeof desc.get, 'function');
 assertEq(typeof desc.set, 'function');
 
 var g = newGlobal('new-compartment');
 var hits;
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 assertEq(dbg.enabled, true);
 dbg.hooks = {debuggerHandler: function () { hits++; }};
 
 var vals = [true, false, null, undefined, NaN, "blah", {}];
 for (var i = 0; i < vals.length; i++) {
     dbg.enabled = vals[i];
     assertEq(dbg.enabled, !!vals[i]);
     hits = 0;
rename from js/src/jit-test/tests/debug/Debug-getYoungestFrame-01.js
rename to js/src/jit-test/tests/debug/Debugger-getYoungestFrame-01.js
--- a/js/src/jit-test/tests/debug/Debug-getYoungestFrame-01.js
+++ b/js/src/jit-test/tests/debug/Debugger-getYoungestFrame-01.js
@@ -1,20 +1,20 @@
 // getYoungestFrame basics.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 assertEq(dbg.getYoungestFrame(), null);
 
 var global = this;
 var frame;
 function f() {
     frame = dbg.getYoungestFrame();
-    assertEq(frame instanceof Debug.Frame, true);
+    assertEq(frame instanceof Debugger.Frame, true);
     assertEq(frame.type, "eval");
     assertEq(frame.older, null);
 }
 g.h = this;
 g.eval("h.f()");
 assertEq(frame.live, false);
 assertThrowsInstanceOf(function () { frame.older; }, Error);
rename from js/src/jit-test/tests/debug/Debug-getYoungestFrame-02.js
rename to js/src/jit-test/tests/debug/Debugger-getYoungestFrame-02.js
--- a/js/src/jit-test/tests/debug/Debug-getYoungestFrame-02.js
+++ b/js/src/jit-test/tests/debug/Debugger-getYoungestFrame-02.js
@@ -1,12 +1,12 @@
-// Hooks and Debug.prototype.getYoungestFrame produce the same Frame object.
+// Hooks and Debugger.prototype.getYoungestFrame produce the same Frame object.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 var savedFrame, savedCallee;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame, savedFrame);
         assertEq(frame.live, true);
         assertEq(frame.callee, savedCallee);
         hits++;
rename from js/src/jit-test/tests/debug/Debug-multi-01.js
rename to js/src/jit-test/tests/debug/Debugger-multi-01.js
--- a/js/src/jit-test/tests/debug/Debug-multi-01.js
+++ b/js/src/jit-test/tests/debug/Debugger-multi-01.js
@@ -1,16 +1,16 @@
 // When there are multiple debuggers, their hooks are called in order.
 
 var g = newGlobal('new-compartment');
 var log;
 var arr = [];
 
 function addDebug(msg) {
-    var dbg = new Debug(g);
+    var dbg = new Debugger(g);
     dbg.hooks = {
         debuggerHandler: function (stack) {
             log += msg;
         }
     };
     arr.push(dbg);
 }
 
rename from js/src/jit-test/tests/debug/Debug-multi-02.js
rename to js/src/jit-test/tests/debug/Debugger-multi-02.js
--- a/js/src/jit-test/tests/debug/Debug-multi-02.js
+++ b/js/src/jit-test/tests/debug/Debugger-multi-02.js
@@ -1,27 +1,27 @@
 // Test adding hooks during dispatch. The behavior is deterministic and "nice",
 // but mainly what we are checking here is that we do not crash due to
 // modifying a data structure while we're iterating over it.
 
 var g = newGlobal('new-compartment');
 var n = 0;
 var hits;
 
-function addDebug() {
-    var dbg = new Debug(g);
+function addDebugger() {
+    var dbg = new Debugger(g);
     dbg.hooks = {
         debuggerHandler: function (stack) {
             hits++;
-            addDebug();
+            addDebugger();
         }
     };
 }
 
-addDebug();  // now there is one enabled Debug
+addDebugger();  // now there is one enabled Debugger
 hits = 0;
 g.eval("debugger;");  // after this there are two
 assertEq(hits, 1);
 
 hits = 0;
 g.eval("debugger;");  // after this there are four
 assertEq(hits, 2);
 
rename from js/src/jit-test/tests/debug/Debug-multi-03.js
rename to js/src/jit-test/tests/debug/Debugger-multi-03.js
--- a/js/src/jit-test/tests/debug/Debug-multi-03.js
+++ b/js/src/jit-test/tests/debug/Debugger-multi-03.js
@@ -3,17 +3,17 @@
 var log = '';
 
 function addDebug(g, id) {
     var debuggerGlobal = newGlobal('new-compartment');
     debuggerGlobal.debuggee = g;
     debuggerGlobal.id = id;
     debuggerGlobal.print = function (s) { log += s; };
     debuggerGlobal.eval(
-        'var dbg = new Debug(debuggee);\n' +
+        'var dbg = new Debugger(debuggee);\n' +
         'dbg.hooks = {\n' +
         '    debuggerHandler: function () { print(id); debugger; print(id); }\n' +
         '};\n');
     return debuggerGlobal;
 }
 
 var base = newGlobal('new-compartment');
 var top = base;
--- a/js/src/jit-test/tests/debug/Frame-01.js
+++ b/js/src/jit-test/tests/debug/Frame-01.js
@@ -1,16 +1,16 @@
 // Test .type and .generator fields of topmost stack frame passed to debuggerHandler.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var expected, hits;
 dbg.hooks = {
     debuggerHandler: function (f) {
-        assertEq(Object.getPrototypeOf(f), Debug.Frame.prototype);
+        assertEq(Object.getPrototypeOf(f), Debugger.Frame.prototype);
         assertEq(f.type, expected.type);
         assertEq(f.generator, expected.generator);
         assertEq(f.constructing, expected.constructing);
         hits++;
     }
 };
 
 function test(code, expectobj, expectedHits) {
--- a/js/src/jit-test/tests/debug/Frame-02.js
+++ b/js/src/jit-test/tests/debug/Frame-02.js
@@ -1,14 +1,14 @@
 // When the debugger is triggered twice from the same stack frame, the same
-// Debug.Frame object must be passed to the hook both times.
+// Debugger.Frame object must be passed to the hook both times.
 
 var g = newGlobal('new-compartment');
 var hits, frame;
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (f) {
         if (hits++ == 0)
             frame = f;
         else
             assertEq(f, frame);
     }
 };
--- a/js/src/jit-test/tests/debug/Frame-03.js
+++ b/js/src/jit-test/tests/debug/Frame-03.js
@@ -1,13 +1,13 @@
 // When the debugger is triggered from different stack frames that happen to
-// occupy the same memory, it must deliver different Debug.Frame objects.
+// occupy the same memory, it must deliver different Debugger.Frame objects.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits;
 var a = [];
 dbg.hooks = {
     debuggerHandler: function (frame) {
         for (var i = 0; i < a.length; i++) 
             assertEq(a[i] === frame, false);
         a.push(frame);
         hits++;
--- a/js/src/jit-test/tests/debug/Frame-arguments-01.js
+++ b/js/src/jit-test/tests/debug/Frame-arguments-01.js
@@ -1,13 +1,13 @@
 // Frame.prototype.arguments with primitive values
 
 var g = newGlobal('new-compartment');
 g.args = null;
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits;
 var v;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         hits++;
         var args = frame.arguments;
         assertEq(args instanceof Array, true);
         assertEq(Array.isArray(args), false);
--- a/js/src/jit-test/tests/debug/Frame-arguments-02.js
+++ b/js/src/jit-test/tests/debug/Frame-arguments-02.js
@@ -1,20 +1,20 @@
 // Object arguments.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var args = frame.arguments;
         assertEq(args, frame.arguments);
         assertEq(args instanceof Array, true);
         assertEq(args.length, 2);
-        assertEq(args[0] instanceof Debug.Object, true);
+        assertEq(args[0] instanceof Debugger.Object, true);
         assertEq(args[0].class, args[1]);
         hits++;
     }
 };
 
 g.eval("function f(obj, cls) { debugger; }");
 g.eval("f({}, 'Object');");
 g.eval("f(Date, 'Function');");
--- a/js/src/jit-test/tests/debug/Frame-arguments-03.js
+++ b/js/src/jit-test/tests/debug/Frame-arguments-03.js
@@ -1,35 +1,35 @@
 // Destructuring arguments.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var args = frame.arguments;
         assertEq(args[0], 1);
         assertEq(args.length, 4);
 
-        assertEq(args[1] instanceof Debug.Object, true);
+        assertEq(args[1] instanceof Debugger.Object, true);
         assertEq(args[1].class, "Array");
         var getprop = frame.eval("(function (p) { return this[p]; })").return;
-        assertEq(getprop instanceof Debug.Object, true);
+        assertEq(getprop instanceof Debugger.Object, true);
         assertEq(getprop.apply(args[1], ["length"]).return, 2);
         assertEq(getprop.apply(args[1], [0]).return, 2);
         assertEq(getprop.apply(args[1], [1]).return, 3);
 
-        assertEq(args[2] instanceof Debug.Object, true);
+        assertEq(args[2] instanceof Debugger.Object, true);
         assertEq(args[2].class, "Object");
         var x = getprop.apply(args[2], ["x"]).return;
         assertEq(x.class, "Array"); 
         assertEq(getprop.apply(x, ["0"]).return, 4);
         assertEq(getprop.apply(args[2], ["z"]).return, 5);
 
-        assertEq(args[3] instanceof Debug.Object, true);
+        assertEq(args[3] instanceof Debugger.Object, true);
         assertEq(args[3].class, "Object");
         assertEq(getprop.apply(args[3], ["q"]).return, 6);
         hits++;
     }
 };
 
 g.eval("function f(a, [b, c], {x: [y], z: w}, {q}) { debugger; }");
 g.eval("f(1, [2, 3], {x: [4], z: 5}, {q: 6});");
--- a/js/src/jit-test/tests/debug/Frame-arguments-04.js
+++ b/js/src/jit-test/tests/debug/Frame-arguments-04.js
@@ -1,12 +1,12 @@
 // frame.arguments works for all live frames
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         for (var i = 0; i <= 4; i++) {
             assertEq(frame.arguments.length, 1);
             assertEq(frame.arguments[0], i);
             frame = frame.older;
         }
--- a/js/src/jit-test/tests/debug/Frame-arguments-05.js
+++ b/js/src/jit-test/tests/debug/Frame-arguments-05.js
@@ -1,12 +1,12 @@
 // frame.arguments is "live" (it reflects assignments to arguments).
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var log = '';
 var args;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         if (args === undefined)
             args = frame.arguments;
         else
             assertEq(frame.arguments, args);
--- a/js/src/jit-test/tests/debug/Frame-arguments-06.js
+++ b/js/src/jit-test/tests/debug/Frame-arguments-06.js
@@ -1,15 +1,15 @@
 // Test extracting frame.arguments element getters and calling them in
 // various awkward ways.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 var fframe, farguments, fgetter;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         if (hits === 0) {
             fframe = frame;
             farguments = frame.arguments;
             fgetter = Object.getOwnPropertyDescriptor(farguments, "0").get;
--- a/js/src/jit-test/tests/debug/Frame-eval-01.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-01.js
@@ -1,8 +1,8 @@
-// simplest possible test of Debug.Frame.prototype.eval
+// simplest possible test of Debugger.Frame.prototype.eval
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var c;
 dbg.hooks = {debuggerHandler: function (frame) { c = frame.eval("2 + 2"); }};
 g.eval("debugger;");
 assertEq(c.return, 4);
--- a/js/src/jit-test/tests/debug/Frame-eval-02.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-02.js
@@ -1,10 +1,10 @@
 // frame.eval() throws if frame is not live
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var f;
 dbg.hooks = {debuggerHandler: function (frame) { f = frame; }};
 g.eval("debugger;");
 assertThrowsInstanceOf(function () { f.eval("2 + 2"); }, Error);
--- a/js/src/jit-test/tests/debug/Frame-eval-03.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-03.js
@@ -1,21 +1,21 @@
 // Test eval-ing names in a topmost script frame
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.eval("a").return, 2);
         assertEq(frame.eval("c").return, 4);
         var exc = frame.eval("d").throw;
-        assertEq(exc instanceof Debug.Object, true);
+        assertEq(exc instanceof Debugger.Object, true);
         assertEq(exc.proto, frame.eval("ReferenceError.prototype").return);
         hits++;
     }
 };
 g.eval("function f(a, b) { var c = a + b; debugger; eval('debugger;'); }");
 g.eval("f(2, 2);");
 g.eval("var a = 2, b = 2, c = a + b; debugger;");
 assertEq(hits, 3);
--- a/js/src/jit-test/tests/debug/Frame-eval-04.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-04.js
@@ -1,12 +1,12 @@
 // frame.eval SyntaxErrors are reflected, not thrown
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var exc, SEp;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         exc = frame.eval("#$@!").throw;
         SEp = frame.eval("SyntaxError.prototype").return;
     }
 };
 g.eval("debugger;");
--- a/js/src/jit-test/tests/debug/Frame-eval-05.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-05.js
@@ -1,12 +1,12 @@
 // var declarations in strict frame.eval do not modify the frame
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var cv;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         cv = frame.eval("'use strict'; var a = 2; h();");
     }
 };
 g.a = 1;
 g.eval("function f(s) { function h() { return a; } eval(s); debugger; } ");
--- a/js/src/jit-test/tests/debug/Frame-eval-06.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-06.js
@@ -1,16 +1,16 @@
 // frame.eval throws if frame is a generator frame that isn't currently on the stack
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
 g.eval("function gen(a) { debugger; yield a; }");
 g.eval("function test() { debugger; }");
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var genframe;
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         if (frame.callee.name == 'gen')
             genframe = frame;
         else
             assertThrowsInstanceOf(function () { genframe.eval("a"); }, Error);
--- a/js/src/jit-test/tests/debug/Frame-eval-07.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-07.js
@@ -1,14 +1,14 @@
 // test frame.eval in non-top frames
 
 var g = newGlobal('new-compartment');
 var N = g.N = 12; // must be even
 assertEq(N % 2, 0);
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var n = frame.eval("n").return;
         if (n === 0) {
             for (var i = 0; i <= N; i++) {
                 assertEq(frame.type, 'call');
                 assertEq(frame.callee.name, i % 2 === 0 ? 'even' : 'odd');
--- a/js/src/jit-test/tests/debug/Frame-eval-08.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-08.js
@@ -1,12 +1,12 @@
 // The arguments can escape from a function via a debugging hook.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 
 // capture arguments object and test function
 var args, testfn;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         args = frame.eval("arguments").return;
         testfn = frame.eval("test").return;
     }
--- a/js/src/jit-test/tests/debug/Frame-eval-09.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-09.js
@@ -1,12 +1,12 @@
 // assigning to local variables in frame.eval code
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         frame.eval("outerarg = 1; outervar = 2; innerarg = 3; innervar = 4;");
     }
 };
 
 var result = g.eval("(" + function outer(outerarg) {
         var outervar = 200;
--- a/js/src/jit-test/tests/debug/Frame-eval-10.js
+++ b/js/src/jit-test/tests/debug/Frame-eval-10.js
@@ -1,11 +1,11 @@
 // frame.eval returns null if the eval code fails with an uncatchable error.
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         if (hits++ === 0)
             assertEq(frame.eval("debugger;"), null);
         else
             return null;
     }
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-01.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-01.js
@@ -1,12 +1,12 @@
 // evalWithBindings basics
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.evalWithBindings("x", {x: 2}).return, 2);
         assertEq(frame.evalWithBindings("x + y", {x: 2}).return, 5);
         hits++;
     }
 };
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-02.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-02.js
@@ -1,11 +1,11 @@
 // evalWithBindings to call a method of a debuggee object
 var g = newGlobal('new-compartment');
-var dbg = new Debug;
+var dbg = new Debugger;
 var global = dbg.addDebuggee(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var obj = frame.arguments[0];
         var expected = frame.arguments[1];
         assertEq(frame.evalWithBindings("obj.toString()", {obj: obj}).return, expected);
         hits++;
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-03.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-03.js
@@ -1,11 +1,11 @@
 // arguments works in evalWithBindings (it does not interpose a function scope)
 var g = newGlobal('new-compartment');
-var dbg = new Debug;
+var dbg = new Debugger;
 var global = dbg.addDebuggee(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var argc = frame.arguments.length;
         assertEq(argc, 7);
         assertEq(frame.evalWithBindings("arguments[prop]", {prop: "length"}).return, argc);
         for (var i = 0; i < argc; i++)
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-04.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-04.js
@@ -1,11 +1,11 @@
 // evalWithBindings works on non-top frames.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var f1;
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.older.evalWithBindings("q + r", {r: 3}).return, 5);
 
         // frame.older.older is in the same function as frame, but a different activation of it
         assertEq(frame.older.older.evalWithBindings("q + r", {r: 3}).return, 6);
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-05.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-05.js
@@ -1,11 +1,11 @@
 // evalWithBindings code can assign to the bindings.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.evalWithBindings("for (i = 0; i < 5; i++) {}  i;", {i: 10}).return, 5);
         hits++;
     }
 };
 
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-06.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-06.js
@@ -1,11 +1,11 @@
 // In evalWithBindings code, assignment to any name not in the bindings works just as in eval.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.evalWithBindings("y = z; x = w;", {z: 2, w: 3}).return, 3);
     }
 };
 g.eval("function f(x) { debugger; assertEq(x, 3); }");
 g.eval("var y = 0; f(0);");
 assertEq(g.y, 2);
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-07.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-07.js
@@ -1,11 +1,11 @@
 // var statements in strict evalWithBindings code behave like strict eval.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.evalWithBindings("var i = a*a + b*b; i === 25;", {a: 3, b: 4}).return, true);
         hits++;
     }
 };
 g.eval("'use strict'; debugger;");
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-08.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-08.js
@@ -1,11 +1,11 @@
 // evalWithBindings ignores non-enumerable and non-own properties.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.evalWithBindings("toString + constructor + length", []).return, 112233);
         var obj = Object.create({constructor: "FAIL"}, {length: {value: "fail"}});
         assertEq(frame.evalWithBindings("toString + constructor + length", obj).return, 112233);
         hits++;
     }
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-09.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-09.js
@@ -1,11 +1,11 @@
 // evalWithBindings code is debuggee code, so it can trip the debugger. It nests!
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var f1;
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         f1 = frame;
 
         // This trips the throw hook.
         var x = frame.evalWithBindings("wrongSpeling", {rightSpelling: 2}).throw;
--- a/js/src/jit-test/tests/debug/Frame-evalWithBindings-10.js
+++ b/js/src/jit-test/tests/debug/Frame-evalWithBindings-10.js
@@ -1,11 +1,11 @@
 // Direct eval code under evalWithbindings sees both the bindings and the enclosing scope.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var code =
             "assertEq(a, 1234);\n" +
             "assertEq(b, null);\n" +
             "assertEq(c, 'ok');\n";
         assertEq(frame.evalWithBindings("eval(s)", {s: code, a: 1234}).return, undefined);
--- a/js/src/jit-test/tests/debug/Frame-identity-01.js
+++ b/js/src/jit-test/tests/debug/Frame-identity-01.js
@@ -1,15 +1,15 @@
 // |jit-test| debug
 // Check that {return:} resumption kills the current stack frame.
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("(" + function () {
-        var dbg = new Debug(debuggeeGlobal);
+        var dbg = new Debugger(debuggeeGlobal);
         var prev = null;
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 assertEq(frame === prev, false);
                 if (prev)
                     assertEq(prev.live, false);
                 prev = frame;
                 return {return: frame.arguments[0]};
--- a/js/src/jit-test/tests/debug/Frame-identity-02.js
+++ b/js/src/jit-test/tests/debug/Frame-identity-02.js
@@ -1,17 +1,17 @@
 // |jit-test| debug
 // Check that {throw:} resumption kills the current stack frame.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("(" + function () {
-        var dbg = new Debug(debuggeeGlobal);
+        var dbg = new Debugger(debuggeeGlobal);
         var prev = null;
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 assertEq(frame === prev, false);
                 if (prev)
                     assertEq(prev.live, false);
                 prev = frame;
                 return {throw: debuggeeGlobal.i};
--- a/js/src/jit-test/tests/debug/Frame-identity-03.js
+++ b/js/src/jit-test/tests/debug/Frame-identity-03.js
@@ -1,19 +1,19 @@
 // |jit-test| debug
-// Test that we create new Debug.Frames and reuse old ones correctly with recursion.
+// Test that we create new Debugger.Frames and reuse old ones correctly with recursion.
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("(" + function () {
         function id(f) {
             return ("id" in f) ? f.id : (f.id = nextid++);
         }
 
-        var dbg = new Debug(debuggeeGlobal);
+        var dbg = new Debugger(debuggeeGlobal);
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 var a = [];
                 for (; frame; frame = frame.older)
                     a.push(frame);
                 var s = '';
                 while (a.length)
                     s += id(a.pop());
--- a/js/src/jit-test/tests/debug/Frame-identity-04.js
+++ b/js/src/jit-test/tests/debug/Frame-identity-04.js
@@ -1,14 +1,14 @@
-// Test that on-stack Debug.Frames are not GC'd even if they are only reachable
-// from the js::Debug::frames table.
+// Test that on-stack Debugger.Frames are not GC'd even if they are only reachable
+// from the js::Debugger::frames table.
 
 var g = newGlobal('new-compartment');
 g.eval("function f(n) { if (n) f(n - 1); debugger; }");
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         if (hits === 0) {
             for (; frame; frame = frame.older)
                 frame.seen = true;
         } else {
             for (; frame; frame = frame.older)
--- a/js/src/jit-test/tests/debug/Frame-live-01.js
+++ b/js/src/jit-test/tests/debug/Frame-live-01.js
@@ -1,26 +1,26 @@
 // |jit-test| debug
-// Debug.Frame.prototype.live is true for frames on the stack and false for
+// Debugger.Frame.prototype.live is true for frames on the stack and false for
 // frames that have returned
 
-var desc = Object.getOwnPropertyDescriptor(Debug.Frame.prototype, "live");
+var desc = Object.getOwnPropertyDescriptor(Debugger.Frame.prototype, "live");
 assertEq(typeof desc.get, "function");
 assertEq(desc.set, undefined);
 assertEq(desc.configurable, true);
 assertEq(desc.enumerable, false);
 
 var loc;
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("var hits = 0;");
 g.eval("(" + function () {
         var a = [];
-        var dbg = Debug(debuggeeGlobal);
+        var dbg = Debugger(debuggeeGlobal);
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 var loc = debuggeeGlobal.loc;
                 a[loc] = frame;
                 for (var i = 0; i < a.length; i++) {
                     assertEq(a[i] === frame, i === loc);
                     assertEq(!!(a[i] && a[i].live), i >= loc);
                 }
--- a/js/src/jit-test/tests/debug/Frame-live-02.js
+++ b/js/src/jit-test/tests/debug/Frame-live-02.js
@@ -1,19 +1,19 @@
 // |jit-test| debug
-// Debug.Frame.prototype.live is false for frames that have thrown or been thrown through
+// Debugger.Frame.prototype.live is false for frames that have thrown or been thrown through
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("var finalCheck;");
 g.eval("(" + function () {
         var a = [];
-        var dbg = Debug(debuggeeGlobal);
+        var dbg = Debugger(debuggeeGlobal);
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 a.push(frame);
                 for (var i = 0; i < a.length; i++)
                     assertEq(a[i].live, true);
             }
         };
         finalCheck = function (n) {
--- a/js/src/jit-test/tests/debug/Frame-live-03.js
+++ b/js/src/jit-test/tests/debug/Frame-live-03.js
@@ -1,22 +1,22 @@
 // |jit-test| debug
 // frame properties throw if !frame.live
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
 var f;
-Debug(g).hooks = {
+Debugger(g).hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.live, true);
         assertEq(frame.type, "call");
         assertEq(frame.this instanceof Object, true);
-        assertEq(frame.older instanceof Debug.Frame, true);
-        assertEq(frame.callee instanceof Debug.Object, true);
+        assertEq(frame.older instanceof Debugger.Frame, true);
+        assertEq(frame.callee instanceof Debugger.Object, true);
         assertEq(frame.generator, false);
         assertEq(frame.constructing, false);
         assertEq(frame.arguments.length, 0);
         f = frame;
     }
 };
 
 g.eval("(function () { debugger; }).call({});");
--- a/js/src/jit-test/tests/debug/Frame-live-04.js
+++ b/js/src/jit-test/tests/debug/Frame-live-04.js
@@ -1,11 +1,11 @@
 // Frame.live is false for frames discarded during uncatchable error unwinding.
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 var snapshot;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var stack = [];
         for (var f = frame; f; f = f.older) {
             if (f.type === "call")
                 stack.push(f);
--- a/js/src/jit-test/tests/debug/Frame-offset-01.js
+++ b/js/src/jit-test/tests/debug/Frame-offset-01.js
@@ -1,11 +1,11 @@
 // frame.offset throws if !frame.live.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var f;
 dbg.hooks = {debuggerHandler: function (frame) { f = frame; }};
 g.eval("debugger;");
 assertEq(f.live, false);
 assertThrowsInstanceOf(function () { f.offset; }, Error);
--- a/js/src/jit-test/tests/debug/Frame-offset-02.js
+++ b/js/src/jit-test/tests/debug/Frame-offset-02.js
@@ -1,12 +1,12 @@
 // frame.offset gives different values at different points in a script.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var s = undefined, a = []
 dbg.hooks = {
     debuggerHandler: function (frame) {
         if (s === undefined)
             s = frame.script;
         else
             assertEq(s, frame.script);
         assertEq(frame.offset !== undefined, true);
--- a/js/src/jit-test/tests/debug/Frame-older-01.js
+++ b/js/src/jit-test/tests/debug/Frame-older-01.js
@@ -1,14 +1,14 @@
 // |jit-test| debug
 // Basic call chain.
 
 var g = newGlobal('new-compartment');
 var result = null;
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var a = [];
         assertEq(frame === frame.older, false);
         for (; frame; frame = frame.older)
             a.push(frame.type === 'call' ? frame.callee.name : frame.type);
         a.reverse();
         result = a.join(", ");
--- a/js/src/jit-test/tests/debug/Frame-script-01.js
+++ b/js/src/jit-test/tests/debug/Frame-script-01.js
@@ -1,13 +1,13 @@
 // |jit-test| debug
 // Frame.prototype.script for eval frames.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 
 // Apply |f| to each frame that is |skip| frames up from each frame that
 // executes a 'debugger' statement when evaluating |code| in the global g.
 function ApplyToFrameScript(code, skip, f) {
     dbg.hooks = {
         debuggerHandler: function (frame) {
             while (skip-- > 0)
                 frame = frame.older;
@@ -17,20 +17,20 @@ function ApplyToFrameScript(code, skip, 
     };
     g.eval(code);
 }
 
 var savedScript;
 
 ApplyToFrameScript('debugger;', 0,
                    function (script) {
-                       assertEq(script instanceof Debug.Script, true);
+                       assertEq(script instanceof Debugger.Script, true);
                        assertEq(script.live, true);
                        savedScript = script;
                    });
 assertEq(savedScript.live, false);
 ApplyToFrameScript("(function () { eval('debugger;'); })();", 0,
                    function (script) {
-                       assertEq(script instanceof Debug.Script, true);
+                       assertEq(script instanceof Debugger.Script, true);
                        assertEq(script.live, true);
                        savedScript = script;
                    });
 assertEq(savedScript.live, false);
--- a/js/src/jit-test/tests/debug/Frame-script-02.js
+++ b/js/src/jit-test/tests/debug/Frame-script-02.js
@@ -1,13 +1,13 @@
 // |jit-test| debug
 // Frame.prototype.script for call frames.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 
 // Apply |f| to each frame that is |skip| frames up from each frame that
 // executes a 'debugger' statement when evaluating |code| in the global g.
 function ApplyToFrameScript(code, skip, f) {
     dbg.hooks = {
         debuggerHandler: function (frame) {
             while (skip-- > 0)
                 frame = frame.older;
@@ -17,17 +17,17 @@ function ApplyToFrameScript(code, skip, 
     };
     g.eval(code);
 }
 
 var savedScript;
 
 ApplyToFrameScript('(function () { debugger; })();', 0,
                    function (script) {
-                       assertEq(script instanceof Debug.Script, true);
+                       assertEq(script instanceof Debugger.Script, true);
                        assertEq(script.live, true);
                        savedScript = script;
                    });
 assertEq(savedScript.live, true);
 
 // This would be nice, once we can get host call frames:
 // ApplyToFrameScript("(function () { debugger; }).call(null);", 1,
 //                    function (script) {
--- a/js/src/jit-test/tests/debug/Frame-this-01.js
+++ b/js/src/jit-test/tests/debug/Frame-this-01.js
@@ -1,12 +1,12 @@
 // Frame.prototype.this in strict-mode functions, with primitive values
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         hits++;
         assertEq(frame.this, g.v);
     }
 };
 
--- a/js/src/jit-test/tests/debug/Frame-this-02.js
+++ b/js/src/jit-test/tests/debug/Frame-this-02.js
@@ -1,12 +1,12 @@
 // Frame.prototype.this in strict direct eval frames
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         hits++;
         assertEq(frame.this, g.v);
     }
 };
 
--- a/js/src/jit-test/tests/debug/Frame-this-03.js
+++ b/js/src/jit-test/tests/debug/Frame-this-03.js
@@ -1,21 +1,21 @@
 // Frame.prototype.this in non-strict-mode functions, with primitive values
 
 function classOf(obj) {
     return Object.prototype.toString.call(obj).match(/^\[object (.*)\]$/)[1];
 }
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         hits++;
-        assertEq(frame.this instanceof Debug.Object, true);
+        assertEq(frame.this instanceof Debugger.Object, true);
         assertEq(frame.this.class, g.v == null ? classOf(g) : classOf(Object(g.v)));
     }
 };
 
 g.eval("function f() { debugger; }");
 
 g.eval("Boolean.prototype.f = f; v = true; v.f();");
 g.eval("f.call(v);");
--- a/js/src/jit-test/tests/debug/Frame-this-04.js
+++ b/js/src/jit-test/tests/debug/Frame-this-04.js
@@ -1,21 +1,21 @@
-// Debug.Frame.prototype.this in functions, with object values
+// Debugger.Frame.prototype.this in functions, with object values
 
 function classOf(obj) {
     return Object.prototype.toString.call(obj).match(/^\[object (.*)\]$/)[1];
 }
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         hits++;
-        assertEq(frame.this instanceof Debug.Object, true);
+        assertEq(frame.this instanceof Debugger.Object, true);
         assertEq(frame.this.class, classOf(Object(g.v)));
     }
 };
 
 g.eval("function f() { debugger; }");
 
 g.eval("v = {}; f.call(v);");
 g.eval("v.f = f; v.f();");
--- a/js/src/jit-test/tests/debug/Object-01.js
+++ b/js/src/jit-test/tests/debug/Object-01.js
@@ -1,19 +1,19 @@
-// Debug.Object basics
+// Debugger.Object basics
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.arguments[0], frame.callee);
-        assertEq(Object.getPrototypeOf(frame.arguments[0]), Debug.Object.prototype);
-        assertEq(frame.arguments[0] instanceof Debug.Object, true);
+        assertEq(Object.getPrototypeOf(frame.arguments[0]), Debugger.Object.prototype);
+        assertEq(frame.arguments[0] instanceof Debugger.Object, true);
         assertEq(frame.arguments[0] !== frame.arguments[1], true);
-        assertEq(Object.getPrototypeOf(frame.arguments[1]), Debug.Object.prototype);
-        assertEq(frame.arguments[1] instanceof Debug.Object, true);
+        assertEq(Object.getPrototypeOf(frame.arguments[1]), Debugger.Object.prototype);
+        assertEq(frame.arguments[1] instanceof Debugger.Object, true);
         hits++;
     }
 };
 
 g.eval("var obj = {}; function f(a, b) { debugger; } f(f, obj);");
 assertEq(hits, 1);
--- a/js/src/jit-test/tests/debug/Object-02.js
+++ b/js/src/jit-test/tests/debug/Object-02.js
@@ -1,13 +1,13 @@
-// Debug.Object referents can be transparent wrappers of objects in the debugger compartment.
+// Debugger.Object referents can be transparent wrappers of objects in the debugger compartment.
 
 var g = newGlobal('new-compartment');
 g.f = function (a, b) { return a + "/" + b; };
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var f = frame.eval("f").return;
         assertEq(f.call(null, "a", "b").return, "a/b");
         hits++;
     }
 };
--- a/js/src/jit-test/tests/debug/Object-apply-01.js
+++ b/js/src/jit-test/tests/debug/Object-apply-01.js
@@ -1,15 +1,15 @@
-// tests calling script functions via Debug.Object.prototype.apply/call
+// tests calling script functions via Debugger.Object.prototype.apply/call
 
 load(libdir + "asserts.js");
 
 var g = newGlobal("new-compartment");
 g.eval("function f() { debugger; }");
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {debuggerHandler: function () {}};
 
 var hits = 0;
 function test(usingApply) {
     dbg.hooks.debuggerHandler = function (frame) {
         var fn = frame.arguments[0];
         var cv = usingApply ? fn.apply(null, [9, 16]) : fn.call(null, 9, 16);
         assertEq(Object.keys(cv).join(","), "return");
@@ -20,17 +20,17 @@ function test(usingApply) {
         assertEq(Object.keys(cv).join(","), "return");
         assertEq(cv.return, "hello world");
 
         // Handle more or less arguments.
         assertEq((usingApply ? fn.apply(null, [1, 5, 100]) : fn.call(null, 1, 5, 100)).return, 6);
         assertEq((usingApply ? fn.apply(null, []) : fn.call(null)).return, NaN);
         assertEq((usingApply ? fn.apply() : fn.call()).return, NaN);
 
-        // Throw if a this-value or argument is an object but not a Debug.Object.
+        // Throw if a this-value or argument is an object but not a Debugger.Object.
         assertThrowsInstanceOf(function () { usingApply ? fn.apply({}, []) : fn.call({}); },
                                TypeError);
         assertThrowsInstanceOf(function () { usingApply ? fn.apply(null, [{}]) : fn.call(null, {}); },
                                TypeError);
         hits++;
     };
     g.eval("f(function (a, b) { return a + b; });");
 
--- a/js/src/jit-test/tests/debug/Object-apply-02.js
+++ b/js/src/jit-test/tests/debug/Object-apply-02.js
@@ -1,15 +1,15 @@
-// tests calling native functions via Debug.Object.prototype.apply/call
+// tests calling native functions via Debugger.Object.prototype.apply/call
 
 load(libdir + "asserts.js");
 
 var g = newGlobal("new-compartment");
 g.eval("function f() { debugger; }");
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {debuggerHandler: function () {}};
 
 function test(usingApply) {
     dbg.hooks.debuggerHandler = function (frame) {
         var max = frame.arguments[0];
         var cv = usingApply ? max.apply(null, [9, 16]) : max.call(null, 9, 16);
         assertEq(cv.return, 16);
 
--- a/js/src/jit-test/tests/debug/Object-apply-03.js
+++ b/js/src/jit-test/tests/debug/Object-apply-03.js
@@ -1,12 +1,12 @@
 // reentering the debugger several times via debuggerHandler and apply/call on a single stack
 
 var g = newGlobal("new-compartment");
-var dbg = Debug(g);
+var dbg = Debugger(g);
 
 function test(usingApply) {
     dbg.hooks = {
         debuggerHandler: function (frame) {
             var n = frame.arguments[0];
             if (n > 1) {
                 var result = usingApply ? frame.callee.apply(null, [n - 1])
                                         : frame.callee.call(null, n - 1);
--- a/js/src/jit-test/tests/debug/Object-apply-04.js
+++ b/js/src/jit-test/tests/debug/Object-apply-04.js
@@ -1,13 +1,13 @@
-// Debug.Object.prototype.apply/call works with function proxies
+// Debugger.Object.prototype.apply/call works with function proxies
 
 var g = newGlobal('new-compartment');
 g.eval("function f() { debugger; }");
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var proxy = frame.arguments[0];
         assertEq(proxy.name, undefined);
         assertEq(proxy.apply(null, [33]).return, 34);
         assertEq(proxy.call(null, 33).return, 34);
         hits++;
--- a/js/src/jit-test/tests/debug/Object-callable.js
+++ b/js/src/jit-test/tests/debug/Object-callable.js
@@ -1,12 +1,12 @@
-// Test Debug.Object.prototype.callable.
+// Test Debugger.Object.prototype.callable.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.arguments[0].callable, frame.arguments[1]);
         hits++;
     }
 };
 
--- a/js/src/jit-test/tests/debug/Object-class.js
+++ b/js/src/jit-test/tests/debug/Object-class.js
@@ -1,11 +1,11 @@
-// Basic tests for Debug.Object.prototype.class.
+// Basic tests for Debugger.Object.prototype.class.
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var arr = frame.arguments;
         assertEq(arr[0].class, "Object");
         assertEq(arr[1].class, "Array");
         assertEq(arr[2].class, "Function");
         assertEq(arr[3].class, "Date");
--- a/js/src/jit-test/tests/debug/Object-gc-01.js
+++ b/js/src/jit-test/tests/debug/Object-gc-01.js
@@ -1,12 +1,12 @@
-// Debug.Objects keep their referents alive.
+// Debugger.Objects keep their referents alive.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var arr = [];
 dbg.hooks = {debuggerHandler: function (frame) { arr.push(frame.eval("[]").return); }};
 g.eval("for (var i = 0; i < 10; i++) debugger;");
 assertEq(arr.length, 10);
 
 gc();
 
 for (var i = 0; i < arr.length; i++)
--- a/js/src/jit-test/tests/debug/Object-identity-01.js
+++ b/js/src/jit-test/tests/debug/Object-identity-01.js
@@ -1,11 +1,11 @@
-// Two references to the same object get the same Debug.Object wrapper.
+// Two references to the same object get the same Debugger.Object wrapper.
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.arguments[0], frame.arguments[1]);
         hits++;
     }
 };
 g.eval("var obj = {}; function f(a, b) { debugger; } f(obj, obj);");
--- a/js/src/jit-test/tests/debug/Object-identity-02.js
+++ b/js/src/jit-test/tests/debug/Object-identity-02.js
@@ -1,11 +1,11 @@
-// Different objects get different Debug.Object wrappers.
+// Different objects get different Debugger.Object wrappers.
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.arguments[0] === frame.arguments[1], false);
         hits++;
     }
 };
 g.eval("function f(a, b) { debugger; } f({}, {});");
--- a/js/src/jit-test/tests/debug/Object-identity-03.js
+++ b/js/src/jit-test/tests/debug/Object-identity-03.js
@@ -1,14 +1,14 @@
-// The same object gets the same Debug.Object wrapper at different times, if the difference would be observable.
+// The same object gets the same Debugger.Object wrapper at different times, if the difference would be observable.
 
 var N = HOTLOOP + 4;
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var wrappers = [];
 
 dbg.hooks = {debuggerHandler: function (frame) { wrappers.push(frame.arguments[0]); }};
 g.eval("var originals = []; function f(x) { originals.push(x); debugger; }");
 for (var i = 0; i < N; i++)
     g.eval("f({});");
 assertEq(wrappers.length, N);
 
--- a/js/src/jit-test/tests/debug/Object-name-01.js
+++ b/js/src/jit-test/tests/debug/Object-name-01.js
@@ -1,12 +1,12 @@
-// Debug.Object.prototype.name
+// Debugger.Object.prototype.name
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var name;
 dbg.hooks = {debuggerHandler: function (frame) { name = frame.callee.name; }};
 
 g.eval("(function f() { debugger; })();");
 assertEq(name, "f");
 g.eval("(function () { debugger; })();");
 assertEq(name, undefined);
 g.eval("Function('debugger;')();");
--- a/js/src/jit-test/tests/debug/Object-name-02.js
+++ b/js/src/jit-test/tests/debug/Object-name-02.js
@@ -1,13 +1,13 @@
 // The .name of a non-function object is undefined.
 
 var g = newGlobal('new-compartment');
 var hits = 0;
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.arguments[0].name, undefined);
         hits++;
     }
 };
 g.eval("function f(nonfunction) { debugger; }");
 
--- a/js/src/jit-test/tests/debug/Object-parameterNames.js
+++ b/js/src/jit-test/tests/debug/Object-parameterNames.js
@@ -1,12 +1,12 @@
 load(libdir + 'array-compare.js');
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var arr = frame.arguments;
         assertEq(arraysEqual(arr[0].parameterNames, []), true);
         assertEq(arraysEqual(arr[1].parameterNames, ["x"]), true);
         assertEq(arraysEqual(arr[2].parameterNames,
                              ["a","b","c","d","e","f","g","h","i","j","k","l","m",
--- a/js/src/jit-test/tests/debug/Object-proto.js
+++ b/js/src/jit-test/tests/debug/Object-proto.js
@@ -1,12 +1,12 @@
-// Debug.Object.prototype.proto
+// Debugger.Object.prototype.proto
 var g = newGlobal('new-compartment');
 var dbgeval = function () {
-        var dbg = new Debug(g);
+        var dbg = new Debugger(g);
         var hits = 0;
         g.eval("function f() { debugger; }");
         var lastval;
         dbg.hooks = {debuggerHandler: function (frame) { lastval = frame.arguments[0]; }};
         return function dbgeval(s) {
             g.eval("f(" + s + ");");
             return lastval;
         };
--- a/js/src/jit-test/tests/debug/Object-script.js
+++ b/js/src/jit-test/tests/debug/Object-script.js
@@ -1,17 +1,17 @@
 // |jit-test| debug
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var arr = frame.arguments;
-        assertEq(arr[0].script instanceof Debug.Script, true);
+        assertEq(arr[0].script instanceof Debugger.Script, true);
         assertEq(arr[1].script, undefined);
         assertEq(arr[2].script, undefined);
         hits++;
     }
 };
 
 g.eval("(function () { debugger; })(function g(){}, {}, Math.atan2);");
 assertEq(hits, 1);
--- a/js/src/jit-test/tests/debug/Script-01.js
+++ b/js/src/jit-test/tests/debug/Script-01.js
@@ -1,16 +1,16 @@
 // |jit-test| debug
-// We get the same Debug.Script object instance each time we ask.
+// We get the same Debugger.Script object instance each time we ask.
 
 var global = newGlobal('new-compartment');
 global.eval('function f() { debugger; }');
 global.eval('function g() { debugger; }');
 
-var debug = new Debug(global);
+var debug = new Debugger(global);
 
 function evalAndNoteScripts(prog) {
     var scripts = {};
     debug.hooks = {
         debuggerHandler: function(frame) {
             if (frame.type == "call")
                 assertEq(frame.script, frame.callee.script);
             scripts.frame = frame.script;
@@ -18,27 +18,27 @@ function evalAndNoteScripts(prog) {
                 scripts.argument = frame.arguments[0].script;
         }
     };
     global.eval(prog);
     return scripts;
 }
 
 // If we create a frame for a function and pass it as a value, those should
-// both yield the same Debug.Script instance.
+// both yield the same Debugger.Script instance.
 var scripts = evalAndNoteScripts('f(f)');
 assertEq(scripts.frame, scripts.argument);
 var fScript = scripts.argument;
 
 // If we call a second time, we should still get the same instance.
 scripts = evalAndNoteScripts('f(f)');
 assertEq(scripts.frame, fScript);
 assertEq(scripts.argument, fScript);
 
-// If we call with a different argument, we should get a different Debug.Script.
+// If we call with a different argument, we should get a different Debugger.Script.
 scripts = evalAndNoteScripts('f(g)');
 assertEq(scripts.frame !== scripts.argument, true);
 assertEq(scripts.frame, fScript);
 var gScript = scripts.argument;
 
 // See if we can get g via the frame.
 scripts = evalAndNoteScripts('g(f)');
 assertEq(scripts.frame !== scripts.argument, true);
--- a/js/src/jit-test/tests/debug/Script-02.js
+++ b/js/src/jit-test/tests/debug/Script-02.js
@@ -1,7 +1,7 @@
 // |jit-test| debug
-// Debug.Script throws when applied as a constructor.
+// Debugger.Script throws when applied as a constructor.
 
 load(libdir + 'asserts.js');
 
-assertThrowsInstanceOf(function() { Debug.Script(); }, TypeError);
-assertThrowsInstanceOf(function() { new Debug.Script(); }, TypeError);
+assertThrowsInstanceOf(function() { Debugger.Script(); }, TypeError);
+assertThrowsInstanceOf(function() { new Debugger.Script(); }, TypeError);
--- a/js/src/jit-test/tests/debug/Script-clearBreakpoint-01.js
+++ b/js/src/jit-test/tests/debug/Script-clearBreakpoint-01.js
@@ -1,14 +1,14 @@
 // A breakpoint handler may clear itself.
 
 var g = newGlobal('new-compartment');
 var bphits = 0;
 var handler = {hit: function (frame) { frame.script.clearBreakpoint(this); bphits++; }};
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var offs = frame.script.getLineOffsets(g.line0 + 3);
         for (var i = 0; i < offs.length; i++)
             frame.script.setBreakpoint(offs[i], handler);
         hits++;
     }
--- a/js/src/jit-test/tests/debug/Script-clearBreakpoint-02.js
+++ b/js/src/jit-test/tests/debug/Script-clearBreakpoint-02.js
@@ -1,13 +1,13 @@
 // A breakpoint cleared during dispatch does not fire.
 // (Breakpoint dispatch is well-behaved even when breakpoint handlers clear other breakpoints.)
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var log = '';
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var s = frame.script;
         function handler(i) {
             if (i === 1)
                 return function () { log += i; s.clearBreakpoint(h[1]); s.clearBreakpoint(h[2]); };
             return function () { log += i; };
--- a/js/src/jit-test/tests/debug/Script-clearBreakpoint-03.js
+++ b/js/src/jit-test/tests/debug/Script-clearBreakpoint-03.js
@@ -1,12 +1,12 @@
 // Clearing a breakpoint by handler can clear multiple breakpoints.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var s;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         s = frame.eval("f").return.script;
     }
 };
 g.eval("var line0 = Error().lineNumber;\n" +
        "function f(a, b) {\n" +     // line0 + 1
--- a/js/src/jit-test/tests/debug/Script-clearBreakpoint-04.js
+++ b/js/src/jit-test/tests/debug/Script-clearBreakpoint-04.js
@@ -1,22 +1,22 @@
-// clearBreakpoint clears breakpoints for the current Debug object only.
+// clearBreakpoint clears breakpoints for the current Debugger object only.
 
 var g = newGlobal('new-compartment');
 
 var hits = 0;
 var handler = {
     hit: function (frame) {
         hits++;
         frame.script.clearBreakpoint(handler);
     }
 };
 
 function attach(i) {
-    var dbg = Debug(g);
+    var dbg = Debugger(g);
     dbg.hooks = {
         debuggerHandler: function (frame) {
             var s = frame.script;
             var offs = s.getLineOffsets(g.line0 + 2);
             for (var i = 0; i < offs.length; i++)
                 s.setBreakpoint(offs[i], handler);
         }
     };
--- a/js/src/jit-test/tests/debug/Script-gc-01.js
+++ b/js/src/jit-test/tests/debug/Script-gc-01.js
@@ -1,18 +1,18 @@
 // |jit-test| debug
-// Debug.Script instances with live referents stay alive.
+// Debugger.Script instances with live referents stay alive.
 
 var N = 4;
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var i;
 dbg.hooks = {
     debuggerHandler: function (frame) {
-        assertEq(frame.script instanceof Debug.Script, true);
+        assertEq(frame.script instanceof Debugger.Script, true);
         frame.script.id = i;
     }
 };
 
 g.eval('var arr = [];')
 for (i = 0; i < N; i++)  // loop to defeat conservative GC
     g.eval("arr.push(function () { debugger }); arr[arr.length - 1]();");
 
--- a/js/src/jit-test/tests/debug/Script-gc-02.js
+++ b/js/src/jit-test/tests/debug/Script-gc-02.js
@@ -1,12 +1,12 @@
-// Debug.Scripts keep their referents alive.
+// Debugger.Scripts keep their referents alive.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var arr = [];
 dbg.hooks = {debuggerHandler: function (frame) { arr.push(frame.script); }};
 g.eval("for (var i = 0; i < 10; i++) Function('debugger;')();");
 assertEq(arr.length, 10);
 
 gc();
 
 for (var i = 0; i < arr.length; i++)
--- a/js/src/jit-test/tests/debug/Script-gc-03.js
+++ b/js/src/jit-test/tests/debug/Script-gc-03.js
@@ -1,12 +1,12 @@
-// Referents of Debug.Scripts in other compartments always survive per-compartment GC.
+// Referents of Debugger.Scripts in other compartments always survive per-compartment GC.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var arr = [];
 dbg.hooks = {debuggerHandler: function (frame) { arr.push(frame.script); }};
 g.eval("for (var i = 0; i < 100; i++) Function('debugger;')();");
 assertEq(arr.length, 100);
 
 gc(g);
 
 for (var i = 0; i < arr.length; i++)
--- a/js/src/jit-test/tests/debug/Script-getBreakpoints-01.js
+++ b/js/src/jit-test/tests/debug/Script-getBreakpoints-01.js
@@ -6,17 +6,17 @@ g.eval("var line0 = Error().lineNumber;\
        "    if (x < 0)\n" +         // line0 + 2
        "        return -x;\n" +     // line0 + 3
        "    return x;\n" +
        "}");
 
 var s;
 var offsets = [];
 var handlers = [];
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         s = frame.eval("f").return.script;
         var off;
 
         for (var i = 0; i < 3; i++) {
             var off = s.getLineOffsets(g.line0 + 2 + i)[0];
             assertEq(typeof off, 'number');
--- a/js/src/jit-test/tests/debug/Script-getBreakpoints-02.js
+++ b/js/src/jit-test/tests/debug/Script-getBreakpoints-02.js
@@ -1,16 +1,16 @@
-// Script.prototype.getBreakpoints returns breakpoints for the current Debug object only.
+// Script.prototype.getBreakpoints returns breakpoints for the current Debugger object only.
 
 var g = newGlobal('new-compartment');
 
 var debuggers = [];
 var hits = 0;
 function attach(g, i) {
-    var dbg = Debug(g);
+    var dbg = Debugger(g);
     dbg.hooks = {
         debuggerHandler: function (frame) {
             var s = frame.script;
             var offs = s.getLineOffsets(g.line0 + 2);
             var hitAny = false;
             var handler = {
                 hit: function (frame) {
                     assertEq(this, handler);
--- a/js/src/jit-test/tests/debug/Script-getChildScripts-01.js
+++ b/js/src/jit-test/tests/debug/Script-getChildScripts-01.js
@@ -1,15 +1,15 @@
 // Basic getChildScripts tests.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var log;
 function note(s) {
-    assertEq(s instanceof Debug.Script, true);
+    assertEq(s instanceof Debugger.Script, true);
     log += 'S';
     var c = s.getChildScripts();
     if (c.length > 0) {
 	log += '[';
 	for (var i = 0; i < c.length; i++)
 	    note(c[i]);
 	log += ']';
     }
--- a/js/src/jit-test/tests/debug/Script-getChildScripts-02.js
+++ b/js/src/jit-test/tests/debug/Script-getChildScripts-02.js
@@ -1,12 +1,12 @@
 // getChildScripts returns scripts in source order.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var scripts = [];
 var cs;
 dbg.hooks = {
     debuggerHandler: function (frame) {
 	scripts.push(frame.script);
 	if (scripts.length === 1)
 	    cs = frame.script.getChildScripts();
     }
--- a/js/src/jit-test/tests/debug/Script-getLineOffsets-01.js
+++ b/js/src/jit-test/tests/debug/Script-getLineOffsets-01.js
@@ -1,12 +1,12 @@
 // getLineOffsets on a line that is definitely outside a script returns an empty array.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var offs = frame.script.getLineOffsets(g.line0 + 2);
         assertEq(Array.isArray(offs), true);
         assertEq(offs.length, 0);
         hits++;
     }
--- a/js/src/jit-test/tests/debug/Script-getLineOffsets-02.js
+++ b/js/src/jit-test/tests/debug/Script-getLineOffsets-02.js
@@ -1,12 +1,12 @@
 // getLineOffsets correctly places the various parts of a ForStatement.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         function handler(line) {
             return {hit: function (frame) { g.log += "" + line; }};
         }
 
         var s = frame.eval("f").return.script;
         for (var line = 2; line <= 6; line++) {
--- a/js/src/jit-test/tests/debug/Script-getLineOffsets-03.js
+++ b/js/src/jit-test/tests/debug/Script-getLineOffsets-03.js
@@ -1,14 +1,14 @@
 // getLineOffsets treats one-line compound statements as having only one entry-point.
 // (A breakpoint on a line that only executes once will only hit once.)
 
 var g = newGlobal('new-compartment');
 g.line0 = null;
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var log;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var s = frame.script;
         var lineno = g.line0 + 2;
         var offs = s.getLineOffsets(lineno);
         for (var i = 0; i < offs.length; i++) {
             assertEq(s.getOffsetLine(offs[i]), lineno);
--- a/js/src/jit-test/tests/debug/Script-getLineOffsets-04.js
+++ b/js/src/jit-test/tests/debug/Script-getLineOffsets-04.js
@@ -1,13 +1,13 @@
 // getLineOffsets works with instructions reachable only by breaking out of a loop or switch.
 
 var g = newGlobal('new-compartment');
 g.line0 = null;
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var where;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var s = frame.eval("f").return.script;
         var lineno = g.line0 + where;
         var offs = s.getLineOffsets(lineno);
         for (var i = 0; i < offs.length; i++) {
             assertEq(s.getOffsetLine(offs[i]), lineno);
--- a/js/src/jit-test/tests/debug/Script-getLineOffsets-05.js
+++ b/js/src/jit-test/tests/debug/Script-getLineOffsets-05.js
@@ -1,13 +1,13 @@
 // getLineOffsets identifies multiple ways to land on a line.
 
 var g = newGlobal('new-compartment');
 g.line0 = null;
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var where;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var s = frame.script, lineno, offs;
 
         lineno = g.line0 + where;
         offs = s.getLineOffsets(lineno);
         for (var i = 0; i < offs.length; i++) {
--- a/js/src/jit-test/tests/debug/Script-getLineOffsets-06.js
+++ b/js/src/jit-test/tests/debug/Script-getLineOffsets-06.js
@@ -1,13 +1,13 @@
 // getLineOffsets works with extended instructions, such as JSOP_GOTOX.
 
 var g = newGlobal('new-compartment');
 g.line0 = null;
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var where;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var s = frame.script;
         var offs;
         var lineno = g.line0 + where;
         offs = s.getLineOffsets(lineno);
         for (var i = 0; i < offs.length; i++) {
--- a/js/src/jit-test/tests/debug/Script-getOffsetLine-01.js
+++ b/js/src/jit-test/tests/debug/Script-getOffsetLine-01.js
@@ -1,12 +1,12 @@
 // Basic getOffsetLine test, using Error.lineNumber as the gold standard.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var knownLine = frame.eval("line").return;
         assertEq(frame.script.getOffsetLine(frame.offset), knownLine);
         hits++;
     }
 };
--- a/js/src/jit-test/tests/debug/Script-getOffsetLine-02.js
+++ b/js/src/jit-test/tests/debug/Script-getOffsetLine-02.js
@@ -1,12 +1,12 @@
 // Frame.script/offset and Script.getOffsetLine work in non-top frames.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var a = [];
         for (; frame.type == "call"; frame = frame.older)
             a.push(frame.script.getOffsetLine(frame.offset) - g.line0);
         assertEq(a.join(","), "1,2,3,4");
         hits++;
--- a/js/src/jit-test/tests/debug/breakpoint-01.js
+++ b/js/src/jit-test/tests/debug/breakpoint-01.js
@@ -3,17 +3,17 @@
 var g = newGlobal('new-compartment');
 g.s = '';
 var handler = {
     hit: function (frame) {
         assertEq(this, handler);
         g.s += '1';
     }
 };
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         g.s += '0';
         var line0 = frame.script.getOffsetLine(frame.offset);
         var offs = frame.script.getLineOffsets(line0 + 2);
         for (var i = 0; i < offs.length; i++)
             frame.script.setBreakpoint(offs[i], handler);
     }
--- a/js/src/jit-test/tests/debug/breakpoint-02.js
+++ b/js/src/jit-test/tests/debug/breakpoint-02.js
@@ -2,14 +2,14 @@
 
 load(libdir + "asserts.js");
 
 var g1 = newGlobal('new-compartment');
 var g2 = g1.eval("newGlobal('same-compartment')");
 g2.eval("function f() { return 2; }");
 g1.f = g2.f;
 
-var dbg = Debug(g1);
+var dbg = Debugger(g1);
 var s;
 dbg.hooks = {debuggerHandler: function (frame) { s = frame.eval("f").return.script; }};
 g1.eval("debugger;");
 
 assertThrowsInstanceOf(function () { s.setBreakpoint(0, {}); }, Error);
--- a/js/src/jit-test/tests/debug/breakpoint-03.js
+++ b/js/src/jit-test/tests/debug/breakpoint-03.js
@@ -1,14 +1,14 @@
 // Setting a breakpoint in a script we are no longer debugging is an error.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = Debug();
+var dbg = Debugger();
 var gobj = dbg.addDebuggee(g);
 g.eval("function f() { return 2; }");
 
 var s;
 dbg.hooks = {debuggerHandler: function (frame) { s = frame.eval("f").return.script; }};
 g.eval("debugger;");
 assertEq(s.live, true);
 s.setBreakpoint(0, {});  // ok
--- a/js/src/jit-test/tests/debug/breakpoint-04.js
+++ b/js/src/jit-test/tests/debug/breakpoint-04.js
@@ -2,17 +2,17 @@
 
 var g = newGlobal('new-compartment');
 g.s = '';
 g.eval("var line0 = Error().lineNumber;\n" +
        "function f() {\n" +   // line0 + 1
        "    debugger;\n" +  // line0 + 2
        "    s += 'x';\n" +  // line0 + 3
        "}\n")
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var bp = [];
 dbg.hooks = {
     debuggerHandler: function (frame) {
         g.s += 'D';
         var arr = frame.script.getLineOffsets(g.line0 + 3);
         for (var i = 0; i < arr.length; i++) {
             var obj = {};
             bp[i] = obj;
--- a/js/src/jit-test/tests/debug/breakpoint-05.js
+++ b/js/src/jit-test/tests/debug/breakpoint-05.js
@@ -1,14 +1,14 @@
 // If the offset parameter to setBreakpoint is invalid, throw an error.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         // We assume at least one offset between 0 and frame.offset is invalid.
         assertThrowsInstanceOf(
             function () {
                 for (var i = 0; i < frame.offset; i++)
                     frame.script.setBreakpoint(i, {});
--- a/js/src/jit-test/tests/debug/breakpoint-06.js
+++ b/js/src/jit-test/tests/debug/breakpoint-06.js
@@ -1,12 +1,12 @@
 // The argument to a breakpoint hit method is a frame.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame1) {
         function hit(frame2) {
             assertEq(frame2, frame1);
             hits++;
         }
         var s = frame1.script;
--- a/js/src/jit-test/tests/debug/breakpoint-07.js
+++ b/js/src/jit-test/tests/debug/breakpoint-07.js
@@ -7,17 +7,17 @@ var src = ("var line0 = Error().lineNumb
            "            return gcd(b, a);\n" +  // line0 + 3
            "    var c = b % a;\n" +         // line0 + 4
            "    if (c === 0)\n" +           // line0 + 5
            "            return a;\n" +          // line0 + 6
            "    return gcd(c, a);\n" +      // line0 + 7
            "}\n");                          // line0 + 8
 g.eval(src);
 
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0 ;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         var s = frame.eval("gcd").return.script;
         var offs;
         for (var lineno = g.line0 + 2; (offs = s.getLineOffsets(lineno)).length > 0; lineno++) {
             for (var i = 0; i < offs.length; i++)
                 s.setBreakpoint(offs[i], {hit: function (f) { hits++; }});
--- a/js/src/jit-test/tests/debug/breakpoint-08.js
+++ b/js/src/jit-test/tests/debug/breakpoint-08.js
@@ -6,17 +6,17 @@ var g = newGlobal('new-compartment');
 g.line0 = undefined;
 g.eval("function f() {\n" +
        "    return eval(s);\n" +
        "}\n");
 g.s = ("line0 = Error().lineNumber;\n" +
        "debugger;\n" +          // line0 + 1
        "result = 'ok';\n");     // line0 + 2
 
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits = 0, bphits = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.type, 'eval');
         assertEq(frame.script.getBreakpoints().length, 0);
         var h = {hit: function (frame) { bphits++; }};
         var offs = frame.script.getLineOffsets(g.line0 + 2);
         for (var i = 0; i < offs.length; i++)
--- a/js/src/jit-test/tests/debug/breakpoint-gc-01.js
+++ b/js/src/jit-test/tests/debug/breakpoint-gc-01.js
@@ -1,12 +1,12 @@
 // Handlers for breakpoints in an eval script are live as long as the script is on the stack.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var log = '';
 dbg.hooks = {
     debuggerHandler: function (frame) {
         function handler(i) {
             return {hit: function () { log += '' + i; }};
         }
 
         var s = frame.script;
--- a/js/src/jit-test/tests/debug/breakpoint-gc-02.js
+++ b/js/src/jit-test/tests/debug/breakpoint-gc-02.js
@@ -1,20 +1,20 @@
-// A Debug with live breakpoints is live.
+// A Debugger with live breakpoints is live.
 
 var g = newGlobal('new-compartment');
 g.eval("var line0 = Error().lineNumber;\n" +
        "function f() {\n" +     // line0 + 1
        "    return 2;\n" +      // line0 + 2
        "}\n");
 
 var N = 4;
 var hits = 0;
 for (var i = 0; i < N; i++) {
-    var dbg = Debug(g);
+    var dbg = Debugger(g);
     dbg.hooks = {
         debuggerHandler: function (frame) {
             var handler = {hit: function () { hits++; }};
             var s = frame.eval("f").return.script;
             var offs = s.getLineOffsets(g.line0 + 2);
             for (var j = 0; j < offs.length; j++)
                 s.setBreakpoint(offs[j], handler);
         }
--- a/js/src/jit-test/tests/debug/breakpoint-multi-01.js
+++ b/js/src/jit-test/tests/debug/breakpoint-multi-01.js
@@ -1,12 +1,12 @@
-// A single Debug object can set multiple breakpoints at an instruction.
+// A single Debugger object can set multiple breakpoints at an instruction.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var log = '';
 dbg.hooks = {
     debuggerHandler: function (frame) {
         log += 'D';
         function handler(i) {
             return {hit: function (frame) { log += '' + i; }};
         }
         var f = frame.eval("f").return;
--- a/js/src/jit-test/tests/debug/breakpoint-multi-02.js
+++ b/js/src/jit-test/tests/debug/breakpoint-multi-02.js
@@ -1,12 +1,12 @@
 // After clearing one breakpoint, another breakpoint at the same instruction still works.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var script = null;
 var handlers = [];
 dbg.hooks = {
     debuggerHandler: function (frame) {
         function handler(i) {
             return {hit: function (frame) { g.log += '' + i; }};
         }
         var f = frame.eval("f").return;
--- a/js/src/jit-test/tests/debug/breakpoint-multi-03.js
+++ b/js/src/jit-test/tests/debug/breakpoint-multi-03.js
@@ -1,13 +1,13 @@
-// Multiple Debug objects can set breakpoints at the same instruction.
+// Multiple Debugger objects can set breakpoints at the same instruction.
 
 var g = newGlobal('new-compartment');
 function attach(g, i) {
-    var dbg = Debug(g);
+    var dbg = Debugger(g);
     dbg.hooks = {
         debuggerHandler: function (frame) {
             var s = frame.eval("f").return.script;
             var offs = s.getLineOffsets(g.line0 + 3);
             for (var j = 0; j < offs.length; j++)
                 s.setBreakpoint(offs[j], {hit: function () { g.log += "" + i; }});
         }
     };
--- a/js/src/jit-test/tests/debug/breakpoint-multi-04.js
+++ b/js/src/jit-test/tests/debug/breakpoint-multi-04.js
@@ -1,22 +1,22 @@
-// After clearing one breakpoint, another breakpoint from a different Debug object at the same instruction still works.
+// After clearing one breakpoint, another breakpoint from a different Debugger object at the same instruction still works.
 
 function test(which) {
     var g = newGlobal('new-compartment');
     g.eval("var line0 = Error().lineNumber;\n" +
            "function f() {\n" +             // line0 + 1
            "    return " + which + ";\n" +  // line0 + 2
            "}\n");
 
     var log;
     var scripts = [];
     var handlers = [];
     function addDebugger(g, i) {
-        var dbg = Debug(g);
+        var dbg = Debugger(g);
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 var s = frame.eval("f").return.script;
                 scripts[i] = s;
                 var offs = s.getLineOffsets(g.line0 + 2);
                 var handler = {hit: function (frame) { log += '' + i; } };
                 s.setBreakpoint(0, handler);
                 handlers[i] = handler;
--- a/js/src/jit-test/tests/debug/breakpoint-resume-01.js
+++ b/js/src/jit-test/tests/debug/breakpoint-resume-01.js
@@ -1,12 +1,12 @@
 // A breakpoint handler hit method can return {throw: exc} to throw an exception.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         function hit(frame) {
             return {throw: frame.eval("new Error('PASS')").return};
         }
 
         var s = frame.script;
         var offs = s.getLineOffsets(g.line0 + 3);
--- a/js/src/jit-test/tests/debug/breakpoint-resume-02.js
+++ b/js/src/jit-test/tests/debug/breakpoint-resume-02.js
@@ -1,12 +1,12 @@
 // A breakpoint handler hit method can return null to raise an uncatchable error.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         g.log += 'D';
 
         function hit(frame) {
             g.log += 'H';
             return null;
         }
--- a/js/src/jit-test/tests/debug/breakpoint-resume-03.js
+++ b/js/src/jit-test/tests/debug/breakpoint-resume-03.js
@@ -1,12 +1,12 @@
 // A breakpoint handler hit method can return {return: val} to force the frame to return.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (frame) {
         g.log += 'D';
 
         function hit(frame) {
             g.log += 'H';
             return {return: 'ok'};
         }
--- a/js/src/jit-test/tests/debug/dispatch-01.js
+++ b/js/src/jit-test/tests/debug/dispatch-01.js
@@ -1,16 +1,16 @@
 // Test removing hooks during dispatch.
 
 var g = newGlobal('new-compartment');
 var log = '';
 
 function addDebug(n) {
     for (var i = 0; i < n; i++) {
-        var dbg = new Debug(g);
+        var dbg = new Debugger(g);
         dbg.hooks = {
             num: i,
             dbg: dbg,
             debuggerHandler: function (stack) {
                 log += this.num + ', ';
                 this.dbg.enabled = false;
                 this.dbg.hooks = {};
                 this.dbg = null;
--- a/js/src/jit-test/tests/debug/dispatch-02.js
+++ b/js/src/jit-test/tests/debug/dispatch-02.js
@@ -1,17 +1,17 @@
-// Disabling a Debug object causes events to stop being delivered to it
+// Disabling a Debugger object causes events to stop being delivered to it
 // immediately, even if we're in the middle of dispatching.
 
 var g = newGlobal('new-compartment');
 var log;
 
 var arr = [];
 for (var i = 0; i < 4; i++) {
-    arr[i] = new Debug(g);
+    arr[i] = new Debugger(g);
     arr[i].hooks = {
         num: i,
         debuggerHandler: function () {
             log += this.num;
             // Disable them all.
             for (var j = 0; j < arr.length; j++)
                 arr[j].enabled = false;
         }
--- a/js/src/jit-test/tests/debug/gc-01.js
+++ b/js/src/jit-test/tests/debug/gc-01.js
@@ -2,17 +2,17 @@
 // unreachable.
 
 var g = newGlobal('new-compartment');
 var actual = 0;
 var expected = 0;
 
 function f() {
     for (var i = 0; i < 20; i++) {
-        var dbg = new Debug(g);
+        var dbg = new Debugger(g);
         dbg.hooks = {num: i, debuggerHandler: function (stack) { actual += this.num; }};
         expected += i;
     }
 }
 
 f();
 gc(); gc(); gc();
 g.eval("debugger;");
--- a/js/src/jit-test/tests/debug/gc-02.js
+++ b/js/src/jit-test/tests/debug/gc-02.js
@@ -2,25 +2,25 @@
 // crashing.
 
 var g = newGlobal('new-compartment');
 var hits;
 
 function addDebug() {
     // These loops are here mainly to defeat the conservative GC. :-\
     for (var i = 0; i < 4; i++) {
-        var dbg = new Debug(g);
+        var dbg = new Debugger(g);
         dbg.hooks = {
             dbg: dbg,
             debuggerHandler: function (stack) {
                 hits++;
                 for (var j = 0; j < 4; j++) {
                     this.dbg.enabled = false;
                     this.dbg.hooks = {};
-                    this.dbg = new Debug(g);
+                    this.dbg = new Debugger(g);
                 }
                 gc();
             }
         };
         if (i > 0) {
             dbg.enabled = false;
             dbg.hooks = {};
             dbg = null;
--- a/js/src/jit-test/tests/debug/gc-03.js
+++ b/js/src/jit-test/tests/debug/gc-03.js
@@ -1,14 +1,14 @@
-// Storing a property on a Debug.Object protects it from GC as long as the
+// Storing a property on a Debugger.Object protects it from GC as long as the
 // referent is alive.
 
 var g = newGlobal('new-compartment');
 var N = g.N = 3;
-var dbg = Debug(g);
+var dbg = Debugger(g);
 
 var i = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         frame.arguments[0].id = i++;
     }
 };
 g.eval("function f(x) { debugger; }");
--- a/js/src/jit-test/tests/debug/gc-04.js
+++ b/js/src/jit-test/tests/debug/gc-04.js
@@ -1,14 +1,14 @@
-// Storing a Debug.Object as a key in a WeakMap protects it from GC as long as
+// Storing a Debugger.Object as a key in a WeakMap protects it from GC as long as
 // the referent is alive.
 
 var g = newGlobal('new-compartment');
 var N = g.N = 10;
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var cache = new WeakMap;
 
 var i = 0;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         cache.set(frame.arguments[0], i++);
     }
 };
--- a/js/src/jit-test/tests/debug/gc-05.js
+++ b/js/src/jit-test/tests/debug/gc-05.js
@@ -1,18 +1,18 @@
-// If a Debug survives its debuggee, its object cache must still be swept.
+// If a Debugger survives its debuggee, its object cache must still be swept.
 
 var g2arr = []; // non-debuggee globals
 var xarr = []; // debuggee objects
 
 var N = 4, M = 4;
 for (var i = 0; i < N; i++) {
     var g1 = newGlobal('new-compartment');
     g1.M = M;
-    var dbg = new Debug(g1);
+    var dbg = new Debugger(g1);
     var g2 = g1.eval("newGlobal('same-compartment')");
     g1.x = g2.eval("x = {};");
 
     dbg.hooks = {debuggerHandler: function (frame) { xarr.push(frame.eval("x").return); }};
     g1.eval("debugger;");
     g2arr.push(g2);
 
     g1 = null;
@@ -21,21 +21,21 @@ for (var i = 0; i < N; i++) {
 
 // At least some of the debuggees have probably been collected at this
 // point. It is nondeterministic, though.
 assertEq(g2arr.length, N);
 assertEq(xarr.length, N);
 
 // Try to make g2arr[i].eval eventually allocate a new object in the same
 // location as a previously gc'd object. If the object caches are not being
-// swept, the pointer coincidence will cause a Debug.Object to be erroneously
+// swept, the pointer coincidence will cause a Debugger.Object to be erroneously
 // reused.
 for (var i = 0; i < N; i++) {
     var obj = xarr[i];
     for (j = 0; j < M; j++) {
-        assertEq(obj instanceof Debug.Object, true);
+        assertEq(obj instanceof Debugger.Object, true);
         g2arr[i].eval("x = x.__proto__ = {};");
         obj = obj.proto;
         assertEq("seen" in obj, false);
         obj.seen = true;
         gc();
     }
 }
--- a/js/src/jit-test/tests/debug/gc-06.js
+++ b/js/src/jit-test/tests/debug/gc-06.js
@@ -1,6 +1,6 @@
-// Debug objects do not keep debuggee globals live.
-var dbg = new Debug;
+// Debugger objects do not keep debuggee globals live.
+var dbg = new Debugger;
 for (var i = 0; i < 10; i++)
     dbg.addDebuggee(newGlobal('new-compartment'));
 gc();
 assertEq(dbg.getDebuggees().length <= 4, true);
--- a/js/src/jit-test/tests/debug/gc-07.js
+++ b/js/src/jit-test/tests/debug/gc-07.js
@@ -1,9 +1,9 @@
-// Don't assert with dead Debug.Object and live cross-compartment wrapper of referent.
+// Don't assert with dead Debugger.Object and live cross-compartment wrapper of referent.
 var g = newGlobal('new-compartment');
 for (var j = 0; j < 4; j++) {
-    var dbg = new Debug;
+    var dbg = new Debugger;
     dbg.addDebuggee(g);
     dbg.enabled = false;
     dbg = null;
     gc(); gc();
 } 
--- a/js/src/jit-test/tests/debug/gc-08.js
+++ b/js/src/jit-test/tests/debug/gc-08.js
@@ -4,17 +4,17 @@
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
 var actual = 0;
 var expected = 0;
 
 function f() {
     for (var i = 0; i < 20; i++) {
-        var dbg = new Debug(g);
+        var dbg = new Debugger(g);
         dbg.hooks = {num: i, throw: function (stack, exc) { actual += this.num; }};
         expected += i;
     }
 }
 
 f();
 gc();
 assertThrowsValue(function () { g.eval("throw 'fit';"); }, "fit");
--- a/js/src/jit-test/tests/debug/gc-compartment-01.js
+++ b/js/src/jit-test/tests/debug/gc-compartment-01.js
@@ -1,6 +1,6 @@
 // A debugger can survive per-compartment GC.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 gc(g);
 gc(this);
--- a/js/src/jit-test/tests/debug/gc-compartment-02.js
+++ b/js/src/jit-test/tests/debug/gc-compartment-02.js
@@ -1,12 +1,12 @@
-// Referents of Debug.Objects in other compartments always survive per-compartment GC.
+// Referents of Debugger.Objects in other compartments always survive per-compartment GC.
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var arr = [];
 dbg.hooks = {debuggerHandler: function (frame) { arr.push(frame.eval("[]").return); }};
 g.eval("for (var i = 0; i < 10; i++) debugger;");
 assertEq(arr.length, 10);
 
 gc(g);
 
 for (var i = 0; i < arr.length; i++)
--- a/js/src/jit-test/tests/debug/hooks-debuggerHandler-01.js
+++ b/js/src/jit-test/tests/debug/hooks-debuggerHandler-01.js
@@ -1,9 +1,9 @@
 var g = newGlobal('new-compartment');
 g.log = '';
 
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hooks = {debuggerHandler: function (stack) { g.log += '!'; }};
 dbg.hooks = hooks;
 assertEq(dbg.hooks, hooks);
 assertEq(g.eval("log += '1'; debugger; log += '2'; 3;"), 3);
 assertEq(g.log, '1!2');
--- a/js/src/jit-test/tests/debug/hooks-debuggerHandler-02.js
+++ b/js/src/jit-test/tests/debug/hooks-debuggerHandler-02.js
@@ -1,14 +1,14 @@
 // Activity in the debugger compartment should not trigger debug hooks.
 
 var g = newGlobal('new-compartment');
 var hit = false;
 
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (stack) {
         hit = true;
     }
 };
 
 debugger;
 assertEq(hit, false, "raw debugger statement in debugger compartment should not hit");
--- a/js/src/jit-test/tests/debug/hooks-debuggerHandler-03.js
+++ b/js/src/jit-test/tests/debug/hooks-debuggerHandler-03.js
@@ -1,14 +1,14 @@
 // A debugger statement in a debuggerHandler should not reenter.
 
 var g = newGlobal('new-compartment');
 var calls = 0;
 
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (stack) {
         calls++;
         debugger;
     }
 };
 
 assertEq(g.eval("debugger; 7;"), 7);
--- a/js/src/jit-test/tests/debug/hooks-deleted.js
+++ b/js/src/jit-test/tests/debug/hooks-deleted.js
@@ -1,14 +1,14 @@
 // If a hook is deleted after setHooks or overwritten with a primitive, it
 // simply isn't called.
 
 var g = newGlobal('new-compartment');
 var hit = false;
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {debuggerHandler: function (stack) { hit = 'fail';}};
 
 delete dbg.hooks.debuggerHandler;
 g.eval("debugger;");
 assertEq(hit, false);
 
 dbg.hooks.debuggerHandler = null;
 g.eval("debugger;");
--- a/js/src/jit-test/tests/debug/hooks-throw-01.js
+++ b/js/src/jit-test/tests/debug/hooks-throw-01.js
@@ -1,21 +1,21 @@
 // Basic throw hook test.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hit = false;
 dbg.hooks = {
     throw: function (frame, exc) {
         // hooks.throw is called multiple times as the stack is unwound.
         // Only check the first hit.
         assertEq(arguments.length, 2);
-        assertEq(frame instanceof Debug.Frame, true);
+        assertEq(frame instanceof Debugger.Frame, true);
         if (!hit) {
             assertEq(exc, 101);
             assertEq(frame.type, "call");
             assertEq(frame.callee.name, "f");
             assertEq(frame.older.type, "eval");
             hit = true;
         }
     }
--- a/js/src/jit-test/tests/debug/hooks-throw-02.js
+++ b/js/src/jit-test/tests/debug/hooks-throw-02.js
@@ -1,20 +1,20 @@
 // |jit-test| debug
 // The throw hook is called multiple times as the stack unwinds.
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.dbg = null;
 g.eval("(" + function () {
-        dbg = new Debug(debuggeeGlobal);
+        dbg = new Debugger(debuggeeGlobal);
         dbg.hooks = {
             throw: function (frame, exc) {
-                assertEq(frame instanceof Debug.Frame, true);
-                assertEq(exc instanceof Debug.Object, true);
+                assertEq(frame instanceof Debugger.Frame, true);
+                assertEq(exc instanceof Debugger.Object, true);
                 var s = '!';
                 for (var f = frame; f; f = f.older)
                     if (f.type === "call")
                         s += f.callee.name;
                 s += ', ';
                 debuggeeGlobal.log += s;
             }
         };
--- a/js/src/jit-test/tests/debug/hooks-throw-03.js
+++ b/js/src/jit-test/tests/debug/hooks-throw-03.js
@@ -1,20 +1,20 @@
 // |jit-test| debug
 // The throw hook is called multiple times as the stack unwinds.
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.dbg = null;
 g.eval("(" + function () {
-        dbg = new Debug(debuggeeGlobal);
+        dbg = new Debugger(debuggeeGlobal);
         dbg.hooks = {
             throw: function (frame, exc) {
-                assertEq(frame instanceof Debug.Frame, true);
-                assertEq(exc instanceof Debug.Object, true);
+                assertEq(frame instanceof Debugger.Frame, true);
+                assertEq(exc instanceof Debugger.Object, true);
                 var s = '!';
                 for (var f = frame; f; f = f.older)
                     if (f.type === "call")
                         s += f.callee.name;
                 s += ', ';
                 debuggeeGlobal.log += s;
             }
         };
--- a/js/src/jit-test/tests/debug/hooks-throw-04.js
+++ b/js/src/jit-test/tests/debug/hooks-throw-04.js
@@ -1,11 +1,11 @@
 // hooks.throw is not called for exceptions thrown and handled in the debugger.
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 g.log = '';
 dbg.hooks = {
     debuggerHandler: function (frame) {
         try {
             throw new Error("oops");
         } catch (exc) {
             g.log += exc.message;
         }
--- a/js/src/jit-test/tests/debug/hooks-throw-05.js
+++ b/js/src/jit-test/tests/debug/hooks-throw-05.js
@@ -1,13 +1,13 @@
 // |jit-test| debug
 // hooks.throw returning undefined does not affect the thrown exception.
 
 var g = newGlobal('new-compartment');
 g.parent = this;
-g.eval("new Debug(parent).hooks = {throw: function () {}};");
+g.eval("new Debugger(parent).hooks = {throw: function () {}};");
 
 var obj = new Error("oops");
 try {
     throw obj;
 } catch (exc) {
     assertEq(exc, obj);
 }
--- a/js/src/jit-test/tests/debug/hooks-throw-06.js
+++ b/js/src/jit-test/tests/debug/hooks-throw-06.js
@@ -1,14 +1,14 @@
 // |jit-test| debug
 // hooks.throw assigning to argv[1] does not affect the thrown exception.
 
 var g = newGlobal('new-compartment');
 g.parent = this;
 g.eval("function f(frame, exc) { f2 = function () { return exc; }; exc = 123; }");
-g.eval("new Debug(parent).hooks = {throw: f};");
+g.eval("new Debugger(parent).hooks = {throw: f};");
 
 var obj = new Error("oops");
 try {
     throw obj;
 } catch (exc) {
     assertEq(exc, obj);
 }
--- a/js/src/jit-test/tests/debug/resumption-01.js
+++ b/js/src/jit-test/tests/debug/resumption-01.js
@@ -1,14 +1,14 @@
 // Simple {throw:} resumption.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (stack) {
         return {throw: "oops"};
     }
 };
 
 assertThrowsValue(function () { g.eval("debugger;"); }, "oops");
 
--- a/js/src/jit-test/tests/debug/resumption-02.js
+++ b/js/src/jit-test/tests/debug/resumption-02.js
@@ -1,11 +1,11 @@
 // Simple {return:} resumption.
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 dbg.hooks = {
     debuggerHandler: function (stack) {
         return {return: 1234};
     }
 };
 
 assertEq(g.eval("debugger; false;"), 1234);
 g.eval("function f() { debugger; return 'bad'; }");
--- a/js/src/jit-test/tests/debug/resumption-03.js
+++ b/js/src/jit-test/tests/debug/resumption-03.js
@@ -2,17 +2,17 @@
 // Returning and throwing objects.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("(" + function () {
         var how, what;
-        var dbg = new Debug(debuggeeGlobal);
+        var dbg = new Debugger(debuggeeGlobal);
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 if (frame.callee.name === "configure") {
                     how = frame.arguments[0];
                     what = frame.arguments[1];
                 } else {
                     var resume = {};
                     resume[how] = what;
--- a/js/src/jit-test/tests/debug/resumption-04.js
+++ b/js/src/jit-test/tests/debug/resumption-04.js
@@ -1,14 +1,14 @@
 // |jit-test| debug
 // Forced return from a generator frame.
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
-g.eval("var dbg = new Debug(debuggeeGlobal);" +
+g.eval("var dbg = new Debugger(debuggeeGlobal);" +
        "dbg.hooks = {debuggerHandler: function () { return {return: '!'}; }};");
 
 function gen() {
     yield '1';
     debugger;  // Force return here. The value is ignored.
     yield '2';
 }
 var x = [v for (v in gen())];
--- a/js/src/jit-test/tests/debug/resumption-05.js
+++ b/js/src/jit-test/tests/debug/resumption-05.js
@@ -1,15 +1,15 @@
 // |jit-test| debug
 // null resumption value means terminate the debuggee
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("(" + function () { 
-        var dbg = new Debug(debuggeeGlobal);
+        var dbg = new Debugger(debuggeeGlobal);
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 if (frame.callee === null) {
                     // The first debugger statement below.
                     debuggeeGlobal.log += "1";
                     var cv = frame.eval("f();");
                     assertEq(cv, null);
                     debuggeeGlobal.log += "2";
--- a/js/src/jit-test/tests/debug/surfaces-01.js
+++ b/js/src/jit-test/tests/debug/surfaces-01.js
@@ -5,13 +5,13 @@ function checkFunction(obj, name, nargs)
     assertEq(desc.configurable, true, name + " should be configurable");
     assertEq(desc.writable, true, name + " should be writable");
     assertEq(desc.enumerable, false, name + " should be non-enumerable");
     assertEq(desc.value, obj[name]);  // well obviously
     assertEq(typeof desc.value, 'function', name + " should be a function");
     assertEq(desc.value.length, nargs, name + " should have .length === " + nargs);
 }
 
-checkFunction(this, "Debug", 1);
+checkFunction(this, "Debugger", 1);
 
-assertEq(Debug.prototype.constructor, Debug);
-assertEq(Object.prototype.toString.call(Debug.prototype), "[object Debug]");
-assertEq(Object.getPrototypeOf(Debug.prototype), Object.prototype);
+assertEq(Debugger.prototype.constructor, Debugger);
+assertEq(Object.prototype.toString.call(Debugger.prototype), "[object Debugger]");
+assertEq(Object.getPrototypeOf(Debugger.prototype), Object.prototype);
--- a/js/src/jit-test/tests/debug/surfaces-02.js
+++ b/js/src/jit-test/tests/debug/surfaces-02.js
@@ -1,29 +1,29 @@
-// Debug.prototype.hooks
+// Debugger.prototype.hooks
 
 load(libdir + 'asserts.js');
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 gc();  // don't assert marking dbg.hooks
 var h = dbg.hooks;
 assertEq(typeof h, 'object');
 assertEq(Object.getOwnPropertyNames(h).length, 0);
 assertEq(Object.getPrototypeOf(h), Object.prototype);
 
 assertThrowsInstanceOf(function () { dbg.hooks = null; }, TypeError);
 assertThrowsInstanceOf(function () { dbg.hooks = "bad"; }, TypeError);
 
 assertEq(Object.getOwnPropertyNames(dbg).length, 0);
-var desc = Object.getOwnPropertyDescriptor(Debug.prototype, "hooks");
+var desc = Object.getOwnPropertyDescriptor(Debugger.prototype, "hooks");
 assertEq(desc.configurable, true);
 assertEq(desc.enumerable, false);
 
 assertThrowsInstanceOf(function () { desc.get(); }, TypeError);
 assertThrowsInstanceOf(function () { desc.get.call(undefined); }, TypeError);
-assertThrowsInstanceOf(function () { desc.get.call(Debug.prototype); }, TypeError);
+assertThrowsInstanceOf(function () { desc.get.call(Debugger.prototype); }, TypeError);
 assertEq(desc.get.call(dbg), h);
 
 assertThrowsInstanceOf(function () { desc.set(); }, TypeError);
 assertThrowsInstanceOf(function () { desc.set.call(dbg); }, TypeError);
 assertThrowsInstanceOf(function () { desc.set.call({}, {}); }, TypeError);
-assertThrowsInstanceOf(function () { desc.set.call(Debug.prototype, {}); }, TypeError);
+assertThrowsInstanceOf(function () { desc.set.call(Debugger.prototype, {}); }, TypeError);
--- a/js/src/jit-test/tests/debug/surfaces-03.js
+++ b/js/src/jit-test/tests/debug/surfaces-03.js
@@ -1,19 +1,19 @@
 // dumb basics of uncaughtExceptionHook
 
 load(libdir + 'asserts.js');
 
-var desc = Object.getOwnPropertyDescriptor(Debug.prototype, "uncaughtExceptionHook");
+var desc = Object.getOwnPropertyDescriptor(Debugger.prototype, "uncaughtExceptionHook");
 assertEq(typeof desc.get, 'function');
 assertEq(typeof desc.set, 'function');
 
-assertThrowsInstanceOf(function () { Debug.prototype.uncaughtExceptionHook = null; }, TypeError);
+assertThrowsInstanceOf(function () { Debugger.prototype.uncaughtExceptionHook = null; }, TypeError);
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 assertEq(desc.get.call(dbg), null);
 assertThrowsInstanceOf(function () { dbg.uncaughtExceptionHook = []; }, TypeError);
 assertThrowsInstanceOf(function () { dbg.uncaughtExceptionHook = 3; }, TypeError);
 dbg.uncaughtExceptionHook = Math.sin;
 assertEq(dbg.uncaughtExceptionHook, Math.sin);
 dbg.uncaughtExceptionHook = null;
 assertEq(dbg.uncaughtExceptionHook, null);
--- a/js/src/jit-test/tests/debug/surfaces-offsets.js
+++ b/js/src/jit-test/tests/debug/surfaces-offsets.js
@@ -1,14 +1,14 @@
 // Invalid offsets result in exceptions, not bogus results.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = Debug(g);
+var dbg = Debugger(g);
 var hits;
 dbg.hooks = {
     debuggerHandler: function (frame) {
         assertEq(frame.script.getOffsetLine(frame.offset), g.line);
         assertThrowsInstanceOf(function () { frame.script.getOffsetLine(String(frame.offset)); }, Error);
         assertThrowsInstanceOf(function () { frame.script.getOffsetLine(Object(frame.offset)); }, Error);
 
         assertThrowsInstanceOf(function () { frame.script.getOffsetLine(-1); }, Error);
--- a/js/src/jit-test/tests/debug/uncaughtExceptionHook-01.js
+++ b/js/src/jit-test/tests/debug/uncaughtExceptionHook-01.js
@@ -1,13 +1,13 @@
 // Uncaught exceptions in the debugger itself are delivered to the
 // uncaughtExceptionHook.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var log;
 dbg.hooks = {
     debuggerHandler: function () {
         log += 'x';
         throw new TypeError("fail");
     }
 };
 dbg.uncaughtExceptionHook = function (exc) {
--- a/js/src/jit-test/tests/debug/uncaughtExceptionHook-02.js
+++ b/js/src/jit-test/tests/debug/uncaughtExceptionHook-02.js
@@ -1,12 +1,12 @@
 // Returning a bad resumption value causes an exception that is reported to the
 // uncaughtExceptionHook.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 dbg.hooks = {debuggerHandler: function () { return {oops: "bad resumption value"}; }};
 dbg.uncaughtExceptionHook = function (exc) {
     assertEq(exc instanceof TypeError, true);
     return {return: "pass"};
 };
 
 assertEq(g.eval("debugger"), "pass");
--- a/js/src/jit-test/tests/debug/uncaughtExceptionHook-03.js
+++ b/js/src/jit-test/tests/debug/uncaughtExceptionHook-03.js
@@ -1,15 +1,15 @@
 // |jit-test| debug; error: ReferenceError
 // If uncaughtExceptionHook is absent, the debuggee is terminated.
 
 var g = newGlobal('new-compartment');
 g.debuggeeGlobal = this;
 g.eval("(" + function () {
-        var dbg = Debug(debuggeeGlobal);
+        var dbg = Debugger(debuggeeGlobal);
         dbg.hooks = {
             debuggerHandler: function (frame) {
                 if (frame.callee === null) {
                     debuggeeGlobal.log += '1';
                     var cv = frame.eval("f();");
                     debuggeeGlobal.log += '2';
                     assertEq(cv, null);
                 } else {
--- a/js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-01.js
+++ b/js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-01.js
@@ -1,14 +1,14 @@
 // uncaughtExceptionHook returns a resumption value.
 
 load(libdir + "asserts.js");
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var rv;
 dbg.hooks = {debuggerHandler: function () { throw 15; }};
 dbg.uncaughtExceptionHook = function (exc) {
     assertEq(exc, 15);
     return rv;
 };
 
 // case 1: undefined
--- a/js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-02.js
+++ b/js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-02.js
@@ -1,16 +1,16 @@
 // uncaughtExceptionHook resumption value other than undefined causes further
 // hooks to be skipped.
 
 var g = newGlobal('new-compartment');
 var log;
 
 function makeDebug(g, name) {
-    var dbg = new Debug(g);
+    var dbg = new Debugger(g);
     dbg.hooks = {
         debuggerHandler: function (frame) {
             log += name;
             throw new Error(name);
         }
     };
     dbg.uncaughtExceptionHook = function (exc) {
         assertEq(exc.message, name);
--- a/js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-03.js
+++ b/js/src/jit-test/tests/debug/uncaughtExceptionHook-resumption-03.js
@@ -1,12 +1,12 @@
 // After hooks.throw throws, if uncaughtExceptionHook returns undefined,
 // the original exception continues to propagate.
 
 var g = newGlobal('new-compartment');
-var dbg = new Debug(g);
+var dbg = new Debugger(g);
 var log = '';
 dbg.hooks = {throw: function () { log += "1"; throw new Error("oops"); }};
 dbg.uncaughtExceptionHook = function () { log += "2"; };
 
 g.eval("var x = new Error('oops');");
 g.eval("try { throw x; } catch (exc) { assertEq(exc, x); }");
 assertEq(log, "12");
--- a/js/src/jsapi-tests/testDebugger.cpp
+++ b/js/src/jsapi-tests/testDebugger.cpp
@@ -99,35 +99,35 @@ BEGIN_TEST(testDebugger_getThisStrict)
          "(42).strict();\n"
          "strict.call(undefined);\n"
          "strict.call(null);\n");
     CHECK(!anyWrapped);
     return true;
 }
 END_TEST(testDebugger_getThisStrict)
 
-BEGIN_TEST(testDebugger_debugObjectVsDebugMode)
+BEGIN_TEST(testDebugger_debuggerObjectVsDebugMode)
 {
-    CHECK(JS_DefineDebugObject(cx, global));
+    CHECK(JS_DefineDebuggerObject(cx, global));
     JSObject *debuggee = JS_NewCompartmentAndGlobalObject(cx, getGlobalClass(), NULL);
     CHECK(debuggee);
 
     {
         JSAutoEnterCompartment ae;
         CHECK(ae.enter(cx, debuggee));
         CHECK(JS_SetDebugMode(cx, true));
         CHECK(JS_InitStandardClasses(cx, debuggee));
     }
 
     JSObject *debuggeeWrapper = debuggee;
     CHECK(JS_WrapObject(cx, &debuggeeWrapper));
     jsval v = OBJECT_TO_JSVAL(debuggeeWrapper);
     CHECK(JS_SetProperty(cx, global, "debuggee", &v));
 
-    EVAL("var dbg = new Debug(debuggee);\n"
+    EVAL("var dbg = new Debugger(debuggee);\n"
          "var hits = 0;\n"
          "dbg.hooks = {debuggerHandler: function () { hits++; }};\n"
          "debuggee.eval('debugger;');\n"
          "hits;\n",
          &v);
     CHECK_SAME(v, JSVAL_ONE);
 
     {
@@ -138,9 +138,9 @@ BEGIN_TEST(testDebugger_debugObjectVsDeb
 
     EVAL("debuggee.eval('debugger; debugger; debugger;');\n"
          "hits;\n",
          &v);
     CHECK_SAME(v, INT_TO_JSVAL(4));
     
     return true;
 }
-END_TEST(testDebugger_debugObjectVsDebugMode)
+END_TEST(testDebugger_debuggerObjectVsDebugMode)
--- a/js/src/jscntxt.h
+++ b/js/src/jscntxt.h
@@ -511,17 +511,17 @@ struct JSRuntime {
                 globalDebugHooks.callHook);
     }
 #endif
 
     /* More debugging state, see jsdbgapi.c. */
     JSCList             watchPointList;
 
     /*
-     * Linked list of all js::Debug objects. This may be accessed by the GC
+     * Linked list of all js::Debugger objects. This may be accessed by the GC
      * thread, if any, or a thread that is in a request and holds gcLock.
      */
     JSCList             debuggerList;
 
     /* Client opaque pointers */
     void                *data;
 
 #ifdef JS_THREADSAFE
--- a/js/src/jscompartment.cpp
+++ b/js/src/jscompartment.cpp
@@ -767,17 +767,17 @@ JSCompartment::getOrCreateBreakpointSite
         JS_ASSERT_IF(scriptObject, site->scriptObject == scriptObject);
     else
         site->scriptObject = scriptObject;
 
     return site;
 }
 
 void
-JSCompartment::clearBreakpointsIn(JSContext *cx, js::Debug *dbg, JSScript *script,
+JSCompartment::clearBreakpointsIn(JSContext *cx, js::Debugger *dbg, JSScript *script,
                                   JSObject *handler)
 {
     JS_ASSERT_IF(script, script->compartment == this);
 
     for (BreakpointSiteMap::Enum e(breakpointSites); !e.empty(); e.popFront()) {
         BreakpointSite *site = e.front().value;
         if (!script || site->script == script) {
             Breakpoint *next;
--- a/js/src/jscompartment.h
+++ b/js/src/jscompartment.h
@@ -550,19 +550,19 @@ struct JS_FRIEND_API(JSCompartment) {
 #endif
 
     size_t backEdgeCount(jsbytecode *pc) const;
     size_t incBackEdgeCount(jsbytecode *pc);
 
     /*
      * There are dueling APIs for debug mode. It can be enabled or disabled via
      * JS_SetDebugModeForCompartment. It is automatically enabled and disabled
-     * by Debug objects. Therefore debugModeBits has the DebugFromC bit set if
-     * the C API wants debug mode and the DebugFromJS bit set if debuggees is
-     * nonempty.
+     * by Debugger objects. Therefore debugModeBits has the DebugFromC bit set
+     * if the C API wants debug mode and the DebugFromJS bit set if debuggees
+     * is nonempty.
      */
     bool debugMode() const { return !!debugModeBits; }
 
     /*
      * True if any scripts from this compartment are on the JS stack in the
      * calling thread. cx is a context in the calling thread, and it is assumed
      * that no other thread is using this compartment.
      */
@@ -577,17 +577,17 @@ struct JS_FRIEND_API(JSCompartment) {
     bool addDebuggee(JSContext *cx, js::GlobalObject *global);
     void removeDebuggee(JSContext *cx, js::GlobalObject *global,
                         js::GlobalObjectSet::Enum *debuggeesEnum = NULL);
     bool setDebugModeFromC(JSContext *cx, bool b);
 
     js::BreakpointSite *getBreakpointSite(jsbytecode *pc);
     js::BreakpointSite *getOrCreateBreakpointSite(JSContext *cx, JSScript *script, jsbytecode *pc,
                                                   JSObject *scriptObject);
-    void clearBreakpointsIn(JSContext *cx, js::Debug *dbg, JSScript *script, JSObject *handler);
+    void clearBreakpointsIn(JSContext *cx, js::Debugger *dbg, JSScript *script, JSObject *handler);
     void clearTraps(JSContext *cx, JSScript *script);
     bool markBreakpointsIteratively(JSTracer *trc);
   private:
     void sweepBreakpoints(JSContext *cx);
 };
 
 #define JS_SCRIPTS_TO_GC(cx)    ((cx)->compartment->scriptsToGC)
 #define JS_PROPERTY_TREE(cx)    ((cx)->compartment->propertyTree)
--- a/js/src/jsdbg.cpp
+++ b/js/src/jsdbg.cpp
@@ -9,17 +9,17 @@
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  * for the specific language governing rights and limitations under the
  * License.
  *
- * The Original Code is SpiderMonkey Debug object.
+ * The Original Code is SpiderMonkey Debugger object.
  *
  * The Initial Developer of the Original Code is
  * Mozilla Foundation.
  * Portions created by the Initial Developer are Copyright (C) 1998-1999
  * the Initial Developer. All Rights Reserved.
  *
  * Contributors:
  *   Jim Blandy <jimb@mozilla.com>
@@ -52,39 +52,39 @@
 #include "methodjit/Retcon.h"
 #include "vm/Stack-inl.h"
 
 using namespace js;
 
 
 // === Forward declarations
 
-extern Class DebugFrame_class;
+extern Class DebuggerFrame_class;
 
 enum {
     JSSLOT_DEBUGFRAME_OWNER,
     JSSLOT_DEBUGFRAME_ARGUMENTS,
     JSSLOT_DEBUGFRAME_COUNT
 };
 
-extern Class DebugArguments_class;
+extern Class DebuggerArguments_class;
 
 enum {
     JSSLOT_DEBUGARGUMENTS_FRAME,
     JSSLOT_DEBUGARGUMENTS_COUNT
 };
 
-extern Class DebugObject_class;
+extern Class DebuggerObject_class;
 
 enum {
     JSSLOT_DEBUGOBJECT_OWNER,
     JSSLOT_DEBUGOBJECT_COUNT
 };
 
-extern Class DebugScript_class;
+extern Class DebuggerScript_class;
 
 enum {
     JSSLOT_DEBUGSCRIPT_OWNER,
     JSSLOT_DEBUGSCRIPT_HOLDER,  // PrivateValue, cross-compartment pointer
     JSSLOT_DEBUGSCRIPT_COUNT
 };
 
 
@@ -125,18 +125,18 @@ CheckThisClass(JSContext *cx, Value *vp,
     }
     JSObject *thisobj = &vp[1].toObject();
     if (thisobj->getClass() != clasp) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
                              clasp->name, fnname, thisobj->getClass()->name);
         return NULL;
     }
 
-    // Forbid e.g. Debug.prototype, which is of the Debug JSClass but isn't
-    // really a Debug object. The prototype object is distinguished by
+    // Forbid e.g. Debugger.prototype, which is of the Debugger JSClass but isn't
+    // really a Debugger object. The prototype object is distinguished by
     // having a NULL private value.
     if ((clasp->flags & JSCLASS_HAS_PRIVATE) && !thisobj->getPrivate()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
                              clasp->name, fnname, "prototype object");
         return NULL;
     }
     return thisobj;
 }
@@ -281,17 +281,17 @@ BreakpointSite::hasBreakpoint(Breakpoint
 {
     for (Breakpoint *p = firstBreakpoint(); p; p = p->nextInSite())
         if (p == bp)
             return true;
     return false;
 }
 
 
-Breakpoint::Breakpoint(Debug *debugger, BreakpointSite *site, JSObject *handler)
+Breakpoint::Breakpoint(Debugger *debugger, BreakpointSite *site, JSObject *handler)
     : debugger(debugger), site(site), handler(handler)
 {
     JS_APPEND_LINK(&debuggerLinks, &debugger->breakpoints);
     JS_APPEND_LINK(&siteLinks, &site->breakpoints);
 }
 
 Breakpoint *
 Breakpoint::fromDebuggerLinks(JSCList *links)
@@ -327,107 +327,108 @@ Breakpoint::nextInDebugger()
 Breakpoint *
 Breakpoint::nextInSite()
 {
     JSCList *link = JS_NEXT_LINK(&siteLinks);
     return (link == &site->breakpoints) ? NULL : fromSiteLinks(link);
 }
 
 
-// === Debug hook dispatch
+// === Debugger hook dispatch
 
 enum {
     JSSLOT_DEBUG_FRAME_PROTO,
     JSSLOT_DEBUG_OBJECT_PROTO,
     JSSLOT_DEBUG_SCRIPT_PROTO,
     JSSLOT_DEBUG_COUNT
 };
 
-Debug::Debug(JSObject *dbg, JSObject *hooks)
+Debugger::Debugger(JSObject *dbg, JSObject *hooks)
   : object(dbg), hooksObject(hooks), uncaughtExceptionHook(NULL), enabled(true),
     hasDebuggerHandler(false), hasThrowHandler(false),
     objects(dbg->compartment()->rt), heldScripts(dbg->compartment()->rt)
 {
     // This always happens within a request on some cx.
     JSRuntime *rt = dbg->compartment()->rt;
     AutoLockGC lock(rt);
     JS_APPEND_LINK(&link, &rt->debuggerList);
     JS_INIT_CLIST(&breakpoints);
 }
 
-Debug::~Debug()
+Debugger::~Debugger()
 {
     JS_ASSERT(debuggees.empty());
 
     // This always happens in the GC thread, so no locking is required.
     JS_ASSERT(object->compartment()->rt->gcRunning);
     JS_REMOVE_LINK(&link);
 }
 
 bool
-Debug::init(JSContext *cx)
+Debugger::init(JSContext *cx)
 {
     bool ok = (frames.init() &&
                objects.init() &&
                debuggees.init() &&
                heldScripts.init() &&
                evalScripts.init());
     if (!ok)
         js_ReportOutOfMemory(cx);
     return ok;
 }
 
 JS_STATIC_ASSERT(uintN(JSSLOT_DEBUGFRAME_OWNER) == uintN(JSSLOT_DEBUGOBJECT_OWNER));
 JS_STATIC_ASSERT(uintN(JSSLOT_DEBUGFRAME_OWNER) == uintN(JSSLOT_DEBUGSCRIPT_OWNER));
 
-Debug *
-Debug::fromChildJSObject(JSObject *obj)
+Debugger *
+Debugger::fromChildJSObject(JSObject *obj)
 {
-    JS_ASSERT(obj->clasp == &DebugFrame_class ||
-              obj->clasp == &DebugObject_class ||
-              obj->clasp == &DebugScript_class);
+    JS_ASSERT(obj->clasp == &DebuggerFrame_class ||
+              obj->clasp == &DebuggerObject_class ||
+              obj->clasp == &DebuggerScript_class);
     JSObject *dbgobj = &obj->getReservedSlot(JSSLOT_DEBUGOBJECT_OWNER).toObject();
     return fromJSObject(dbgobj);
 }
 
 bool
-Debug::getScriptFrame(JSContext *cx, StackFrame *fp, Value *vp)
+Debugger::getScriptFrame(JSContext *cx, StackFrame *fp, Value *vp)
 {
     JS_ASSERT(fp->isScriptFrame());
     FrameMap::AddPtr p = frames.lookupForAdd(fp);
     if (!p) {
-        // Create and populate the Debug.Frame object.
+        // Create and populate the Debugger.Frame object.
         JSObject *proto = &object->getReservedSlot(JSSLOT_DEBUG_FRAME_PROTO).toObject();
-        JSObject *frameobj = NewNonFunction<WithProto::Given>(cx, &DebugFrame_class, proto, NULL);
+        JSObject *frameobj =
+            NewNonFunction<WithProto::Given>(cx, &DebuggerFrame_class, proto, NULL);
         if (!frameobj || !frameobj->ensureClassReservedSlots(cx))
             return false;
         frameobj->setPrivate(fp);
         frameobj->setReservedSlot(JSSLOT_DEBUGFRAME_OWNER, ObjectValue(*object));
 
         if (!frames.add(p, fp, frameobj)) {
             js_ReportOutOfMemory(cx);
             return false;
         }
     }
     vp->setObject(*p->value);
     return true;
 }
 
 void
-Debug::slowPathLeaveStackFrame(JSContext *cx)
+Debugger::slowPathLeaveStackFrame(JSContext *cx)
 {
     StackFrame *fp = cx->fp();
     GlobalObject *global = fp->scopeChain().getGlobal();
 
     // FIXME This notifies only current debuggers, so it relies on a hack in
-    // Debug::removeDebuggeeGlobal to make sure only current debuggers have
+    // Debugger::removeDebuggeeGlobal to make sure only current debuggers have
     // Frame objects with .live === true.
-    if (GlobalObject::DebugVector *debuggers = global->getDebuggers()) {
-        for (Debug **p = debuggers->begin(); p != debuggers->end(); p++) {
-            Debug *dbg = *p;
+    if (GlobalObject::DebuggerVector *debuggers = global->getDebuggers()) {
+        for (Debugger **p = debuggers->begin(); p != debuggers->end(); p++) {
+            Debugger *dbg = *p;
             if (FrameMap::Ptr p = dbg->frames.lookup(fp)) {
                 JSObject *frameobj = p->value;
                 frameobj->setPrivate(NULL);
                 dbg->frames.remove(p);
             }
         }
     }
 
@@ -435,30 +436,31 @@ Debug::slowPathLeaveStackFrame(JSContext
     // script is about to be destroyed. Remove any breakpoints in it.
     if (fp->isEvalFrame()) {
         JSScript *script = fp->script();
         script->compartment->clearBreakpointsIn(cx, NULL, script, NULL);
     }
 }
 
 bool
-Debug::wrapDebuggeeValue(JSContext *cx, Value *vp)
+Debugger::wrapDebuggeeValue(JSContext *cx, Value *vp)
 {
     assertSameCompartment(cx, object);
 
     if (vp->isObject()) {
         JSObject *obj = &vp->toObject();
 
         ObjectWeakMap::AddPtr p = objects.lookupForAdd(obj);
         if (p) {
             vp->setObject(*p->value);
         } else {
-            // Create a new Debug.Object for obj.
+            // Create a new Debugger.Object for obj.
             JSObject *proto = &object->getReservedSlot(JSSLOT_DEBUG_OBJECT_PROTO).toObject();
-            JSObject *dobj = NewNonFunction<WithProto::Given>(cx, &DebugObject_class, proto, NULL);
+            JSObject *dobj =
+                NewNonFunction<WithProto::Given>(cx, &DebuggerObject_class, proto, NULL);
             if (!dobj || !dobj->ensureClassReservedSlots(cx))
                 return false;
             dobj->setPrivate(obj);
             dobj->setReservedSlot(JSSLOT_DEBUGOBJECT_OWNER, ObjectValue(*object));
             if (!objects.relookupOrAdd(p, obj, dobj)) {
                 js_ReportOutOfMemory(cx);
                 return false;
             }
@@ -468,24 +470,24 @@ Debug::wrapDebuggeeValue(JSContext *cx, 
         vp->setUndefined();
         return false;
     }
 
     return true;
 }
 
 bool
-Debug::unwrapDebuggeeValue(JSContext *cx, Value *vp)
+Debugger::unwrapDebuggeeValue(JSContext *cx, Value *vp)
 {
     assertSameCompartment(cx, object, *vp);
     if (vp->isObject()) {
         JSObject *dobj = &vp->toObject();
-        if (dobj->clasp != &DebugObject_class) {
+        if (dobj->clasp != &DebuggerObject_class) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NOT_EXPECTED_TYPE,
-                                 "Debug", "Debug.Object", dobj->clasp->name);
+                                 "Debugger", "Debugger.Object", dobj->clasp->name);
             return false;
         }
 
         Value owner = dobj->getReservedSlot(JSSLOT_DEBUGOBJECT_OWNER);
         if (owner.toObjectOrNull() != object) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
                                  owner.isNull()
                                  ? JSMSG_DEBUG_OBJECT_PROTO
@@ -494,17 +496,17 @@ Debug::unwrapDebuggeeValue(JSContext *cx
         }
 
         vp->setObject(*(JSObject *) dobj->getPrivate());
     }
     return true;
 }
 
 JSTrapStatus
-Debug::handleUncaughtException(AutoCompartment &ac, Value *vp, bool callHook)
+Debugger::handleUncaughtException(AutoCompartment &ac, Value *vp, bool callHook)
 {
     JSContext *cx = ac.context;
     if (cx->isExceptionPending()) {
         if (callHook && uncaughtExceptionHook) {
             Value fval = ObjectValue(*uncaughtExceptionHook);
             Value exc = cx->getPendingException();
             Value rv;
             cx->clearPendingException();
@@ -517,17 +519,17 @@ Debug::handleUncaughtException(AutoCompa
             cx->clearPendingException();
         }
     }
     ac.leave();
     return JSTRAP_ERROR;
 }
 
 bool
-Debug::newCompletionValue(AutoCompartment &ac, bool ok, Value val, Value *vp)
+Debugger::newCompletionValue(AutoCompartment &ac, bool ok, Value val, Value *vp)
 {
     JS_ASSERT_IF(ok, !ac.context->isExceptionPending());
 
     JSContext *cx = ac.context;
     jsid key;
     if (ok) {
         ac.leave();
         key = ATOM_TO_JSID(cx->runtime->atomState.returnAtom);
@@ -550,17 +552,17 @@ Debug::newCompletionValue(AutoCompartmen
     {
         return false;
     }
     vp->setObject(*obj);
     return true;
 }
 
 JSTrapStatus
-Debug::parseResumptionValue(AutoCompartment &ac, bool ok, const Value &rv, Value *vp,
+Debugger::parseResumptionValue(AutoCompartment &ac, bool ok, const Value &rv, Value *vp,
                             bool callHook)
 {
     vp->setUndefined();
     if (!ok)
         return handleUncaughtException(ac, vp, callHook);
     if (rv.isUndefined()) {
         ac.leave();
         return JSTRAP_CONTINUE;
@@ -613,23 +615,23 @@ CallMethodIfPresent(JSContext *cx, JSObj
     Value fval;
     return atom &&
            js_GetMethod(cx, obj, ATOM_TO_JSID(atom), JSGET_NO_METHOD_BARRIER, &fval) &&
            (!js_IsCallable(fval) ||
             ExternalInvoke(cx, ObjectValue(*obj), fval, argc, argv, rval));
 }
 
 bool
-Debug::observesDebuggerStatement() const
+Debugger::observesDebuggerStatement() const
 {
     return enabled && hasDebuggerHandler;
 }
 
 JSTrapStatus
-Debug::handleDebuggerStatement(JSContext *cx, Value *vp)
+Debugger::handleDebuggerStatement(JSContext *cx, Value *vp)
 {
     // Grab cx->fp() before pushing a dummy frame.
     StackFrame *fp = cx->fp();
 
     JS_ASSERT(hasDebuggerHandler);
     AutoCompartment ac(cx, hooksObject);
     if (!ac.enter())
         return JSTRAP_ERROR;
@@ -639,23 +641,23 @@ Debug::handleDebuggerStatement(JSContext
         return handleUncaughtException(ac, vp, false);
 
     Value rv;
     bool ok = CallMethodIfPresent(cx, hooksObject, "debuggerHandler", 1, argv, &rv);
     return parseResumptionValue(ac, ok, rv, vp);
 }
 
 bool
-Debug::observesThrow() const
+Debugger::observesThrow() const
 {
     return enabled && hasThrowHandler;
 }
 
 JSTrapStatus
-Debug::handleThrow(JSContext *cx, Value *vp)
+Debugger::handleThrow(JSContext *cx, Value *vp)
 {
     StackFrame *fp = cx->fp();
     Value exc = cx->getPendingException();
 
     cx->clearPendingException();
     JS_ASSERT(hasThrowHandler);
     AutoCompartment ac(cx, hooksObject);
     if (!ac.enter())
@@ -670,51 +672,51 @@ Debug::handleThrow(JSContext *cx, Value 
     bool ok = CallMethodIfPresent(cx, hooksObject, "throw", 2, argv, &rv);
     JSTrapStatus st = parseResumptionValue(ac, ok, rv, vp);
     if (st == JSTRAP_CONTINUE)
         cx->setPendingException(exc);
     return st;
 }
 
 JSTrapStatus
-Debug::dispatchHook(JSContext *cx, js::Value *vp, DebugObservesMethod observesEvent,
-                    DebugHandleMethod handleEvent)
+Debugger::dispatchHook(JSContext *cx, js::Value *vp, DebuggerObservesMethod observesEvent,
+                       DebuggerHandleMethod handleEvent)
 {
     // Determine which debuggers will receive this event, and in what order.
     // Make a copy of the list, since the original is mutable and we will be
     // calling into arbitrary JS.
     // Note: In the general case, 'triggered' contains references to objects in
     // different compartments--every compartment *except* this one.
     AutoValueVector triggered(cx);
     GlobalObject *global = cx->fp()->scopeChain().getGlobal();
-    if (GlobalObject::DebugVector *debuggers = global->getDebuggers()) {
-        for (Debug **p = debuggers->begin(); p != debuggers->end(); p++) {
-            Debug *dbg = *p;
+    if (GlobalObject::DebuggerVector *debuggers = global->getDebuggers()) {
+        for (Debugger **p = debuggers->begin(); p != debuggers->end(); p++) {
+            Debugger *dbg = *p;
             if ((dbg->*observesEvent)()) {
                 if (!triggered.append(ObjectValue(*dbg->toJSObject())))
                     return JSTRAP_ERROR;
             }
         }
     }
 
     // Deliver the event to each debugger, checking again to make sure it
     // should still be delivered.
     for (Value *p = triggered.begin(); p != triggered.end(); p++) {
-        Debug *dbg = Debug::fromJSObject(&p->toObject());
+        Debugger *dbg = Debugger::fromJSObject(&p->toObject());
         if (dbg->debuggees.has(global) && (dbg->*observesEvent)()) {
             JSTrapStatus st = (dbg->*handleEvent)(cx, vp);
             if (st != JSTRAP_CONTINUE)
                 return st;
         }
     }
     return JSTRAP_CONTINUE;
 }
 
 JSTrapStatus
-Debug::onTrap(JSContext *cx, Value *vp)
+Debugger::onTrap(JSContext *cx, Value *vp)
 {
     StackFrame *fp = cx->fp();
     GlobalObject *scriptGlobal = fp->scopeChain().getGlobal();
     jsbytecode *pc = cx->regs().pc;
     BreakpointSite *site = cx->compartment->getBreakpointSite(pc);
     JSOp op = site->realOpcode;
 
     // Build list of breakpoint handlers.
@@ -727,17 +729,17 @@ Debug::onTrap(JSContext *cx, Value *vp)
     Value frame = UndefinedValue();
     for (Breakpoint **p = triggered.begin(); p != triggered.end(); p++) {
         Breakpoint *bp = *p;
 
         // Handlers can clear breakpoints. Check that bp still exists.
         if (!site || !site->hasBreakpoint(bp))
             continue;
 
-        Debug *dbg = bp->debugger;
+        Debugger *dbg = bp->debugger;
         if (dbg->enabled && dbg->debuggees.lookup(scriptGlobal)) {
             AutoCompartment ac(cx, dbg->object);
             if (!ac.enter())
                 return JSTRAP_ERROR;
 
             Value argv[1];
             if (!dbg->getScriptFrame(cx, fp, &argv[0]))
                 return dbg->handleUncaughtException(ac, vp, false);
@@ -760,20 +762,20 @@ Debug::onTrap(JSContext *cx, Value *vp)
     }
 
     // By convention, return the true op to the interpreter in vp.
     vp->setInt32(op);
     return JSTRAP_CONTINUE;
 }
 
 
-// === Debug JSObjects
+// === Debugger JSObjects
 
 void
-Debug::markKeysInCompartment(JSTracer *tracer, ObjectWeakMap &map)
+Debugger::markKeysInCompartment(JSTracer *tracer, ObjectWeakMap &map)
 {
     JSCompartment *comp = tracer->context->runtime->gcCurrentCompartment;
     JS_ASSERT(comp);
 
     typedef HashMap<JSObject *, JSObject *, DefaultHasher<JSObject *>, RuntimeAllocPolicy> Map;
     Map &storage = map;
     for (Map::Range r = storage.all(); !r.empty(); r.popFront()) {
         JSObject *key = r.front().key;
@@ -787,60 +789,60 @@ Debug::markKeysInCompartment(JSTracer *t
 // WeakMap was marked during mark phase.
 //
 // However, during single-compartment GC, we have to do something about
 // cross-compartment WeakMaps in other compartments. Since those compartments
 // aren't being GC'd, the WeakMaps definitely will not be found during mark
 // phase. If their keys and values might need to be marked, we have to do it
 // manually.
 //
-// Each Debug object keeps two cross-compartment WeakMaps: objects and
+// Each Debugger object keeps two cross-compartment WeakMaps: objects and
 // heldScripts.  Both have the nice property that all their values are in the
-// same compartment as the Debug object, so we only need to mark the keys. We
-// must simply mark all keys that are in the compartment being GC'd.
+// same compartment as the Debugger object, so we only need to mark the
+// keys. We must simply mark all keys that are in the compartment being GC'd.
 //
-// We must scan all Debug objects regardless of whether they *currently* have
-// any debuggees in the compartment being GC'd, because the WeakMap entries
-// persist even when debuggees are removed.
+// We must scan all Debugger objects regardless of whether they *currently*
+// have any debuggees in the compartment being GC'd, because the WeakMap
+// entries persist even when debuggees are removed.
 //
 // This happens during the initial mark phase, not iterative marking, because
 // all the edges being reported here are strong references.
 //
 void 
-Debug::markCrossCompartmentDebugObjectReferents(JSTracer *tracer)
+Debugger::markCrossCompartmentDebuggerObjectReferents(JSTracer *tracer)
 {
     JSRuntime *rt = tracer->context->runtime;
     JSCompartment *comp = rt->gcCurrentCompartment;
 
-    // Mark all objects in comp that are referents of Debug.Objects in other
+    // Mark all objects in comp that are referents of Debugger.Objects in other
     // compartments.
     for (JSCList *p = &rt->debuggerList; (p = JS_NEXT_LINK(p)) != &rt->debuggerList;) {
-        Debug *dbg = Debug::fromLinks(p);
+        Debugger *dbg = Debugger::fromLinks(p);
         if (dbg->object->compartment() != comp) {
             markKeysInCompartment(tracer, dbg->objects);
             markKeysInCompartment(tracer, dbg->heldScripts);
         }
     }         
 }
 
 // This method has two tasks:
-//   1. Mark Debug objects that are unreachable except for debugger hooks that
+//   1. Mark Debugger objects that are unreachable except for debugger hooks that
 //      may yet be called.
 //   2. Mark breakpoint handlers.
 //
 // This happens during the incremental long tail of the GC mark phase. This
 // method returns true if it has to mark anything; GC calls it repeatedly until
 // it returns false.
 //
 bool
-Debug::mark(GCMarker *trc, JSGCInvocationKind gckind)
+Debugger::mark(GCMarker *trc, JSGCInvocationKind gckind)
 {
     bool markedAny = false;
 
-    // We must find all Debug objects in danger of GC. This code is a little
+    // We must find all Debugger objects in danger of GC. This code is a little
     // convoluted since the easiest way to find them is via their debuggees.
     JSRuntime *rt = trc->context->runtime;
     JSCompartment *comp = rt->gcCurrentCompartment;
     for (JSCompartment **c = rt->compartments.begin(); c != rt->compartments.end(); c++) {
         JSCompartment *dc = *c;
 
         // If dc is being collected, mark breakpoint handlers in it.
         if (!comp || dc == comp)
@@ -850,95 +852,95 @@ Debug::mark(GCMarker *trc, JSGCInvocatio
         // |comp|. If it's a global GC, then search every live compartment.
         if (comp ? dc != comp : !dc->isAboutToBeCollected(gckind)) {
             const GlobalObjectSet &debuggees = dc->getDebuggees();
             for (GlobalObjectSet::Range r = debuggees.all(); !r.empty(); r.popFront()) {
                 GlobalObject *global = r.front();
 
                 // Every debuggee has at least one debugger, so in this case
                 // getDebuggers can't return NULL.
-                const GlobalObject::DebugVector *debuggers = global->getDebuggers();
+                const GlobalObject::DebuggerVector *debuggers = global->getDebuggers();
                 JS_ASSERT(debuggers);
-                for (Debug **p = debuggers->begin(); p != debuggers->end(); p++) {
-                    Debug *dbg = *p;
+                for (Debugger **p = debuggers->begin(); p != debuggers->end(); p++) {
+                    Debugger *dbg = *p;
                     JSObject *obj = dbg->toJSObject();
 
-                    // dbg is a Debug with at least one debuggee. Check three things:
+                    // dbg is a Debugger with at least one debuggee. Check three things:
                     //   - dbg is actually in a compartment being GC'd
                     //   - it isn't already marked
                     //   - it actually has hooks that might be called
                     if ((!comp || obj->compartment() == comp) && !obj->isMarked()) {
                         if (dbg->hasAnyLiveHooks()) {
                             // obj could be reachable only via its live, enabled
                             // debugger hooks, which may yet be called.
-                            MarkObject(trc, *obj, "enabled Debug");
+                            MarkObject(trc, *obj, "enabled Debugger");
                             markedAny = true;
                         }
                     }
                 }
             }
         }
     }
     return markedAny;
 }
 
 void
-Debug::traceObject(JSTracer *trc, JSObject *obj)
+Debugger::traceObject(JSTracer *trc, JSObject *obj)
 {
-    if (Debug *dbg = Debug::fromJSObject(obj))
+    if (Debugger *dbg = Debugger::fromJSObject(obj))
         dbg->trace(trc);
 }
 
 void
-Debug::trace(JSTracer *trc)
+Debugger::trace(JSTracer *trc)
 {
     MarkObject(trc, *hooksObject, "hooks");
     if (uncaughtExceptionHook)
         MarkObject(trc, *uncaughtExceptionHook, "hooks");
 
-    // Mark Debug.Frame objects that are reachable from JS if we look them up
+    // Mark Debugger.Frame objects that are reachable from JS if we look them up
     // again (because the corresponding StackFrame is still on the stack).
     for (FrameMap::Range r = frames.all(); !r.empty(); r.popFront()) {
         JSObject *frameobj = r.front().value;
         JS_ASSERT(frameobj->getPrivate());
-        MarkObject(trc, *frameobj, "live Debug.Frame");
+        MarkObject(trc, *frameobj, "live Debugger.Frame");
     }
 
-    // Trace the referent -> Debug.Object weak map.
+    // Trace the referent -> Debugger.Object weak map.
     objects.trace(trc);
 
     // Trace the weak map from JSFunctions and "Script" JSObjects to
-    // Debug.Script objects.
+    // Debugger.Script objects.
     heldScripts.trace(trc);
 
     // Trace the map for eval scripts, which are explicitly freed.
     for (ScriptMap::Range r = evalScripts.all(); !r.empty(); r.popFront()) {
         JSObject *scriptobj = r.front().value;
 
-        // evalScripts should only refer to Debug.Script objects for
+        // evalScripts should only refer to Debugger.Script objects for
         // scripts that haven't been freed yet.
         JS_ASSERT(scriptobj->getPrivate());
-        MarkObject(trc, *scriptobj, "live eval Debug.Script");
+        MarkObject(trc, *scriptobj, "live eval Debugger.Script");
     }
 }
 
 void
-Debug::sweepAll(JSContext *cx)
+Debugger::sweepAll(JSContext *cx)
 {
     JSRuntime *rt = cx->runtime;
     for (JSCList *p = &rt->debuggerList; (p = JS_NEXT_LINK(p)) != &rt->debuggerList;) {
-        Debug *dbg = Debug::fromLinks(p);
+        Debugger *dbg = Debugger::fromLinks(p);
 
         if (!dbg->object->isMarked()) {
-            // If this Debug is being GC'd, detach it from its debuggees. In the case of
+            // If this Debugger is being GC'd, detach it from its debuggees. In the case of
             // runtime-wide GC, the debuggee might be GC'd too. Since detaching requires
             // access to both objects, this must be done before finalize time. However, in
             // a per-compartment GC, it is impossible for both objects to be GC'd (since
             // they are in different compartments), so in that case we just wait for
-            // Debug::finalize.
+            // Debugger::finalize.
             for (GlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront())
                 dbg->removeDebuggeeGlobal(cx, e.front(), NULL, &e);
         }
 
     }
 
     for (JSCompartment **c = rt->compartments.begin(); c != rt->compartments.end(); c++) {
         // For each debuggee being GC'd, detach it from all its debuggers.
@@ -947,66 +949,67 @@ Debug::sweepAll(JSContext *cx)
             GlobalObject *global = e.front();
             if (!global->isMarked())
                 detachAllDebuggersFromGlobal(cx, global, &e);
         }
     }
 }
 
 void
-Debug::detachAllDebuggersFromGlobal(JSContext *cx, GlobalObject *global, GlobalObjectSet::Enum *compartmentEnum)
+Debugger::detachAllDebuggersFromGlobal(JSContext *cx, GlobalObject *global,
+                                       GlobalObjectSet::Enum *compartmentEnum)
 {
-    const GlobalObject::DebugVector *debuggers = global->getDebuggers();
+    const GlobalObject::DebuggerVector *debuggers = global->getDebuggers();
     JS_ASSERT(!debuggers->empty());
     while (!debuggers->empty())
         debuggers->back()->removeDebuggeeGlobal(cx, global, compartmentEnum, NULL);
 }
 
 void
-Debug::finalize(JSContext *cx, JSObject *obj)
+Debugger::finalize(JSContext *cx, JSObject *obj)
 {
-    Debug *dbg = (Debug *) obj->getPrivate();
+    Debugger *dbg = (Debugger *) obj->getPrivate();
     if (!dbg)
         return;
     if (!dbg->debuggees.empty()) {
         // This happens only during per-compartment GC. See comment in
-        // Debug::sweepAll.
+        // Debugger::sweepAll.
         JS_ASSERT(cx->runtime->gcCurrentCompartment == dbg->object->compartment());
         for (GlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront())
             dbg->removeDebuggeeGlobal(cx, e.front(), NULL, &e);
     }
     cx->delete_(dbg);
 }
 
-Class Debug::jsclass = {
-    "Debug", JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUG_COUNT),
+Class Debugger::jsclass = {
+    "Debugger", JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUG_COUNT),
     PropertyStub, PropertyStub, PropertyStub, StrictPropertyStub,
-    EnumerateStub, ResolveStub, ConvertStub, Debug::finalize,
+    EnumerateStub, ResolveStub, ConvertStub, Debugger::finalize,
     NULL,                 /* reserved0   */
     NULL,                 /* checkAccess */
     NULL,                 /* call        */
     NULL,                 /* construct   */
     NULL,                 /* xdrObject   */
     NULL,                 /* hasInstance */
-    Debug::traceObject
+    Debugger::traceObject
 };
 
 JSBool
-Debug::getHooks(JSContext *cx, uintN argc, Value *vp)
+Debugger::getHooks(JSContext *cx, uintN argc, Value *vp)
 {
-    THISOBJ(cx, vp, Debug, "get hooks", thisobj, dbg);
+    THISOBJ(cx, vp, Debugger, "get hooks", thisobj, dbg);
     vp->setObject(*dbg->hooksObject);
     return true;
 }
 
 JSBool
-Debug::setHooks(JSContext *cx, uintN argc, Value *vp)
+Debugger::setHooks(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.set hooks", 1);
-    THISOBJ(cx, vp, Debug, "set hooks", thisobj, dbg);
+    REQUIRE_ARGC("Debugger.set hooks", 1);
+    THISOBJ(cx, vp, Debugger, "set hooks", thisobj, dbg);
     if (!vp[2].isObject())
         return ReportObjectRequired(cx);
     JSObject *hooksobj = &vp[2].toObject();
 
     bool hasDebuggerHandler, hasThrow;
     JSBool found;
     if (!JS_HasProperty(cx, hooksobj, "debuggerHandler", &found))
         return false;
@@ -1018,223 +1021,227 @@ Debug::setHooks(JSContext *cx, uintN arg
     dbg->hooksObject = hooksobj;
     dbg->hasDebuggerHandler = hasDebuggerHandler;
     dbg->hasThrowHandler = hasThrow;
     vp->setUndefined();
     return true;
 }
 
 JSBool
-Debug::getEnabled(JSContext *cx, uintN argc, Value *vp)
+Debugger::getEnabled(JSContext *cx, uintN argc, Value *vp)
 {
-    THISOBJ(cx, vp, Debug, "get enabled", thisobj, dbg);
+    THISOBJ(cx, vp, Debugger, "get enabled", thisobj, dbg);
     vp->setBoolean(dbg->enabled);
     return true;
 }
 
 JSBool
-Debug::setEnabled(JSContext *cx, uintN argc, Value *vp)
+Debugger::setEnabled(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.set enabled", 1);
-    THISOBJ(cx, vp, Debug, "set enabled", thisobj, dbg);
+    REQUIRE_ARGC("Debugger.set enabled", 1);
+    THISOBJ(cx, vp, Debugger, "set enabled", thisobj, dbg);
     bool enabled = js_ValueToBoolean(vp[2]);
 
     if (enabled != dbg->enabled) {
         for (Breakpoint *bp = dbg->firstBreakpoint(); bp; bp = bp->nextInDebugger()) {
             if (enabled) {
                 if (!bp->site->inc(cx)) {
                     // Roll back the changes on error to keep the
                     // BreakpointSite::enabledCount counters correct.
-                    for (Breakpoint *bp2 = dbg->firstBreakpoint(); bp2 != bp; bp2 = bp2->nextInDebugger())
+                    for (Breakpoint *bp2 = dbg->firstBreakpoint();
+                         bp2 != bp;
+                         bp2 = bp2->nextInDebugger())
+                    {
                         bp->site->dec(cx);
+                    }
                     return false;
                 }
             } else {
                 bp->site->dec(cx);
             }
         }
     }
 
     dbg->enabled = enabled;
     vp->setUndefined();
     return true;
 }
 
 JSBool
-Debug::getUncaughtExceptionHook(JSContext *cx, uintN argc, Value *vp)
+Debugger::getUncaughtExceptionHook(JSContext *cx, uintN argc, Value *vp)
 {
-    THISOBJ(cx, vp, Debug, "get uncaughtExceptionHook", thisobj, dbg);
+    THISOBJ(cx, vp, Debugger, "get uncaughtExceptionHook", thisobj, dbg);
     vp->setObjectOrNull(dbg->uncaughtExceptionHook);
     return true;
 }
 
 JSBool
-Debug::setUncaughtExceptionHook(JSContext *cx, uintN argc, Value *vp)
+Debugger::setUncaughtExceptionHook(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.set uncaughtExceptionHook", 1);
-    THISOBJ(cx, vp, Debug, "set uncaughtExceptionHook", thisobj, dbg);
+    REQUIRE_ARGC("Debugger.set uncaughtExceptionHook", 1);
+    THISOBJ(cx, vp, Debugger, "set uncaughtExceptionHook", thisobj, dbg);
     if (!vp[2].isNull() && (!vp[2].isObject() || !vp[2].toObject().isCallable())) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_ASSIGN_FUNCTION_OR_NULL,
                              "uncaughtExceptionHook");
         return false;
     }
 
     dbg->uncaughtExceptionHook = vp[2].toObjectOrNull();
     vp->setUndefined();
     return true;
 }
 
 JSObject *
-Debug::unwrapDebuggeeArgument(JSContext *cx, Value *vp)
+Debugger::unwrapDebuggeeArgument(JSContext *cx, Value *vp)
 {
     // The argument to {add,remove,has}Debuggee may be
-    //   - a Debug.Object belonging to this Debug: return its referent
+    //   - a Debugger.Object belonging to this Debugger: return its referent
     //   - a cross-compartment wrapper: return the wrapped object
-    //   - any other non-Debug.Object object: return it
-    // If it is a primitive, or a Debug.Object that belongs to some other
-    // Debug, throw a TypeError.
+    //   - any other non-Debugger.Object object: return it
+    // If it is a primitive, or a Debugger.Object that belongs to some other
+    // Debugger, throw a TypeError.
     Value v = JS_ARGV(cx, vp)[0];
     JSObject *obj = NonNullObject(cx, v);
     if (obj) {
-        if (obj->clasp == &DebugObject_class) {
+        if (obj->clasp == &DebuggerObject_class) {
             if (!unwrapDebuggeeValue(cx, &v))
                 return NULL;
             return &v.toObject();
         }
         if (obj->isCrossCompartmentWrapper())
             return &obj->getProxyPrivate().toObject();
     }
     return obj;
 }
 
 JSBool
-Debug::addDebuggee(JSContext *cx, uintN argc, Value *vp)
+Debugger::addDebuggee(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.addDebuggee", 1);
-    THISOBJ(cx, vp, Debug, "addDebuggee", thisobj, dbg);
+    REQUIRE_ARGC("Debugger.addDebuggee", 1);
+    THISOBJ(cx, vp, Debugger, "addDebuggee", thisobj, dbg);
     JSObject *referent = dbg->unwrapDebuggeeArgument(cx, vp);
     if (!referent)
         return false;
     GlobalObject *global = referent->getGlobal();
     if (!dbg->debuggees.has(global) && !dbg->addDebuggeeGlobal(cx, global))
         return false;
 
     Value v = ObjectValue(*referent);
     if (!dbg->wrapDebuggeeValue(cx, &v))
         return false;
     *vp = v;
     return true;
 }
 
 JSBool
-Debug::removeDebuggee(JSContext *cx, uintN argc, Value *vp)
+Debugger::removeDebuggee(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.removeDebuggee", 1);
-    THISOBJ(cx, vp, Debug, "removeDebuggee", thisobj, dbg);
+    REQUIRE_ARGC("Debugger.removeDebuggee", 1);
+    THISOBJ(cx, vp, Debugger, "removeDebuggee", thisobj, dbg);
     JSObject *referent = dbg->unwrapDebuggeeArgument(cx, vp);
     if (!referent)
         return false;
     GlobalObject *global = referent->getGlobal();
     if (dbg->debuggees.has(global))
         dbg->removeDebuggeeGlobal(cx, global, NULL, NULL);
     vp->setUndefined();
     return true;
 }
 
 JSBool
-Debug::hasDebuggee(JSContext *cx, uintN argc, Value *vp)
+Debugger::hasDebuggee(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.hasDebuggee", 1);
-    THISOBJ(cx, vp, Debug, "hasDebuggee", thisobj, dbg);
+    REQUIRE_ARGC("Debugger.hasDebuggee", 1);
+    THISOBJ(cx, vp, Debugger, "hasDebuggee", thisobj, dbg);
     JSObject *referent = dbg->unwrapDebuggeeArgument(cx, vp);
     if (!referent)
         return false;
     vp->setBoolean(!!dbg->debuggees.lookup(referent->getGlobal()));
     return true;
 }
 
 JSBool
-Debug::getDebuggees(JSContext *cx, uintN argc, Value *vp)
+Debugger::getDebuggees(JSContext *cx, uintN argc, Value *vp)
 {
-    THISOBJ(cx, vp, Debug, "getDebuggees", thisobj, dbg);
+    THISOBJ(cx, vp, Debugger, "getDebuggees", thisobj, dbg);
     JSObject *arrobj = NewDenseAllocatedArray(cx, dbg->debuggees.count(), NULL);
     if (!arrobj)
         return false;
     uintN i = 0;
     for (GlobalObjectSet::Enum e(dbg->debuggees); !e.empty(); e.popFront()) {
         Value v = ObjectValue(*e.front());
         if (!dbg->wrapDebuggeeValue(cx, &v))
             return false;
         arrobj->setDenseArrayElement(i++, v);
     }
     vp->setObject(*arrobj);
     return true;
 }
 
 JSBool
-Debug::getYoungestFrame(JSContext *cx, uintN argc, Value *vp)
+Debugger::getYoungestFrame(JSContext *cx, uintN argc, Value *vp)
 {
-    THISOBJ(cx, vp, Debug, "getYoungestFrame", thisobj, dbg);
+    THISOBJ(cx, vp, Debugger, "getYoungestFrame", thisobj, dbg);
 
     // cx->fp() would return the topmost frame in the current context.
     // Since there may be multiple contexts, use AllFramesIter instead.
     for (AllFramesIter i(cx->stack.space()); !i.done(); ++i) {
         if (dbg->observesFrame(i.fp()))
             return dbg->getScriptFrame(cx, i.fp(), vp);
     }
     vp->setNull();
     return true;
 }
 
 JSBool
-Debug::clearAllBreakpoints(JSContext *cx, uintN argc, Value *vp)
+Debugger::clearAllBreakpoints(JSContext *cx, uintN argc, Value *vp)
 {
-    THISOBJ(cx, vp, Debug, "clearAllBreakpoints", thisobj, dbg);
+    THISOBJ(cx, vp, Debugger, "clearAllBreakpoints", thisobj, dbg);
     for (GlobalObjectSet::Range r = dbg->debuggees.all(); !r.empty(); r.popFront())
         r.front()->compartment()->clearBreakpointsIn(cx, dbg, NULL, NULL);
     return true;
 }
 
 JSBool
-Debug::construct(JSContext *cx, uintN argc, Value *vp)
+Debugger::construct(JSContext *cx, uintN argc, Value *vp)
 {
     // Check that the arguments, if any, are cross-compartment wrappers.
     Value *argv = vp + 2, *argvEnd = argv + argc;
     for (Value *p = argv; p != argvEnd; p++) {
         const Value &arg = *p;
         if (!arg.isObject())
             return ReportObjectRequired(cx);
         JSObject *argobj = &arg.toObject();
         if (!argobj->isCrossCompartmentWrapper()) {
-            JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CCW_REQUIRED, "Debug");
+            JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_CCW_REQUIRED, "Debugger");
             return false;
         }
     }
 
-    // Get Debug.prototype.
+    // Get Debugger.prototype.
     Value v;
     jsid prototypeId = ATOM_TO_JSID(cx->runtime->atomState.classPrototypeAtom);
     if (!vp[0].toObject().getProperty(cx, prototypeId, &v))
         return false;
     JSObject *proto = &v.toObject();
-    JS_ASSERT(proto->getClass() == &Debug::jsclass);
+    JS_ASSERT(proto->getClass() == &Debugger::jsclass);
 
-    // Make the new Debug object. Each one has a reference to
-    // Debug.{Frame,Object,Script}.prototype in reserved slots.
-    JSObject *obj = NewNonFunction<WithProto::Given>(cx, &Debug::jsclass, proto, NULL);
+    // Make the new Debugger object. Each one has a reference to
+    // Debugger.{Frame,Object,Script}.prototype in reserved slots.
+    JSObject *obj = NewNonFunction<WithProto::Given>(cx, &Debugger::jsclass, proto, NULL);
     if (!obj || !obj->ensureClassReservedSlots(cx))
         return false;
     for (uintN slot = JSSLOT_DEBUG_FRAME_PROTO; slot < JSSLOT_DEBUG_COUNT; slot++)
         obj->setReservedSlot(slot, proto->getReservedSlot(slot));
 
     JSObject *hooks = NewBuiltinClassInstance(cx, &js_ObjectClass);
     if (!hooks)
         return false;
 
-    Debug *dbg = cx->new_<Debug>(obj, hooks);
+    Debugger *dbg = cx->new_<Debugger>(obj, hooks);
     if (!dbg)
         return false;
     obj->setPrivate(dbg);
     if (!dbg->init(cx)) {
         cx->delete_(dbg);
         return false;
     }
 
@@ -1245,39 +1252,39 @@ Debug::construct(JSContext *cx, uintN ar
             return false;
     }
 
     vp->setObject(*obj);
     return true;
 }
 
 bool
-Debug::addDebuggeeGlobal(JSContext *cx, GlobalObject *obj)
+Debugger::addDebuggeeGlobal(JSContext *cx, GlobalObject *obj)
 {
     JSCompartment *debuggeeCompartment = obj->compartment();
 
-    // Check for cycles. If obj's compartment is reachable from this Debug
+    // Check for cycles. If obj's compartment is reachable from this Debugger
     // object's compartment by following debuggee-to-debugger links, then
     // adding obj would create a cycle. (Typically nobody is debugging the
     // debugger, in which case we zip through this code without looping.)
     Vector<JSCompartment *> visited(cx);
     if (!visited.append(object->compartment()))
         return false;
     for (size_t i = 0; i < visited.length(); i++) {
         JSCompartment *c = visited[i];
         if (c == debuggeeCompartment) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_DEBUG_LOOP);
             return false;
         }
 
         // Find all compartments containing debuggers debugging global objects
         // in c. Add those compartments to visited.
         for (GlobalObjectSet::Range r = c->getDebuggees().all(); !r.empty(); r.popFront()) {
-            GlobalObject::DebugVector *v = r.front()->getDebuggers();
-            for (Debug **p = v->begin(); p != v->end(); p++) {
+            GlobalObject::DebuggerVector *v = r.front()->getDebuggers();
+            for (Debugger **p = v->begin(); p != v->end(); p++) {
                 JSCompartment *next = (*p)->object->compartment();
                 if (visited.find(next) == visited.end() && !visited.append(next))
                     return false;
             }
         }
     }
 
     // Refuse to enable debug mode for a compartment that has running scripts.
@@ -1286,17 +1293,17 @@ Debug::addDebuggeeGlobal(JSContext *cx, 
         return false;
     }
 
     // Each debugger-debuggee relation must be stored in up to three places.
     // JSCompartment::addDebuggee enables debug mode if needed.
     AutoCompartment ac(cx, obj);
     if (!ac.enter())
         return false;
-    GlobalObject::DebugVector *v = obj->getOrCreateDebuggers(cx);
+    GlobalObject::DebuggerVector *v = obj->getOrCreateDebuggers(cx);
     if (!v || !v->append(this)) {
         js_ReportOutOfMemory(cx);
         goto fail1;
     }
     if (!debuggees.put(obj)) {
         js_ReportOutOfMemory(cx);
         goto fail2;
     }
@@ -1310,46 +1317,46 @@ fail3:
 fail2:
     JS_ASSERT(v->back() == this);
     v->popBack();
 fail1:
     return false;
 }
 
 void
-Debug::removeDebuggeeGlobal(JSContext *cx, GlobalObject *global,
-                            GlobalObjectSet::Enum *compartmentEnum,
-                            GlobalObjectSet::Enum *debugEnum)
+Debugger::removeDebuggeeGlobal(JSContext *cx, GlobalObject *global,
+                               GlobalObjectSet::Enum *compartmentEnum,
+                               GlobalObjectSet::Enum *debugEnum)
 {
     // Each debuggee is in two HashSets: one for its compartment and one for
     // its debugger (this). The caller might be enumerating either set; if so,
     // use HashSet::Enum::removeFront rather than HashSet::remove below, to
     // avoid invalidating the live enumerator.
     JS_ASSERT(global->compartment()->getDebuggees().has(global));
     JS_ASSERT_IF(compartmentEnum, compartmentEnum->front() == global);
     JS_ASSERT(debuggees.has(global));
     JS_ASSERT_IF(debugEnum, debugEnum->front() == global);
 
-    // FIXME Debug::slowPathLeaveStackFrame needs to kill all Debug.Frame
-    // objects referring to a particular js::StackFrame. This is hard if Debug
-    // objects that are no longer debugging the relevant global might have live
-    // Frame objects. So we take the easy way out and kill them here. This is a
-    // bug, since it's observable and contrary to the spec. One possible fix
-    // would be to put such objects into a compartment-wide bag which
-    // slowPathLeaveStackFrame would have to examine.
+    // FIXME Debugger::slowPathLeaveStackFrame needs to kill all Debugger.Frame
+    // objects referring to a particular js::StackFrame. This is hard if
+    // Debugger objects that are no longer debugging the relevant global might
+    // have live Frame objects. So we take the easy way out and kill them
+    // here. This is a bug, since it's observable and contrary to the spec. One
+    // possible fix would be to put such objects into a compartment-wide bag
+    // which slowPathLeaveStackFrame would have to examine.
     for (FrameMap::Enum e(frames); !e.empty(); e.popFront()) {
         js::StackFrame *fp = e.front().key;
         if (fp->scopeChain().getGlobal() == global) {
             e.front().value->setPrivate(NULL);
             e.removeFront();
         }
     }
 
-    GlobalObject::DebugVector *v = global->getDebuggers();
-    Debug **p;
+    GlobalObject::DebuggerVector *v = global->getDebuggers();
+    Debugger **p;
     for (p = v->begin(); p != v->end(); p++) {
         if (*p == this)
             break;
     }
     JS_ASSERT(p != v->end());
 
     // The relation must be removed from up to three places: *v and debuggees
     // for sure, and possibly the compartment's debuggee set.
@@ -1357,220 +1364,222 @@ Debug::removeDebuggeeGlobal(JSContext *c
     if (v->empty())
         global->compartment()->removeDebuggee(cx, global, compartmentEnum);
     if (debugEnum)
         debugEnum->removeFront();
     else
         debuggees.remove(global);
 }
 
-JSPropertySpec Debug::properties[] = {
-    JS_PSGS("hooks", Debug::getHooks, Debug::setHooks, 0),
-    JS_PSGS("enabled", Debug::getEnabled, Debug::setEnabled, 0),
-    JS_PSGS("uncaughtExceptionHook", Debug::getUncaughtExceptionHook,
-            Debug::setUncaughtExceptionHook, 0),
+JSPropertySpec Debugger::properties[] = {
+    JS_PSGS("hooks", Debugger::getHooks, Debugger::setHooks, 0),
+    JS_PSGS("enabled", Debugger::getEnabled, Debugger::setEnabled, 0),
+    JS_PSGS("uncaughtExceptionHook", Debugger::getUncaughtExceptionHook,
+            Debugger::setUncaughtExceptionHook, 0),
     JS_PS_END
 };
 
-JSFunctionSpec Debug::methods[] = {
-    JS_FN("addDebuggee", Debug::addDebuggee, 1, 0),
-    JS_FN("removeDebuggee", Debug::removeDebuggee, 1, 0),
-    JS_FN("hasDebuggee", Debug::hasDebuggee, 1, 0),
-    JS_FN("getDebuggees", Debug::getDebuggees, 0, 0),
-    JS_FN("getYoungestFrame", Debug::getYoungestFrame, 0, 0),
-    JS_FN("clearAllBreakpoints", Debug::clearAllBreakpoints, 1, 0),
+JSFunctionSpec Debugger::methods[] = {
+    JS_FN("addDebuggee", Debugger::addDebuggee, 1, 0),
+    JS_FN("removeDebuggee", Debugger::removeDebuggee, 1, 0),
+    JS_FN("hasDebuggee", Debugger::hasDebuggee, 1, 0),
+    JS_FN("getDebuggees", Debugger::getDebuggees, 0, 0),
+    JS_FN("getYoungestFrame", Debugger::getYoungestFrame, 0, 0),
+    JS_FN("clearAllBreakpoints", Debugger::clearAllBreakpoints, 1, 0),
     JS_FS_END
 };
 
 
-// === Debug.Script
+// === Debugger.Script
 
 // JSScripts' lifetimes fall into to two categories:
 //
 // - "Held scripts": JSScripts belonging to JSFunctions and JSScripts created
 //   using JSAPI have lifetimes determined by the garbage collector. A JSScript
 //   itself has no mark bit of its own. Instead, its holding object manages the
 //   JSScript as part of its own structure: the holder has a mark bit; when the
 //   holder is marked it calls js_TraceScript on its JSScript; and when the
 //   holder is freed it explicitly frees its JSScript.
 //
-//   Debug.Script instances for held scripts are strong references to the
-//   holder (and thus to the script). Debug::heldScripts weakly maps debuggee
-//   holding objects to the Debug.Script objects for their JSScripts. We
-//   needn't act on a destroyScript event for a held script: if we get such an
-//   event we know its Debug.Script is dead anyway, and its entry in
-//   Debug::heldScripts will be cleaned up by the standard weak table code.
+//   Debugger.Script instances for held scripts are strong references to the
+//   holder (and thus to the script). Debugger::heldScripts weakly maps
+//   debuggee holding objects to the Debugger.Script objects for their
+//   JSScripts. We needn't act on a destroyScript event for a held script: if
+//   we get such an event we know its Debugger.Script is dead anyway, and its
+//   entry in Debugger::heldScripts will be cleaned up by the standard weak
+//   table code.
 //
 // - "Eval scripts": JSScripts generated temporarily for a call to 'eval' or a
 //   related function live until the call completes, at which point the script
 //   is destroyed.
 //
-//   A Debug.Script instance for an eval script has no influence on the
-//   JSScript's lifetime. Debug::evalScripts maps live JSScripts to to their
-//   Debug.Script objects.  When a destroyScript event tells us that an eval
-//   script is dead, we remove its table entry, and clear its Debug.Script
+//   A Debugger.Script instance for an eval script has no influence on the
+//   JSScript's lifetime. Debugger::evalScripts maps live JSScripts to to their
+//   Debugger.Script objects.  When a destroyScript event tells us that an eval
+//   script is dead, we remove its table entry, and clear its Debugger.Script
 //   object's script pointer, thus marking it dead.
 //
-// A Debug.Script's private pointer points directly to the JSScript, or is NULL
-// if the Debug.Script is dead. The JSSLOT_DEBUGSCRIPT_HOLDER slot refers to
-// the holding object, or is null for eval-like JSScripts. The private pointer
-// is not traced; the holding object reference, if present, is traced via
-// DebugScript_trace.
+// A Debugger.Script's private pointer points directly to the JSScript, or is
+// NULL if the Debugger.Script is dead. The JSSLOT_DEBUGSCRIPT_HOLDER slot
+// refers to the holding object, or is null for eval-like JSScripts. The
+// private pointer is not traced; the holding object reference, if present, is
+// traced via DebuggerScript_trace.
 //
 // (We consider a script saved in and retrieved from the eval cache to have
 // been destroyed, and then --- mirabile dictu --- re-created at the same
 // address. The newScriptHook and destroyScriptHook hooks cooperate with this
 // view.)
 
 static inline JSScript *
 GetScriptReferent(JSObject *obj)
 {
-    JS_ASSERT(obj->getClass() == &DebugScript_class);
+    JS_ASSERT(obj->getClass() == &DebuggerScript_class);
     return (JSScript *) obj->getPrivate();
 }
 
 static inline void
 ClearScriptReferent(JSObject *obj)
 {
-    JS_ASSERT(obj->getClass() == &DebugScript_class);
+    JS_ASSERT(obj->getClass() == &DebuggerScript_class);
     obj->setPrivate(NULL);
 }
 
 static inline JSObject *
 GetScriptHolder(JSObject *obj)
 {
-    JS_ASSERT(obj->getClass() == &DebugScript_class);
+    JS_ASSERT(obj->getClass() == &DebuggerScript_class);
     Value v = obj->getReservedSlot(JSSLOT_DEBUGSCRIPT_HOLDER);
     return (JSObject *) v.toPrivate();
 }
 
 static void
-DebugScript_trace(JSTracer *trc, JSObject *obj)
+DebuggerScript_trace(JSTracer *trc, JSObject *obj)
 {
     if (!trc->context->runtime->gcCurrentCompartment) {
         Value v = obj->getReservedSlot(JSSLOT_DEBUGSCRIPT_HOLDER);
         if (!v.isUndefined()) {
             if (JSObject *obj = (JSObject *) v.toPrivate())
-                MarkObject(trc, *obj, "Debug.Script referent holder");
+                MarkObject(trc, *obj, "Debugger.Script referent holder");
         }
     }
 }
 
-Class DebugScript_class = {
+Class DebuggerScript_class = {
     "Script", JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGSCRIPT_COUNT),
     PropertyStub, PropertyStub, PropertyStub, StrictPropertyStub,
     EnumerateStub, ResolveStub, ConvertStub, NULL,
     NULL,                 /* reserved0   */
     NULL,                 /* checkAccess */
     NULL,                 /* call        */
     NULL,                 /* construct   */
     NULL,                 /* xdrObject   */
     NULL,                 /* hasInstance */
-    DebugScript_trace
+    DebuggerScript_trace
 };
 
 JSObject *
-Debug::newDebugScript(JSContext *cx, JSScript *script, JSObject *holder)
+Debugger::newDebuggerScript(JSContext *cx, JSScript *script, JSObject *holder)
 {
     JSObject *proto = &object->getReservedSlot(JSSLOT_DEBUG_SCRIPT_PROTO).toObject();
     JS_ASSERT(proto);
-    JSObject *scriptobj = NewNonFunction<WithProto::Given>(cx, &DebugScript_class, proto, NULL);
+    JSObject *scriptobj = NewNonFunction<WithProto::Given>(cx, &DebuggerScript_class, proto, NULL);
     if (!scriptobj || !scriptobj->ensureClassReservedSlots(cx))
         return false;
     scriptobj->setPrivate(script);
     scriptobj->setReservedSlot(JSSLOT_DEBUGSCRIPT_OWNER, ObjectValue(*object));
     scriptobj->setReservedSlot(JSSLOT_DEBUGSCRIPT_HOLDER, PrivateValue(holder));
 
     return scriptobj;
 }
 
 JSObject *
-Debug::wrapHeldScript(JSContext *cx, JSScript *script, JSObject *obj)
+Debugger::wrapHeldScript(JSContext *cx, JSScript *script, JSObject *obj)
 {
     assertSameCompartment(cx, object);
 
     ScriptWeakMap::AddPtr p = heldScripts.lookupForAdd(obj);
     if (!p) {
-        JSObject *scriptobj = newDebugScript(cx, script, obj);
+        JSObject *scriptobj = newDebuggerScript(cx, script, obj);
         // The allocation may have caused a GC, which can remove table entries.
         if (!scriptobj || !heldScripts.relookupOrAdd(p, obj, scriptobj))
             return NULL;
     }
 
     JS_ASSERT(GetScriptReferent(p->value) == script);
     return p->value;
 }
 
 JSObject *
-Debug::wrapFunctionScript(JSContext *cx, JSFunction *fun)
+Debugger::wrapFunctionScript(JSContext *cx, JSFunction *fun)
 {
     return wrapHeldScript(cx, fun->script(), fun);
 }
 
 JSObject *
-Debug::wrapJSAPIScript(JSContext *cx, JSObject *obj)
+Debugger::wrapJSAPIScript(JSContext *cx, JSObject *obj)
 {
     JS_ASSERT(obj->isScript());
     return wrapHeldScript(cx, obj->getScript(), obj);
 }
 
 JSObject *
-Debug::wrapEvalScript(JSContext *cx, JSScript *script)
+Debugger::wrapEvalScript(JSContext *cx, JSScript *script)
 {
     JS_ASSERT(cx->compartment != script->compartment);
     ScriptMap::AddPtr p = evalScripts.lookupForAdd(script);
     if (!p) {
-        JSObject *scriptobj = newDebugScript(cx, script, NULL);
+        JSObject *scriptobj = newDebuggerScript(cx, script, NULL);
         // The allocation may have caused a GC, which can remove table entries.
         if (!scriptobj || !evalScripts.relookupOrAdd(p, script, scriptobj))
             return NULL;
     }
 
     JS_ASSERT(GetScriptReferent(p->value) == script);
     return p->value;
 }
 
 void
-Debug::slowPathOnDestroyScript(JSScript *script)
+Debugger::slowPathOnDestroyScript(JSScript *script)
 {
-    // Find all debuggers that might have Debug.Script referring to this script.
+    // Find all debuggers that might have Debugger.Script referring to this script.
     js::GlobalObjectSet *debuggees = &script->compartment->getDebuggees();
     for (GlobalObjectSet::Range r = debuggees->all(); !r.empty(); r.popFront()) {
-        GlobalObject::DebugVector *debuggers = r.front()->getDebuggers();
-        for (Debug **p = debuggers->begin(); p != debuggers->end(); p++)
+        GlobalObject::DebuggerVector *debuggers = r.front()->getDebuggers();
+        for (Debugger **p = debuggers->begin(); p != debuggers->end(); p++)
             (*p)->destroyEvalScript(script);
     }
 }
 
 void
-Debug::destroyEvalScript(JSScript *script)
+Debugger::destroyEvalScript(JSScript *script)
 {
     ScriptMap::Ptr p = evalScripts.lookup(script);
     if (p) {
         JS_ASSERT(GetScriptReferent(p->value) == script);
         ClearScriptReferent(p->value);
         evalScripts.remove(p);
     }
 }
 
 static JSObject *
-DebugScript_check(JSContext *cx, const Value &v, const char *clsname, const char *fnname, bool checkLive)
+DebuggerScript_check(JSContext *cx, const Value &v, const char *clsname, const char *fnname,
+                     bool checkLive)
 {
     if (!v.isObject()) {
         ReportObjectRequired(cx);
         return NULL;
     }
     JSObject *thisobj = &v.toObject();
-    if (thisobj->clasp != &DebugScript_class) {
+    if (thisobj->clasp != &DebuggerScript_class) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
                              clsname, fnname, thisobj->getClass()->name);
         return NULL;
     }
 
-    // Check for Debug.Script.prototype, which is of class DebugScript_class
+    // Check for Debugger.Script.prototype, which is of class DebuggerScript_class
     // but whose holding object is undefined.
     if (thisobj->getReservedSlot(JSSLOT_DEBUGSCRIPT_HOLDER).isUndefined()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
                              clsname, fnname, "prototype object");
         return NULL;
     }
 
     if (checkLive && !GetScriptReferent(thisobj)) {
@@ -1578,46 +1587,46 @@ DebugScript_check(JSContext *cx, const V
                              clsname, fnname, "script");
         return NULL;
     }
 
     return thisobj;
 }
 
 static JSObject *
-DebugScript_checkThis(JSContext *cx, Value *vp, const char *fnname, bool checkLive)
+DebuggerScript_checkThis(JSContext *cx, Value *vp, const char *fnname, bool checkLive)
 {
-    return DebugScript_check(cx, vp[1], "Debug.Script", fnname, checkLive);
+    return DebuggerScript_check(cx, vp[1], "Debugger.Script", fnname, checkLive);
 }
 
 #define THIS_DEBUGSCRIPT_SCRIPT_NEEDLIVE(cx, vp, fnname, obj, script, checkLive)    \
-    JSObject *obj = DebugScript_checkThis(cx, vp, fnname, checkLive);               \
+    JSObject *obj = DebuggerScript_checkThis(cx, vp, fnname, checkLive);            \
     if (!obj)                                                                       \
         return false;                                                               \
     JSScript *script = GetScriptReferent(obj)
 
 #define THIS_DEBUGSCRIPT_SCRIPT(cx, vp, fnname, obj, script)                  \
     THIS_DEBUGSCRIPT_SCRIPT_NEEDLIVE(cx, vp, fnname, obj, script, false)
 #define THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, fnname, obj, script)             \
     THIS_DEBUGSCRIPT_SCRIPT_NEEDLIVE(cx, vp, fnname, obj, script, true)
 
 
 static JSBool
-DebugScript_getLive(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_getLive(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_SCRIPT(cx, vp, "get live", obj, script);
     vp->setBoolean(!!script);
     return true;
 }
 
 static JSBool
-DebugScript_getChildScripts(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_getChildScripts(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "get live", obj, script);
-    Debug *dbg = Debug::fromChildJSObject(obj);
+    Debugger *dbg = Debugger::fromChildJSObject(obj);
 
     JSObject *result = NewDenseEmptyArray(cx);
     if (!result)
         return false;
     if (JSScript::isValidOffset(script->objectsOffset)) {
         JSObjectArray *objects = script->objects();
         for (uint32 i = 0; i < objects->length; i++) {
             JSObject *obj = objects->vector[i];
@@ -1647,19 +1656,19 @@ ScriptOffset(JSContext *cx, JSScript *sc
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_DEBUG_BAD_OFFSET);
         return false;
     }
     *offsetp = off;
     return true;
 }
 
 static JSBool
-DebugScript_getOffsetLine(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_getOffsetLine(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.Script.getOffsetLine", 1);
+    REQUIRE_ARGC("Debugger.Script.getOffsetLine", 1);
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "getOffsetLine", obj, script);
     size_t offset;
     if (!ScriptOffset(cx, script, vp[2], &offset))
         return false;
     uintN lineno = JS_PCToLineNumber(cx, script, script->code + offset);
     vp->setNumber(lineno);
     return true;
 }
@@ -1708,17 +1717,17 @@ class BytecodeRangeWithLineNumbers : pri
     jsbytecode *snpc;
 };
 
 static const size_t NoEdges = -1;
 static const size_t MultipleEdges = -2;
 
 /*
  * FlowGraphSummary::populate(cx, script) computes a summary of script's
- * control flow graph used by DebugScript_{getAllOffsets,getLineOffsets}.
+ * control flow graph used by DebuggerScript_{getAllOffsets,getLineOffsets}.
  *
  * jumpData[offset] is:
  *   - NoEdges if offset isn't the offset of an instruction, or if the
  *     instruction is apparently unreachable;
  *   - MultipleEdges if you can arrive at that instruction from
  *     instructions on multiple different lines OR it's the first
  *     instruction of the script;
  *   - otherwise, the (unique) line number of all instructions that can
@@ -1806,17 +1815,17 @@ class FlowGraphSummary : public Vector<s
         }
 
 
         return true;
     }
 };
 
 static JSBool
-DebugScript_getAllOffsets(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_getAllOffsets(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "getAllOffsets", obj, script);
 
     // First pass: determine which offsets in this script are jump targets and
     // which line numbers jump to them.
     FlowGraphSummary flowData(cx);
     if (!flowData.populate(cx, script))
         return false;
@@ -1860,20 +1869,20 @@ DebugScript_getAllOffsets(JSContext *cx,
         }
     }
 
     vp->setObject(*result);
     return true;
 }
 
 static JSBool
-DebugScript_getLineOffsets(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_getLineOffsets(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "getAllOffsets", obj, script);
-    REQUIRE_ARGC("Debug.Script.getLineOffsets", 1);
+    REQUIRE_ARGC("Debugger.Script.getLineOffsets", 1);
 
     // Parse lineno argument.
     size_t lineno;
     bool ok = false;
     if (vp[2].isNumber()) {
         jsdouble d = vp[2].toNumber();
         lineno = size_t(d);
         ok = (lineno == d);
@@ -1906,21 +1915,21 @@ DebugScript_getLineOffsets(JSContext *cx
         }
     }
 
     vp->setObject(*result);
     return true;
 }
 
 JSBool
-DebugScript_setBreakpoint(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_setBreakpoint(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.Script.setBreakpoint", 2);
+    REQUIRE_ARGC("Debugger.Script.setBreakpoint", 2);
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "setBreakpoint", obj, script);
-    Debug *dbg = Debug::fromChildJSObject(obj);
+    Debugger *dbg = Debugger::fromChildJSObject(obj);
 
     JSObject *holder = GetScriptHolder(obj);
     if (!dbg->observesScope(ScriptScope(cx, script, holder))) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_DEBUG_NOT_DEBUGGING);
         return false;
     }
 
     size_t offset;
@@ -1944,20 +1953,20 @@ DebugScript_setBreakpoint(JSContext *cx,
 fail2:
     site->dec(cx);
 fail1:
     site->destroyIfEmpty(cx->runtime, NULL);
     return false;
 }
 
 JSBool
-DebugScript_getBreakpoints(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_getBreakpoints(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "getBreakpoints", obj, script);
-    Debug *dbg = Debug::fromChildJSObject(obj);
+    Debugger *dbg = Debugger::fromChildJSObject(obj);
 
     jsbytecode *pc;
     if (argc > 0) {
         size_t offset;
         if (!ScriptOffset(cx, script, vp[2], &offset))
             return false;
         pc = script->code + offset;
     } else {
@@ -1980,100 +1989,101 @@ DebugScript_getBreakpoints(JSContext *cx
             }
         }
     }
     vp->setObject(*arr);
     return true;
 }
 
 JSBool
-DebugScript_clearBreakpoint(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_clearBreakpoint(JSContext *cx, uintN argc, Value *vp)
 {
-    REQUIRE_ARGC("Debug.Script.clearBreakpoint", 1);
+    REQUIRE_ARGC("Debugger.Script.clearBreakpoint", 1);
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "clearBreakpoint", obj, script);
-    Debug *dbg = Debug::fromChildJSObject(obj);
+    Debugger *dbg = Debugger::fromChildJSObject(obj);
 
     JSObject *handler = NonNullObject(cx, vp[2]);
     if (!handler)
         return false;
 
     script->compartment->clearBreakpointsIn(cx, dbg, script, handler);
     vp->setUndefined();
     return true;
 }
 
 JSBool
-DebugScript_clearAllBreakpoints(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_clearAllBreakpoints(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_LIVE_SCRIPT(cx, vp, "clearBreakpoint", obj, script);
-    Debug *dbg = Debug::fromChildJSObject(obj);
+    Debugger *dbg = Debugger::fromChildJSObject(obj);
     script->compartment->clearBreakpointsIn(cx, dbg, script, NULL);
     vp->setUndefined();
     return true;
 }
 
 static JSBool
-DebugScript_construct(JSContext *cx, uintN argc, Value *vp)
+DebuggerScript_construct(JSContext *cx, uintN argc, Value *vp)
 {
-    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NO_CONSTRUCTOR, "Debug.Script");
+    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NO_CONSTRUCTOR, "Debugger.Script");
     return false;
 }
 
-static JSPropertySpec DebugScript_properties[] = {
-    JS_PSG("live", DebugScript_getLive, 0),
+static JSPropertySpec DebuggerScript_properties[] = {
+    JS_PSG("live", DebuggerScript_getLive, 0),
     JS_PS_END
 };
 
-static JSFunctionSpec DebugScript_methods[] = {
-    JS_FN("getChildScripts", DebugScript_getChildScripts, 0, 0),
-    JS_FN("getAllOffsets", DebugScript_getAllOffsets, 0, 0),
-    JS_FN("getLineOffsets", DebugScript_getLineOffsets, 1, 0),
-    JS_FN("getOffsetLine", DebugScript_getOffsetLine, 0, 0),
-    JS_FN("setBreakpoint", DebugScript_setBreakpoint, 2, 0),
-    JS_FN("getBreakpoints", DebugScript_getBreakpoints, 1, 0),
-    JS_FN("clearBreakpoint", DebugScript_clearBreakpoint, 1, 0),
-    JS_FN("clearAllBreakpoints", DebugScript_clearAllBreakpoints, 0, 0),
+static JSFunctionSpec DebuggerScript_methods[] = {
+    JS_FN("getChildScripts", DebuggerScript_getChildScripts, 0, 0),
+    JS_FN("getAllOffsets", DebuggerScript_getAllOffsets, 0, 0),
+    JS_FN("getLineOffsets", DebuggerScript_getLineOffsets, 1, 0),
+    JS_FN("getOffsetLine", DebuggerScript_getOffsetLine, 0, 0),
+    JS_FN("setBreakpoint", DebuggerScript_setBreakpoint, 2, 0),
+    JS_FN("getBreakpoints", DebuggerScript_getBreakpoints, 1, 0),
+    JS_FN("clearBreakpoint", DebuggerScript_clearBreakpoint, 1, 0),
+    JS_FN("clearAllBreakpoints", DebuggerScript_clearAllBreakpoints, 0, 0),
     JS_FS_END
 };
 
 
-// === Debug.Frame
+// === Debugger.Frame
 
-Class DebugFrame_class = {
+Class DebuggerFrame_class = {
     "Frame", JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGFRAME_COUNT),
     PropertyStub, PropertyStub, PropertyStub, StrictPropertyStub,
     EnumerateStub, ResolveStub, ConvertStub
 };
 
 static JSObject *
 CheckThisFrame(JSContext *cx, Value *vp, const char *fnname, bool checkLive)
 {
     if (!vp[1].isObject()) {
         ReportObjectRequired(cx);
         return NULL;
     }
     JSObject *thisobj = &vp[1].toObject();
-    if (thisobj->getClass() != &DebugFrame_class) {
+    if (thisobj->getClass() != &DebuggerFrame_class) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
-                             "Debug.Frame", fnname, thisobj->getClass()->name);
+                             "Debugger.Frame", fnname, thisobj->getClass()->name);
         return NULL;
     }
 
-    // Forbid Debug.Frame.prototype, which is of class DebugFrame_class but
-    // isn't really a working Debug.Frame object. The prototype object is
-    // distinguished by having a NULL private value. Also, forbid popped frames.
+    // Forbid Debugger.Frame.prototype, which is of class DebuggerFrame_class
+    // but isn't really a working Debugger.Frame object. The prototype object
+    // is distinguished by having a NULL private value. Also, forbid popped
+    // frames.
     if (!thisobj->getPrivate()) {
         if (thisobj->getReservedSlot(JSSLOT_DEBUGFRAME_OWNER).isUndefined()) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
-                                 "Debug.Frame", fnname, "prototype object");
+                                 "Debugger.Frame", fnname, "prototype object");
             return NULL;
         }
         if (checkLive) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_DEBUG_NOT_LIVE,
-                                 "Debug.Frame", fnname, "stack frame");
+                                 "Debugger.Frame", fnname, "stack frame");
             return NULL;
         }
     }
     return thisobj;
 }
 
 #if DEBUG
 static bool
@@ -2090,158 +2100,159 @@ StackContains(JSContext *cx, StackFrame 
 #define THIS_FRAME(cx, vp, fnname, thisobj, fp)                              \
     JSObject *thisobj = CheckThisFrame(cx, vp, fnname, true);                \
     if (!thisobj)                                                            \
         return false;                                                        \
     StackFrame *fp = (StackFrame *) thisobj->getPrivate();                   \
     JS_ASSERT(StackContains(cx, fp))
 
 static JSBool
-DebugFrame_getType(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getType(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get type", thisobj, fp);
 
     // Indirect eval frames are both isGlobalFrame() and isEvalFrame(), so the
     // order of checks here is significant.
     vp->setString(fp->isEvalFrame()
                   ? cx->runtime->atomState.evalAtom
                   : fp->isGlobalFrame()
                   ? cx->runtime->atomState.globalAtom
                   : cx->runtime->atomState.callAtom);
     return true;
 }
 
 static JSBool
-DebugFrame_getCallee(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getCallee(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get callee", thisobj, fp);
     *vp = (fp->isFunctionFrame() && !fp->isEvalFrame()) ? fp->calleev() : NullValue();
-    return Debug::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, vp);
+    return Debugger::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, vp);
 }
 
 static JSBool
-DebugFrame_getGenerator(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getGenerator(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get generator", thisobj, fp);
     vp->setBoolean(fp->isGeneratorFrame());
     return true;
 }
 
 static JSBool
-DebugFrame_getConstructing(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getConstructing(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get constructing", thisobj, fp);
     vp->setBoolean(fp->isFunctionFrame() && fp->isConstructing());
     return true;
 }
 
 static JSBool
-DebugFrame_getThis(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getThis(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get this", thisobj, fp);
     {
         AutoCompartment ac(cx, &fp->scopeChain());
         if (!ac.enter())
             return false;
         if (!ComputeThis(cx, fp))
             return false;
         *vp = fp->thisValue();
     }
-    return Debug::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, vp);
+    return Debugger::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, vp);
 }
 
 static JSBool
-DebugFrame_getOlder(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getOlder(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get this", thisobj, thisfp);
-    Debug *dbg = Debug::fromChildJSObject(thisobj);
+    Debugger *dbg = Debugger::fromChildJSObject(thisobj);
     for (StackFrame *fp = thisfp->prev(); fp; fp = fp->prev()) {
         if (!fp->isDummyFrame() && dbg->observesFrame(fp))
             return dbg->getScriptFrame(cx, fp, vp);
     }
     vp->setNull();
     return true;
 }
 
-Class DebugArguments_class = {
+Class DebuggerArguments_class = {
     "Arguments", JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGARGUMENTS_COUNT),
     PropertyStub, PropertyStub, PropertyStub, StrictPropertyStub,
     EnumerateStub, ResolveStub, ConvertStub
 };
 
-// The getter used for each element of frame.arguments. See DebugFrame_getArguments.
+// The getter used for each element of frame.arguments. See DebuggerFrame_getArguments.
 JSBool
-DebugArguments_getArg(JSContext *cx, uintN argc, Value *vp)
+DebuggerArguments_getArg(JSContext *cx, uintN argc, Value *vp)
 {
     JSObject *callee = &CallArgsFromVp(argc, vp).callee();
     int32 i = callee->getReservedSlot(0).toInt32();
 
     // Check that the this value is an Arguments object.
     if (!vp[1].isObject()) {
         ReportObjectRequired(cx);
         return false;
     }
     JSObject *argsobj = &vp[1].toObject();
-    if (argsobj->getClass() != &DebugArguments_class) {
+    if (argsobj->getClass() != &DebuggerArguments_class) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
                              "Arguments", "getArgument", argsobj->getClass()->name);
         return false;
     }
 
-    // Put the Debug.Frame into the this-value slot, then use THIS_FRAME
+    // Put the Debugger.Frame into the this-value slot, then use THIS_FRAME
     // to check that it is still live and get the fp.
     vp[1] = argsobj->getReservedSlot(JSSLOT_DEBUGARGUMENTS_FRAME);
     THIS_FRAME(cx, vp, "get argument", thisobj, fp);
 
     // Since getters can be extracted and applied to other objects,
     // there is no guarantee this object has an ith argument.
     JS_ASSERT(i >= 0);
     if (uintN(i) < fp->numActualArgs())
         *vp = fp->actualArgs()[i];
     else
         vp->setUndefined();
-    return Debug::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, vp);
+    return Debugger::fromChildJSObject(thisobj)->wrapDebuggeeValue(cx, vp);
 }
 
 JSBool
-DebugFrame_getArguments(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getArguments(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get arguments", thisobj, fp);
     Value argumentsv = thisobj->getReservedSlot(JSSLOT_DEBUGFRAME_ARGUMENTS);
     if (!argumentsv.isUndefined()) {
         JS_ASSERT(argumentsv.isObjectOrNull());
         *vp = argumentsv;
         return true;
     }
 
     JSObject *argsobj;
     if (fp->hasArgs()) {
         // Create an arguments object.
         GlobalObject *global = CallArgsFromVp(argc, vp).callee().getGlobal();
         JSObject *proto;
         if (!js_GetClassPrototype(cx, global, JSProto_Array, &proto))
             return false;
-        argsobj = NewNonFunction<WithProto::Given>(cx, &DebugArguments_class, proto, global);
+        argsobj = NewNonFunction<WithProto::Given>(cx, &DebuggerArguments_class, proto, global);
         if (!argsobj ||
             !js_SetReservedSlot(cx, argsobj, JSSLOT_DEBUGARGUMENTS_FRAME, ObjectValue(*thisobj)))
         {
             return false;
         }
 
         JS_ASSERT(fp->numActualArgs() <= 0x7fffffff);
         int32 fargc = int32(fp->numActualArgs());
         if (!DefineNativeProperty(cx, argsobj, ATOM_TO_JSID(cx->runtime->atomState.lengthAtom),
                                   Int32Value(fargc), NULL, NULL,
                                   JSPROP_PERMANENT | JSPROP_READONLY, 0, 0))
         {
             return false;
         }
 
         for (int32 i = 0; i < fargc; i++) {
-            JSObject *getobj = js_NewFunction(cx, NULL, DebugArguments_getArg, 0, 0, global, NULL);
+            JSObject *getobj =
+                js_NewFunction(cx, NULL, DebuggerArguments_getArg, 0, 0, global, NULL);
             if (!getobj ||
                 !js_SetReservedSlot(cx, getobj, 0, Int32Value(i)) ||
                 !DefineNativeProperty(cx, argsobj, INT_TO_JSID(i), UndefinedValue(),
                                       JS_DATA_TO_FUNC_PTR(PropertyOp, getobj), NULL,
                                       JSPROP_ENUMERATE | JSPROP_SHARED | JSPROP_GETTER, 0, 0))
             {
                 return false;
             }
@@ -2250,20 +2261,20 @@ DebugFrame_getArguments(JSContext *cx, u
         argsobj = NULL;
     }
     *vp = ObjectOrNullValue(argsobj);
     thisobj->setReservedSlot(JSSLOT_DEBUGFRAME_ARGUMENTS, *vp);
     return true;
 }
 
 static JSBool
-DebugFrame_getScript(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getScript(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get script", thisobj, fp);
-    Debug *debug = Debug::fromChildJSObject(thisobj);
+    Debugger *debug = Debugger::fromChildJSObject(thisobj);
 
     JSObject *scriptObject = NULL;
     if (fp->isFunctionFrame() && !fp->isEvalFrame()) {
         JSFunction *callee = fp->callee().getFunctionPrivate();
         if (callee->isInterpreted()) {
             scriptObject = debug->wrapFunctionScript(cx, callee);
             if (!scriptObject)
                 return false;
@@ -2289,34 +2300,34 @@ DebugFrame_getScript(JSContext *cx, uint
                 return false;
         }
     }
     vp->setObjectOrNull(scriptObject);
     return true;
 }
 
 static JSBool
-DebugFrame_getOffset(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getOffset(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_FRAME(cx, vp, "get offset", thisobj, fp);
     if (fp->isScriptFrame()) {
         JSScript *script = fp->script();
         jsbytecode *pc = fp->pcQuadratic(cx);
         JS_ASSERT(script->code <= pc);
         JS_ASSERT(pc < script->code + script->length);
         size_t offset = pc - script->code;
         vp->setNumber(double(offset));
     } else {
         vp->setUndefined();
     }
     return true;
 }
 
 static JSBool
-DebugFrame_getLive(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_getLive(JSContext *cx, uintN argc, Value *vp)
 {
     JSObject *thisobj = CheckThisFrame(cx, vp, "get live", false);
     if (!thisobj)
         return false;
     StackFrame *fp = (StackFrame *) thisobj->getPrivate();
     vp->setBoolean(!!fp);
     return true;
 }
@@ -2348,27 +2359,27 @@ EvaluateInScope(JSContext *cx, JSObject 
     return ok;
 }
 
 }
 
 enum EvalBindingsMode { WithoutBindings, WithBindings };
 
 static JSBool
-DebugFrameEval(JSContext *cx, uintN argc, Value *vp, EvalBindingsMode mode)
+DebuggerFrameEval(JSContext *cx, uintN argc, Value *vp, EvalBindingsMode mode)
 {
-    REQUIRE_ARGC(mode == WithBindings ? "Debug.Frame.evalWithBindings" : "Debug.Frame.eval",
+    REQUIRE_ARGC(mode == WithBindings ? "Debugger.Frame.evalWithBindings" : "Debugger.Frame.eval",
                  uintN(mode == WithBindings ? 2 : 1));
     THIS_FRAME(cx, vp, mode == WithBindings ? "evalWithBindings" : "eval", thisobj, fp);
-    Debug *dbg = Debug::fromChildJSObject(&vp[1].toObject());
+    Debugger *dbg = Debugger::fromChildJSObject(&vp[1].toObject());
 
     // Check the first argument, the eval code string.
     if (!vp[2].isString()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NOT_EXPECTED_TYPE,
-                             "Debug.Frame.eval", "string", InformalValueTypeName(vp[2]));
+                             "Debugger.Frame.eval", "string", InformalValueTypeName(vp[2]));
         return false;
     }
     JSLinearString *linearStr = vp[2].toString()->ensureLinear(cx);
     if (!linearStr)
         return false;
 
     // Gather keys and values of bindings, if any. This must be done in the
     // debugger compartment, since that is where any exceptions must be
@@ -2423,156 +2434,156 @@ DebugFrameEval(JSContext *cx, uintN argc
     Value rval;
     JS::Anchor<JSString *> anchor(linearStr);
     bool ok = EvaluateInScope(cx, scobj, fp, linearStr->chars(), linearStr->length(),
                               "debugger eval code", 1, &rval);
     return dbg->newCompletionValue(ac, ok, rval, vp);
 }
 
 static JSBool
-DebugFrame_eval(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_eval(JSContext *cx, uintN argc, Value *vp)
 {
-    return DebugFrameEval(cx, argc, vp, WithoutBindings);
+    return DebuggerFrameEval(cx, argc, vp, WithoutBindings);
 }
 
 static JSBool
-DebugFrame_evalWithBindings(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_evalWithBindings(JSContext *cx, uintN argc, Value *vp)
 {
-    return DebugFrameEval(cx, argc, vp, WithBindings);
+    return DebuggerFrameEval(cx, argc, vp, WithBindings);
 }
 
 static JSBool
-DebugFrame_construct(JSContext *cx, uintN argc, Value *vp)
+DebuggerFrame_construct(JSContext *cx, uintN argc, Value *vp)
 {
-    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NO_CONSTRUCTOR, "Debug.Frame");
+    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NO_CONSTRUCTOR, "Debugger.Frame");
     return false;
 }
 
-static JSPropertySpec DebugFrame_properties[] = {
-    JS_PSG("arguments", DebugFrame_getArguments, 0),
-    JS_PSG("callee", DebugFrame_getCallee, 0),
-    JS_PSG("constructing", DebugFrame_getConstructing, 0),
-    JS_PSG("generator", DebugFrame_getGenerator, 0),
-    JS_PSG("live", DebugFrame_getLive, 0),
-    JS_PSG("offset", DebugFrame_getOffset, 0),
-    JS_PSG("older", DebugFrame_getOlder, 0),
-    JS_PSG("script", DebugFrame_getScript, 0),
-    JS_PSG("this", DebugFrame_getThis, 0),
-    JS_PSG("type", DebugFrame_getType, 0),
+static JSPropertySpec DebuggerFrame_properties[] = {
+    JS_PSG("arguments", DebuggerFrame_getArguments, 0),
+    JS_PSG("callee", DebuggerFrame_getCallee, 0),
+    JS_PSG("constructing", DebuggerFrame_getConstructing, 0),
+    JS_PSG("generator", DebuggerFrame_getGenerator, 0),
+    JS_PSG("live", DebuggerFrame_getLive, 0),
+    JS_PSG("offset", DebuggerFrame_getOffset, 0),
+    JS_PSG("older", DebuggerFrame_getOlder, 0),
+    JS_PSG("script", DebuggerFrame_getScript, 0),
+    JS_PSG("this", DebuggerFrame_getThis, 0),
+    JS_PSG("type", DebuggerFrame_getType, 0),
     JS_PS_END
 };
 
-static JSFunctionSpec DebugFrame_methods[] = {
-    JS_FN("eval", DebugFrame_eval, 1, 0),
-    JS_FN("evalWithBindings", DebugFrame_evalWithBindings, 1, 0),
+static JSFunctionSpec DebuggerFrame_methods[] = {
+    JS_FN("eval", DebuggerFrame_eval, 1, 0),
+    JS_FN("evalWithBindings", DebuggerFrame_evalWithBindings, 1, 0),
     JS_FS_END
 };
 
 
-// === Debug.Object
+// === Debugger.Object
 
 static void
-DebugObject_trace(JSTracer *trc, JSObject *obj)
+DebuggerObject_trace(JSTracer *trc, JSObject *obj)
 {
     if (!trc->context->runtime->gcCurrentCompartment) {
         if (JSObject *referent = (JSObject *) obj->getPrivate())
-            MarkObject(trc, *referent, "Debug.Object referent");
+            MarkObject(trc, *referent, "Debugger.Object referent");
     }
 }
 
-Class DebugObject_class = {
+Class DebuggerObject_class = {
     "Object", JSCLASS_HAS_PRIVATE | JSCLASS_HAS_RESERVED_SLOTS(JSSLOT_DEBUGOBJECT_COUNT),
     PropertyStub, PropertyStub, PropertyStub, StrictPropertyStub,
     EnumerateStub, ResolveStub, ConvertStub, NULL,
     NULL,                 /* reserved0   */
     NULL,                 /* checkAccess */
     NULL,                 /* call        */
     NULL,                 /* construct   */
     NULL,                 /* xdrObject   */
     NULL,                 /* hasInstance */
-    DebugObject_trace
+    DebuggerObject_trace
 };
 
 static JSObject *
-DebugObject_checkThis(JSContext *cx, Value *vp, const char *fnname)
+DebuggerObject_checkThis(JSContext *cx, Value *vp, const char *fnname)
 {
     if (!vp[1].isObject()) {
         ReportObjectRequired(cx);
         return NULL;
     }
     JSObject *thisobj = &vp[1].toObject();
-    if (thisobj->clasp != &DebugObject_class) {
+    if (thisobj->clasp != &DebuggerObject_class) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
-                             "Debug.Object", fnname, thisobj->getClass()->name);
+                             "Debugger.Object", fnname, thisobj->getClass()->name);
         return NULL;
     }
 
-    // Forbid Debug.Object.prototype, which is of class DebugObject_class
-    // but isn't a real working Debug.Object. The prototype object is
+    // Forbid Debugger.Object.prototype, which is of class DebuggerObject_class
+    // but isn't a real working Debugger.Object. The prototype object is
     // distinguished by having no referent.
     if (!thisobj->getPrivate()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
-                             "Debug.Object", fnname, "prototype object");
+                             "Debugger.Object", fnname, "prototype object");
         return NULL;
     }
     return thisobj;
 }
 
 #define THIS_DEBUGOBJECT_REFERENT(cx, vp, fnname, obj)                        \
-    JSObject *obj = DebugObject_checkThis(cx, vp, fnname);                    \
+    JSObject *obj = DebuggerObject_checkThis(cx, vp, fnname);                 \
     if (!obj)                                                                 \
         return false;                                                         \
     obj = (JSObject *) obj->getPrivate();                                     \
     JS_ASSERT(obj)
 
 #define THIS_DEBUGOBJECT_OWNER_REFERENT(cx, vp, fnname, dbg, obj)             \
-    JSObject *obj = DebugObject_checkThis(cx, vp, fnname);                    \
+    JSObject *obj = DebuggerObject_checkThis(cx, vp, fnname);                 \
     if (!obj)                                                                 \
         return false;                                                         \
-    Debug *dbg = Debug::fromChildJSObject(obj);                               \
+    Debugger *dbg = Debugger::fromChildJSObject(obj);                         \
     obj = (JSObject *) obj->getPrivate();                                     \
     JS_ASSERT(obj)
 
 static JSBool
-DebugObject_construct(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_construct(JSContext *cx, uintN argc, Value *vp)
 {
-    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NO_CONSTRUCTOR, "Debug.Object");
+    JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_NO_CONSTRUCTOR, "Debugger.Object");
     return false;
 }
 
 static JSBool
-DebugObject_getProto(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_getProto(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGOBJECT_OWNER_REFERENT(cx, vp, "get proto", dbg, refobj);
     vp->setObjectOrNull(refobj->getProto());
     return dbg->wrapDebuggeeValue(cx, vp);
 }
 
 static JSBool
-DebugObject_getClass(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_getClass(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGOBJECT_REFERENT(cx, vp, "get class", refobj);
     const char *s = refobj->clasp->name;
     JSAtom *str = js_Atomize(cx, s, strlen(s));
     if (!str)
         return false;
     vp->setString(str);
     return true;
 }
 
 static JSBool
-DebugObject_getCallable(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_getCallable(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGOBJECT_REFERENT(cx, vp, "get callable", refobj);
     vp->setBoolean(refobj->isCallable());
     return true;
 }
 
 static JSBool
-DebugObject_getName(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_getName(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGOBJECT_OWNER_REFERENT(cx, vp, "get name", dbg, obj);
     if (!obj->isFunction()) {
         vp->setUndefined();
         return true;
     }
 
     JSString *name = obj->getFunctionPrivate()->atom;
@@ -2581,17 +2592,17 @@ DebugObject_getName(JSContext *cx, uintN
         return true;
     }
 
     vp->setString(name);
     return dbg->wrapDebuggeeValue(cx, vp);
 }
 
 static JSBool
-DebugObject_getParameterNames(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_getParameterNames(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGOBJECT_REFERENT(cx, vp, "get parameterNames", obj);
     if (!obj->isFunction()) {
         vp->setUndefined();
         return true;
     }
 
     const JSFunction *fun = obj->getFunctionPrivate();
@@ -2621,17 +2632,17 @@ DebugObject_getParameterNames(JSContext 
             result->addressOfDenseArrayElement(i)->setUndefined();
     }
 
     vp->setObject(*result);
     return true;
 }
 
 static JSBool
-DebugObject_getScript(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_getScript(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGOBJECT_OWNER_REFERENT(cx, vp, "get script", dbg, obj);
 
     vp->setUndefined();
 
     if (!obj->isFunction())
         return true;
 
@@ -2654,32 +2665,33 @@ ApplyOrCall(JSContext *cx, uintN argc, V
 {
     THIS_DEBUGOBJECT_OWNER_REFERENT(cx, vp, "apply", dbg, obj);
 
     // Any JS exceptions thrown must be in the debugger compartment, so do
     // sanity checks and fallible conversions before entering the debuggee.
     Value calleev = ObjectValue(*obj);
     if (!obj->isCallable()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_INCOMPATIBLE_PROTO,
-                             "Debug.Object", "apply", obj->getClass()->name);
+                             "Debugger.Object", "apply", obj->getClass()->name);
         return false;
     }
 
-    // Unwrap Debug.Objects. This happens in the debugger's compartment since
+    // Unwrap Debugger.Objects. This happens in the debugger's compartment since
     // that is where any exceptions must be reported.
     Value thisv = argc > 0 ? vp[2] : UndefinedValue();
     if (!dbg->unwrapDebuggeeValue(cx, &thisv))
         return false;
     uintN callArgc = 0;
     Value *callArgv = NULL;
     AutoValueVector argv(cx);
     if (mode == ApplyMode) {
         if (argc >= 2 && !vp[3].isNullOrUndefined()) {
             if (!vp[3].isObject()) {
-                JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_APPLY_ARGS, js_apply_str);
+                JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_APPLY_ARGS,
+                                     js_apply_str);
                 return false;
             }
             JSObject *argsobj = &vp[3].toObject();
             if (!js_GetLengthProperty(cx, argsobj, &callArgc))
                 return false;
             callArgc = uintN(JS_MIN(callArgc, JS_ARGS_LENGTH_MAX));
             if (!argv.growBy(callArgc) || !GetElements(cx, argsobj, callArgc, argv.begin()))
                 return false;
@@ -2707,78 +2719,80 @@ ApplyOrCall(JSContext *cx, uintN argc, V
     // Call the function. Use newCompletionValue to return to the debugger
     // compartment and populate *vp.
     Value rval;
     bool ok = ExternalInvoke(cx, thisv, calleev, callArgc, callArgv, &rval);
     return dbg->newCompletionValue(ac, ok, rval, vp);
 }
 
 static JSBool
-DebugObject_apply(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_apply(JSContext *cx, uintN argc, Value *vp)
 {
     return ApplyOrCall(cx, argc, vp, ApplyMode);
 }
 
 static JSBool
-DebugObject_call(JSContext *cx, uintN argc, Value *vp)
+DebuggerObject_call(JSContext *cx, uintN argc, Value *vp)
 {
     return ApplyOrCall(cx, argc, vp, CallMode);
 }
 
-static JSPropertySpec DebugObject_properties[] = {
-    JS_PSG("proto", DebugObject_getProto, 0),
-    JS_PSG("class", DebugObject_getClass, 0),
-    JS_PSG("callable", DebugObject_getCallable, 0),
-    JS_PSG("name", DebugObject_getName, 0),
-    JS_PSG("parameterNames", DebugObject_getParameterNames, 0),
-    JS_PSG("script", DebugObject_getScript, 0),
+static JSPropertySpec DebuggerObject_properties[] = {
+    JS_PSG("proto", DebuggerObject_getProto, 0),
+    JS_PSG("class", DebuggerObject_getClass, 0),
+    JS_PSG("callable", DebuggerObject_getCallable, 0),
+    JS_PSG("name", DebuggerObject_getName, 0),
+    JS_PSG("parameterNames", DebuggerObject_getParameterNames, 0),
+    JS_PSG("script", DebuggerObject_getScript, 0),
     JS_PS_END
 };
 
-static JSFunctionSpec DebugObject_methods[] = {
-    JS_FN("apply", DebugObject_apply, 0, 0),
-    JS_FN("call", DebugObject_call, 0, 0),
+static JSFunctionSpec DebuggerObject_methods[] = {
+    JS_FN("apply", DebuggerObject_apply, 0, 0),
+    JS_FN("call", DebuggerObject_call, 0, 0),
     JS_FS_END
 };
 
 
 // === Glue
 
 extern JS_PUBLIC_API(JSBool)
-JS_DefineDebugObject(JSContext *cx, JSObject *obj)
+JS_DefineDebuggerObject(JSContext *cx, JSObject *obj)
 {
     JSObject *objProto;
     if (!js_GetClassPrototype(cx, obj, JSProto_Object, &objProto))
         return false;
 
     JSObject *debugCtor;
-    JSObject *debugProto = js_InitClass(cx, obj, objProto, &Debug::jsclass, Debug::construct, 1,
-                                        Debug::properties, Debug::methods, NULL, NULL, &debugCtor);
+    JSObject *debugProto = js_InitClass(cx, obj, objProto, &Debugger::jsclass, Debugger::construct,
+                                        1, Debugger::properties, Debugger::methods, NULL, NULL,
+                                        &debugCtor);
     if (!debugProto || !debugProto->ensureClassReservedSlots(cx))
         return false;
 
     JSObject *frameCtor;
-    JSObject *frameProto = js_InitClass(cx, debugCtor, objProto, &DebugFrame_class,
-                                        DebugFrame_construct, 0,
-                                        DebugFrame_properties, DebugFrame_methods, NULL, NULL,
-                                        &frameCtor);
+    JSObject *frameProto = js_InitClass(cx, debugCtor, objProto, &DebuggerFrame_class,
+                                        DebuggerFrame_construct, 0,
+                                        DebuggerFrame_properties, DebuggerFrame_methods,
+                                        NULL, NULL, &frameCtor);
     if (!frameProto)
         return false;
 
     JSObject *scriptCtor;
-    JSObject *scriptProto = js_InitClass(cx, debugCtor, objProto, &DebugScript_class,
-                                         DebugScript_construct, 0,
-                                         DebugScript_properties, DebugScript_methods, NULL, NULL,
-                                         &scriptCtor);
+    JSObject *scriptProto = js_InitClass(cx, debugCtor, objProto, &DebuggerScript_class,
+                                         DebuggerScript_construct, 0,
+                                         DebuggerScript_properties, DebuggerScript_methods,
+                                         NULL, NULL, &scriptCtor);
     if (!scriptProto || !scriptProto->ensureClassReservedSlots(cx))
         return false;
 
-    JSObject *objectProto = js_InitClass(cx, debugCtor, objProto, &DebugObject_class,
-                                         DebugObject_construct, 0,
-                                         DebugObject_properties, DebugObject_methods, NULL, NULL);
+    JSObject *objectProto = js_InitClass(cx, debugCtor, objProto, &DebuggerObject_class,
+                                         DebuggerObject_construct, 0,
+                                         DebuggerObject_properties, DebuggerObject_methods,
+                                         NULL, NULL);
     if (!objectProto)
         return false;
 
     debugProto->setReservedSlot(JSSLOT_DEBUG_FRAME_PROTO, ObjectValue(*frameProto));
     debugProto->setReservedSlot(JSSLOT_DEBUG_OBJECT_PROTO, ObjectValue(*objectProto));
     debugProto->setReservedSlot(JSSLOT_DEBUG_SCRIPT_PROTO, ObjectValue(*scriptProto));
     return true;
 }
--- a/js/src/jsdbg.h
+++ b/js/src/jsdbg.h
@@ -9,17 +9,17 @@
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  * for the specific language governing rights and limitations under the
  * License.
  *
- * The Original Code is SpiderMonkey Debug object.
+ * The Original Code is SpiderMonkey Debugger object.
  *
  * The Initial Developer of the Original Code is
  * Mozilla Foundation.
  * Portions created by the Initial Developer are Copyright (C) 1998-1999
  * the Initial Developer. All Rights Reserved.
  *
  * Contributors:
  *   Jim Blandy <jimb@mozilla.com>
@@ -49,25 +49,25 @@
 #include "jshashtable.h"
 #include "jsweakmap.h"
 #include "jswrapper.h"
 #include "jsvalue.h"
 #include "vm/GlobalObject.h"
 
 namespace js {
 
-class Debug {
+class Debugger {
     friend class js::Breakpoint;
-    friend JSBool (::JS_DefineDebugObject)(JSContext *cx, JSObject *obj);
+    friend JSBool (::JS_DefineDebuggerObject)(JSContext *cx, JSObject *obj);
 
   private:
     JSCList link;                       // See JSRuntime::debuggerList.
-    JSObject *object;                   // The Debug object. Strong reference.
+    JSObject *object;                   // The Debugger object. Strong reference.
     GlobalObjectSet debuggees;          // Debuggee globals. Cross-compartment weak references.
-    JSObject *hooksObject;              // See Debug.prototype.hooks. Strong reference.
+    JSObject *hooksObject;              // See Debugger.prototype.hooks. Strong reference.
     JSObject *uncaughtExceptionHook;    // Strong reference.
     bool enabled;
 
     // True if hooksObject had a property of the respective name when the hooks
     // property was set.
     bool hasDebuggerHandler;            // hooks.debuggerHandler
     bool hasThrowHandler;               // hooks.throw
 
@@ -75,39 +75,39 @@ class Debug {
 
     // Weak references to stack frames that are currently on the stack and thus
     // necessarily alive. We drop them as soon as they leave the stack (see
     // slowPathLeaveStackFrame) and in removeDebuggee.
     typedef HashMap<StackFrame *, JSObject *, DefaultHasher<StackFrame *>, SystemAllocPolicy>
         FrameMap;
     FrameMap frames;
 
-    // The map from debuggee objects to their Debug.Object instances.
+    // The map from debuggee objects to their Debugger.Object instances.
     typedef WeakMap<JSObject *, JSObject *, DefaultHasher<JSObject *>, CrossCompartmentMarkPolicy>
         ObjectWeakMap;
     ObjectWeakMap objects;
 
-    // An ephemeral map from script-holding objects to Debug.Script instances.
+    // An ephemeral map from script-holding objects to Debugger.Script instances.
     typedef WeakMap<JSObject *, JSObject *, DefaultHasher<JSObject *>, CrossCompartmentMarkPolicy>
         ScriptWeakMap;
 
-    // Map of Debug.Script instances for garbage-collected JSScripts. For function
+    // Map of Debugger.Script instances for garbage-collected JSScripts. For function
     // scripts, the key is the compiler-created, internal JSFunction; for scripts returned
     // by JSAPI functions, the key is the "Script"-class JSObject.
     ScriptWeakMap heldScripts;
 
-    // An ordinary (non-ephemeral) map from JSScripts to Debug.Script instances, for eval
+    // An ordinary (non-ephemeral) map from JSScripts to Debugger.Script instances, for eval
     // scripts that are explicitly freed.
     typedef HashMap<JSScript *, JSObject *, DefaultHasher<JSScript *>, SystemAllocPolicy>
         ScriptMap;
 
-    // Map from eval JSScripts to their Debug.Script objects. "Eval scripts" are scripts
+    // Map from eval JSScripts to their Debugger.Script objects. "Eval scripts" are scripts
     // created for 'eval' and similar calls that are explicitly destroyed when the call
-    // returns. Debug.Script objects are not strong references to such JSScripts; the
-    // Debug.Script becomes "dead" when the eval call returns.
+    // returns. Debugger.Script objects are not strong references to such JSScripts; the
+    // Debugger.Script becomes "dead" when the eval call returns.
     ScriptMap evalScripts;
 
     bool addDebuggeeGlobal(JSContext *cx, GlobalObject *obj);
     void removeDebuggeeGlobal(JSContext *cx, GlobalObject *global,
                               GlobalObjectSet::Enum *compartmentEnum,
                               GlobalObjectSet::Enum *debugEnum);
 
     JSTrapStatus handleUncaughtException(AutoCompartment &ac, Value *vp, bool callHook);
@@ -137,68 +137,68 @@ class Debug {
     static JSPropertySpec properties[];
     static JSFunctionSpec methods[];
 
     inline bool hasAnyLiveHooks() const;
 
     static void slowPathLeaveStackFrame(JSContext *cx);
     static void slowPathOnDestroyScript(JSScript *script);
 
-    typedef bool (Debug::*DebugObservesMethod)() const;
-    typedef JSTrapStatus (Debug::*DebugHandleMethod)(JSContext *, Value *) const;
+    typedef bool (Debugger::*DebuggerObservesMethod)() const;
+    typedef JSTrapStatus (Debugger::*DebuggerHandleMethod)(JSContext *, Value *) const;
     static JSTrapStatus dispatchHook(JSContext *cx, js::Value *vp,
-                                     DebugObservesMethod observesEvent,
-                                     DebugHandleMethod handleEvent);
+                                     DebuggerObservesMethod observesEvent,
+                                     DebuggerHandleMethod handleEvent);
 
     bool observesDebuggerStatement() const;
     JSTrapStatus handleDebuggerStatement(JSContext *cx, Value *vp);
 
     bool observesThrow() const;
     JSTrapStatus handleThrow(JSContext *cx, Value *vp);
 
-    // Allocate and initialize a Debug.Script instance whose referent is |script| and
-    // whose holder is |obj|. If |obj| is NULL, this creates a Debug.Script whose holder
+    // Allocate and initialize a Debugger.Script instance whose referent is |script| and
+    // whose holder is |obj|. If |obj| is NULL, this creates a Debugger.Script whose holder
     // is null, for eval scripts.
-    JSObject *newDebugScript(JSContext *cx, JSScript *script, JSObject *obj);
+    JSObject *newDebuggerScript(JSContext *cx, JSScript *script, JSObject *obj);
 
     // Helper function for wrapFunctionScript and wrapJSAPIscript.
     JSObject *wrapHeldScript(JSContext *cx, JSScript *script, JSObject *obj);
 
     // Remove script from our table of eval scripts.
     void destroyEvalScript(JSScript *script);
 
-    static inline Debug *fromLinks(JSCList *links);
+    static inline Debugger *fromLinks(JSCList *links);
     inline Breakpoint *firstBreakpoint() const;
 
   public:
-    Debug(JSObject *dbg, JSObject *hooks);
-    ~Debug();
+    Debugger(JSObject *dbg, JSObject *hooks);
+    ~Debugger();
 
     bool init(JSContext *cx);
     inline JSObject *toJSObject() const;
-    static inline Debug *fromJSObject(JSObject *obj);
-    static Debug *fromChildJSObject(JSObject *obj);
+    static inline Debugger *fromJSObject(JSObject *obj);
+    static Debugger *fromChildJSObject(JSObject *obj);
 
     /*********************************** Methods for interaction with the GC. */
 
-    // A Debug object is live if:
-    //   * the Debug JSObject is live (Debug::trace handles this case); OR
+    // A Debugger object is live if:
+    //   * the Debugger JSObject is live (Debugger::trace handles this case); OR
     //   * it is in the middle of dispatching an event (the event dispatching
     //     code roots it in this case); OR
     //   * it is enabled, and it is debugging at least one live compartment,
     //     and at least one of the following is true:
     //       - it has a debugger hook installed
     //       - it has a breakpoint set on a live script
     //       - it has a watchpoint set on a live object.
     //
-    // The last case is handled by the mark() method. If it finds any Debug
+    // The last case is handled by the mark() method. If it finds any Debugger
     // objects that are definitely live but not yet marked, it marks them and
     // returns true. If not, it returns false.
     //
-    static void markCrossCompartmentDebugObjectReferents(JSTracer *tracer);
+    static void markCrossCompartmentDebuggerObjectReferents(JSTracer *tracer);
     static bool mark(GCMarker *trc, JSGCInvocationKind gckind);
     static void sweepAll(JSContext *cx);
     static void detachAllDebuggersFromGlobal(JSContext *cx, GlobalObject *global,
                                              GlobalObjectSet::Enum *compartmentEnum);
 
     static inline void leaveStackFrame(JSContext *cx);
     static inline JSTrapStatus onDebuggerStatement(JSContext *cx, js::Value *vp);
     static inline JSTrapStatus onThrow(JSContext *cx, js::Value *vp);
@@ -208,83 +208,83 @@ class Debug {
     /**************************************** Functions for use by jsdbg.cpp. */
 
     inline bool observesScope(JSObject *obj) const;
     inline bool observesFrame(StackFrame *fp) const;
 
     // Precondition: *vp is a value from a debuggee compartment and cx is in
     // the debugger's compartment.
     //
-    // Wrap *vp for the debugger compartment, wrap it in a Debug.Object if it's
+    // Wrap *vp for the debugger compartment, wrap it in a Debugger.Object if it's
     // an object, store the result in *vp, and return true.
     //
     bool wrapDebuggeeValue(JSContext *cx, Value *vp);
 
     // NOT the inverse of wrapDebuggeeValue.
     //
     // Precondition: cx is in the debugger compartment. *vp is a value in that
     // compartment. (*vp is a "debuggee value", meaning it is the debugger's
     // reflection of a value in the debuggee.)
     //
-    // If *vp is a Debug.Object, store the referent in *vp. Otherwise, if *vp
+    // If *vp is a Debugger.Object, store the referent in *vp. Otherwise, if *vp
     // is an object, throw a TypeError, because it is not a debuggee
     // value. Otherwise *vp is a primitive, so leave it alone.
     //
     // The value is not rewrapped for any debuggee compartment.
     //
     bool unwrapDebuggeeValue(JSContext *cx, Value *vp);
 
-    // Store the Debug.Frame object for the frame fp in *vp.
+    // Store the Debugger.Frame object for the frame fp in *vp.
     bool getScriptFrame(JSContext *cx, StackFrame *fp, Value *vp);
 
     // Precondition: we are in the debuggee compartment (ac is entered) and ok
     // is true if the operation in the debuggee compartment succeeded, false on
     // error or exception.
     //
     // Postcondition: we are in the debugger compartment (ac is not entered)
     // whether creating the new completion value succeeded or not.
     //
     // On success, a completion value is in vp and ac.context does not have a
     // pending exception. (This ordinarily returns true even if the ok argument
     // is false.)
     //
     bool newCompletionValue(AutoCompartment &ac, bool ok, Value val, Value *vp);
 
-    // Return the Debug.Script object for |fun|'s script, or create a new one if needed.
+    // Return the Debugger.Script object for |fun|'s script, or create a new one if needed.
     // The context |cx| must be in the debugger compartment; |fun| must be a
     // cross-compartment wrapper referring to the JSFunction in a debuggee compartment.
     JSObject *wrapFunctionScript(JSContext *cx, JSFunction *fun);
 
-    // Return the Debug.Script object for the Script object |obj|'s JSScript, or create a
+    // Return the Debugger.Script object for the Script object |obj|'s JSScript, or create a
     // new one if needed. The context |cx| must be in the debugger compartment; |obj| must
     // be a cross-compartment wrapper referring to a script object in a debuggee
     // compartment.
     JSObject *wrapJSAPIScript(JSContext *cx, JSObject *scriptObj);
 
-    // Return the Debug.Script object for the eval script |script|, or create a new one if
+    // Return the Debugger.Script object for the eval script |script|, or create a new one if
     // needed. The context |cx| must be in the debugger compartment; |script| must be a
     // script in a debuggee compartment.
     JSObject *wrapEvalScript(JSContext *cx, JSScript *script);
 
   private:
     // Prohibit copying.
-    Debug(const Debug &);
-    Debug & operator=(const Debug &);
+    Debugger(const Debugger &);
+    Debugger & operator=(const Debugger &);
 };
 
 bool
-Debug::hasAnyLiveHooks() const
+Debugger::hasAnyLiveHooks() const
 {
     return enabled && (hasDebuggerHandler || hasThrowHandler || !JS_CLIST_IS_EMPTY(&breakpoints));
 }
 
 class BreakpointSite {
     friend class js::Breakpoint;
     friend class ::JSCompartment;
-    friend class js::Debug;
+    friend class js::Debugger;
 
   public:
     JSScript * const script;
     jsbytecode * const pc;
     const JSOp realOpcode;
 
   private:
     // The holder object for script, if known, else NULL.  This is NULL for
@@ -309,107 +309,107 @@ class BreakpointSite {
     bool setTrap(JSContext *cx, JSTrapHandler handler, const Value &closure);
     void clearTrap(JSContext *cx, BreakpointSiteMap::Enum *e = NULL,
                    JSTrapHandler *handlerp = NULL, Value *closurep = NULL);
     void destroyIfEmpty(JSRuntime *rt, BreakpointSiteMap::Enum *e);
 };
 
 class Breakpoint {
     friend class ::JSCompartment;
-    friend class js::Debug;
+    friend class js::Debugger;
 
   public:
-    Debug * const debugger;
+    Debugger * const debugger;
     BreakpointSite * const site;
   private:
     JSObject *handler;
     JSCList debuggerLinks;
     JSCList siteLinks;
 
   public:
     static Breakpoint *fromDebuggerLinks(JSCList *links);
     static Breakpoint *fromSiteLinks(JSCList *links);
-    Breakpoint(Debug *debugger, BreakpointSite *site, JSObject *handler);
+    Breakpoint(Debugger *debugger, BreakpointSite *site, JSObject *handler);
     void destroy(JSContext *cx, BreakpointSiteMap::Enum *e = NULL);
     Breakpoint *nextInDebugger();
     Breakpoint *nextInSite();
     JSObject *getHandler() const { return handler; }
 };
 
 bool
-Debug::observesScope(JSObject *obj) const
+Debugger::observesScope(JSObject *obj) const
 {
     return debuggees.has(obj->getGlobal());
 }
 
 bool
-Debug::observesFrame(StackFrame *fp) const
+Debugger::observesFrame(StackFrame *fp) const
 {
     return observesScope(&fp->scopeChain());
 }
 
-js::Debug *
-js::Debug::fromLinks(JSCList *links)
+js::Debugger *
+js::Debugger::fromLinks(JSCList *links)
 {
     unsigned char *p = reinterpret_cast<unsigned char *>(links);
-    return reinterpret_cast<Debug *>(p - offsetof(Debug, link));
+    return reinterpret_cast<Debugger *>(p - offsetof(Debugger, link));
 }
 
 
 Breakpoint *
-Debug::firstBreakpoint() const
+Debugger::firstBreakpoint() const
 {
     if (JS_CLIST_IS_EMPTY(&breakpoints))
         return NULL;
     return Breakpoint::fromDebuggerLinks(JS_NEXT_LINK(&breakpoints));
 }
 
 JSObject *
-Debug::toJSObject() const
+Debugger::toJSObject() const
 {
     JS_ASSERT(object);
     return object;
 }
 
-Debug *
-Debug::fromJSObject(JSObject *obj)
+Debugger *
+Debugger::fromJSObject(JSObject *obj)
 {
     JS_ASSERT(obj->getClass() == &jsclass);
-    return (Debug *) obj->getPrivate();
+    return (Debugger *) obj->getPrivate();
 }
 
 void
-Debug::leaveStackFrame(JSContext *cx)
+Debugger::leaveStackFrame(JSContext *cx)
 {
     if (!cx->compartment->getDebuggees().empty() || !cx->compartment->breakpointSites.empty())
         slowPathLeaveStackFrame(cx);
 }
 
 JSTrapStatus
-Debug::onDebuggerStatement(JSContext *cx, js::Value *vp)
+Debugger::onDebuggerStatement(JSContext *cx, js::Value *vp)
 {
     return cx->compartment->getDebuggees().empty()
            ? JSTRAP_CONTINUE
            : dispatchHook(cx, vp,
-                          DebugObservesMethod(&Debug::observesDebuggerStatement),
-                          DebugHandleMethod(&Debug::handleDebuggerStatement));
+                          DebuggerObservesMethod(&Debugger::observesDebuggerStatement),
+                          DebuggerHandleMethod(&Debugger::handleDebuggerStatement));
 }
 
 JSTrapStatus
-Debug::onThrow(JSContext *cx, js::Value *vp)
+Debugger::onThrow(JSContext *cx, js::Value *vp)
 {
     return cx->compartment->getDebuggees().empty()
            ? JSTRAP_CONTINUE
            : dispatchHook(cx, vp,
-                          DebugObservesMethod(&Debug::observesThrow),
-                          DebugHandleMethod(&Debug::handleThrow));
+                          DebuggerObservesMethod(&Debugger::observesThrow),
+                          DebuggerHandleMethod(&Debugger::handleThrow));
 }
 
 void
-Debug::onDestroyScript(JSScript *script)
+Debugger::onDestroyScript(JSScript *script)
 {
     if (!script->compartment->getDebuggees().empty())
         slowPathOnDestroyScript(script);
 }
 
 extern JSBool
 EvaluateInScope(JSContext *cx, JSObject *scobj, StackFrame *fp, const jschar *chars,
                 uintN length, const char *filename, uintN lineno, Value *rval);
--- a/js/src/jsdbgapi.cpp
+++ b/js/src/jsdbgapi.cpp
@@ -131,17 +131,17 @@ ScriptDebugEpilogue(JSContext *cx, Stack
         if (fp->isFramePushedByExecute()) {
             if (JSInterpreterHook hook = cx->debugHooks->executeHook)
                 hook(cx, Jsvalify(fp), false, &ok, hookData);
         } else {
             if (JSInterpreterHook hook = cx->debugHooks->callHook)
                 hook(cx, Jsvalify(fp), false, &ok, hookData);
         }
     }
-    Debug::leaveStackFrame(cx);
+    Debugger::leaveStackFrame(cx);
 
     return ok;
 }
 
 } /* namespace js */
 
 JS_FRIEND_API(JSBool)
 JS_SetDebugModeForCompartment(JSContext *cx, JSCompartment *comp, JSBool debug)
--- a/js/src/jsdbgapi.h
+++ b/js/src/jsdbgapi.h
@@ -516,17 +516,17 @@ JS_StartProfiling();
 extern JS_PUBLIC_API(void)
 JS_StopProfiling();
 
 extern JS_PUBLIC_API(JSBool)
 JS_DefineProfilingFunctions(JSContext *cx, JSObject *obj);
 
 /* Defined in jsdbg.cpp. */
 extern JS_PUBLIC_API(JSBool)
-JS_DefineDebugObject(JSContext *cx, JSObject *obj);
+JS_DefineDebuggerObject(JSContext *cx, JSObject *obj);
 
 #ifdef MOZ_CALLGRIND
 
 extern JS_FRIEND_API(JSBool)
 js_StopCallgrind(JSContext *cx, uintN argc, jsval *vp);
 
 extern JS_FRIEND_API(JSBool)
 js_StartCallgrind(JSContext *cx, uintN argc, jsval *vp);
--- a/js/src/jsgc.cpp
+++ b/js/src/jsgc.cpp
@@ -2228,30 +2228,30 @@ MarkAndSweep(JSContext *cx, JSCompartmen
     rt->gcMarkingTracer = &gcmarker;
 
     for (GCChunkSet::Range r(rt->gcChunkSet.all()); !r.empty(); r.popFront())
          r.front()->bitmap.clear();
 
     if (comp) {
         for (JSCompartment **c = rt->compartments.begin(); c != rt->compartments.end(); ++c)
             (*c)->markCrossCompartmentWrappers(&gcmarker);
-        Debug::markCrossCompartmentDebugObjectReferents(&gcmarker);
+        Debugger::markCrossCompartmentDebuggerObjectReferents(&gcmarker);
     } else {
         js_MarkScriptFilenames(rt);
     }
 
     MarkRuntime(&gcmarker);
     gcmarker.drainMarkStack();
 
     /*
      * Mark weak roots.
      */
     while (js_TraceWatchPoints(&gcmarker) ||
            WeakMapBase::markAllIteratively(&gcmarker) ||
-           Debug::mark(&gcmarker, gckind))
+           Debugger::mark(&gcmarker, gckind))
     {
         gcmarker.drainMarkStack();
     }
 
     rt->gcMarkingTracer = NULL;
 
     if (rt->gcCallback)
         (void) rt->gcCallback(cx, JSGC_MARK_END);
@@ -2299,17 +2299,17 @@ MarkAndSweep(JSContext *cx, JSCompartmen
         comp->sweep(cx, 0);
         comp->finalizeObjectArenaLists(cx);
         GCTIMESTAMP(sweepObjectEnd);
         comp->finalizeStringArenaLists(cx);
         GCTIMESTAMP(sweepStringEnd);
         comp->finalizeShapeArenaLists(cx);
         GCTIMESTAMP(sweepShapeEnd);
     } else {
-        Debug::sweepAll(cx);
+        Debugger::sweepAll(cx);
 
         SweepCrossCompartmentWrappers(cx);
         for (JSCompartment **c = rt->compartments.begin(); c != rt->compartments.end(); c++)
             (*c)->finalizeObjectArenaLists(cx);
 
         GCTIMESTAMP(sweepObjectEnd);
 
         for (JSCompartment **c = rt->compartments.begin(); c != rt->compartments.end(); c++)
--- a/js/src/jsinterp.cpp
+++ b/js/src/jsinterp.cpp
@@ -4465,17 +4465,17 @@ BEGIN_CASE(JSOP_LOOKUPSWITCH)
           : GET_JUMPX_OFFSET(pc2);
 }
 END_VARLEN_CASE
 }
 
 BEGIN_CASE(JSOP_TRAP)
 {
     Value rval;
-    JSTrapStatus status = Debug::onTrap(cx, &rval);
+    JSTrapStatus status = Debugger::onTrap(cx, &rval);
     switch (status) {
       case JSTRAP_ERROR:
         goto error;
       case JSTRAP_RETURN:
         regs.fp()->setReturnValue(rval);
         interpReturnOK = JS_TRUE;
         goto forced_return;
       case JSTRAP_THROW:
@@ -5534,17 +5534,17 @@ END_CASE(JSOP_INSTANCEOF)
 
 BEGIN_CASE(JSOP_DEBUGGER)
 {
     JSTrapStatus st = JSTRAP_CONTINUE;
     Value rval;
     if (JSDebuggerHandler handler = cx->debugHooks->debuggerHandler)
         st = handler(cx, script, regs.pc, Jsvalify(&rval), cx->debugHooks->debuggerHandlerData);
     if (st == JSTRAP_CONTINUE)
-        st = Debug::onDebuggerStatement(cx, &rval);
+        st = Debugger::onDebuggerStatement(cx, &rval);
     switch (st) {
       case JSTRAP_ERROR:
         goto error;
       case JSTRAP_CONTINUE:
         break;
       case JSTRAP_RETURN:
         regs.fp()->setReturnValue(rval);
         interpReturnOK = JS_TRUE;
@@ -6063,17 +6063,17 @@ END_CASE(JSOP_ARRAYPUSH)
         uint32 offset;
 
         /* Restore atoms local in case we will resume. */
         atoms = script->atomMap.vector;
 
         /* Call debugger throw hook if set. */
         if (cx->debugHooks->throwHook || !cx->compartment->getDebuggees().empty()) {
             Value rval;
-            JSTrapStatus st = Debug::onThrow(cx, &rval);
+            JSTrapStatus st = Debugger::onThrow(cx, &rval);
             if (st == JSTRAP_CONTINUE) {
                 handler = cx->debugHooks->throwHook;
                 if (handler)
                     st = handler(cx, script, regs.pc, Jsvalify(&rval), cx->debugHooks->throwHookData);
             }
 
             switch (st) {
             case JSTRAP_ERROR:
--- a/js/src/jsprvtd.h
+++ b/js/src/jsprvtd.h
@@ -194,17 +194,17 @@ class MultiDeclRange;
 class ParseMapPool;
 class DefnOrHeader;
 typedef js::InlineMap<JSAtom *, JSDefinition *, 24> AtomDefnMap;
 typedef js::InlineMap<JSAtom *, jsatomid, 24> AtomIndexMap;
 typedef js::InlineMap<JSAtom *, DefnOrHeader, 24> AtomDOHMap;
 
 class Breakpoint;
 class BreakpointSite;
-class Debug;
+class Debugger;
 
 typedef HashMap<jsbytecode *, BreakpointSite *, DefaultHasher<jsbytecode *>, RuntimeAllocPolicy>
     BreakpointSiteMap;
 
 } /* namespace js */
 
 } /* export "C++" */
 
--- a/js/src/jsscript.cpp
+++ b/js/src/jsscript.cpp
@@ -1395,17 +1395,17 @@ js_CallNewScriptHook(JSContext *cx, JSSc
 void
 js_CallDestroyScriptHook(JSContext *cx, JSScript *script)
 {
     JSDestroyScriptHook hook;
 
     hook = cx->debugHooks->destroyScriptHook;
     if (hook)
         hook(cx, script, cx->debugHooks->destroyScriptHookData);
-    Debug::onDestroyScript(script);
+    Debugger::onDestroyScript(script);
     JS_ClearScriptTraps(cx, script);
 }
 
 static void
 DestroyScript(JSContext *cx, JSScript *script)
 {
     if (script->principals)
         JSPRINCIPALS_DROP(cx, script->principals);
--- a/js/src/methodjit/Compiler.cpp
+++ b/js/src/methodjit/Compiler.cpp
@@ -2011,17 +2011,17 @@ mjit::Compiler::generateMethod()
             if (analysis->jumpTarget(PC))
                 interruptCheckHelper();
           }
           END_CASE(JSOP_TRACE)
 
           BEGIN_CASE(JSOP_DEBUGGER)
             prepareStubCall(Uses(0));
             masm.move(ImmPtr(PC), Registers::ArgReg1);
-            INLINE_STUBCALL(stubs::Debugger);
+            INLINE_STUBCALL(stubs::DebuggerStatement);
           END_CASE(JSOP_DEBUGGER)
 
           BEGIN_CASE(JSOP_UNBRAND)
             jsop_unbrand();
           END_CASE(JSOP_UNBRAND)
 
           BEGIN_CASE(JSOP_UNBRANDTHIS)
             jsop_this();
--- a/js/src/methodjit/InvokeHelpers.cpp
+++ b/js/src/methodjit/InvokeHelpers.cpp
@@ -466,17 +466,17 @@ js_InternalThrow(VMFrame &f)
     JS_ASSERT(&cx->regs() == &f.regs);
 
     jsbytecode *pc = NULL;
     for (;;) {
         // Call the throw hook if necessary
         JSThrowHook handler = cx->debugHooks->throwHook;
         if (handler || !cx->compartment->getDebuggees().empty()) {
             Value rval;
-            JSTrapStatus st = Debug::onThrow(cx, &rval);
+            JSTrapStatus st = Debugger::onThrow(cx, &rval);
             if (st == JSTRAP_CONTINUE && handler) {
                 st = handler(cx, cx->fp()->script(), cx->regs().pc, Jsvalify(&rval),
                              cx->debugHooks->throwHookData);
             }
 
             switch (st) {
               case JSTRAP_ERROR:
                 cx->clearPendingException();
--- a/js/src/methodjit/StubCalls.cpp
+++ b/js/src/methodjit/StubCalls.cpp
@@ -1138,28 +1138,28 @@ stubs::Mod(VMFrame &f)
         } else {
             d1 = js_fmod(d1, d2);
             regs.sp[-2].setDouble(d1);
         }
     }
 }
 
 void JS_FASTCALL
-stubs::Debugger(VMFrame &f, jsbytecode *pc)
+stubs::DebuggerStatement(VMFrame &f, jsbytecode *pc)
 {
     JSDebuggerHandler handler = f.cx->debugHooks->debuggerHandler;
     if (handler || !f.cx->compartment->getDebuggees().empty()) {
         JSTrapStatus st = JSTRAP_CONTINUE;
         Value rval;
         if (handler) {
             st = handler(f.cx, f.cx->fp()->script(), pc, Jsvalify(&rval),
                          f.cx->debugHooks->debuggerHandlerData);
         }
         if (st == JSTRAP_CONTINUE)
-            st = Debug::onDebuggerStatement(f.cx, &rval);
+            st = Debugger::onDebuggerStatement(f.cx, &rval);
 
         switch (st) {
           case JSTRAP_THROW:
             f.cx->setPendingException(rval);
             THROW();
 
           case JSTRAP_RETURN:
             f.cx->clearPendingException();
@@ -1203,17 +1203,17 @@ stubs::Trap(VMFrame &f, uint32 trapTypes
          */
         JSInterruptHook hook = f.cx->debugHooks->interruptHook;
         if (hook)
             result = hook(f.cx, f.cx->fp()->script(), pc, Jsvalify(&rval),
                           f.cx->debugHooks->interruptHookData);
     }
 
     if (result == JSTRAP_CONTINUE && (trapTypes & JSTRAP_TRAP))
-        result = Debug::onTrap(f.cx, &rval);
+        result = Debugger::onTrap(f.cx, &rval);
 
     switch (result) {
       case JSTRAP_THROW:
         f.cx->setPendingException(rval);
         THROW();
 
       case JSTRAP_RETURN:
         f.cx->clearPendingException();
--- a/js/src/methodjit/StubCalls.h
+++ b/js/src/methodjit/StubCalls.h
@@ -52,17 +52,17 @@ typedef enum JSTrapType {
     JSTRAP_TRAP = 1,
     JSTRAP_SINGLESTEP = 2
 } JSTrapType;
 
 void JS_FASTCALL This(VMFrame &f);
 JSObject * JS_FASTCALL NewInitArray(VMFrame &f, uint32 count);
 JSObject * JS_FASTCALL NewInitObject(VMFrame &f, JSObject *base);
 void JS_FASTCALL Trap(VMFrame &f, uint32 trapTypes);
-void JS_FASTCALL Debugger(VMFrame &f, jsbytecode *pc);
+void JS_FASTCALL DebuggerStatement(VMFrame &f, jsbytecode *pc);
 void JS_FASTCALL Interrupt(VMFrame &f, jsbytecode *pc);
 void JS_FASTCALL InitElem(VMFrame &f, uint32 last);
 void JS_FASTCALL InitProp(VMFrame &f, JSAtom *atom);
 void JS_FASTCALL InitMethod(VMFrame &f, JSAtom *atom);
 
 void JS_FASTCALL HitStackQuota(VMFrame &f);
 void * JS_FASTCALL FixupArity(VMFrame &f, uint32 argc);
 void * JS_FASTCALL CompileFunction(VMFrame &f, uint32 argc);
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -5905,17 +5905,17 @@ NewGlobalObject(JSContext *cx, Compartme
 #endif
 
 #ifdef JS_HAS_CTYPES
         if (!JS_InitCTypesClass(cx, glob))
             return NULL;
 #endif
         if (!JS_InitReflect(cx, glob))
             return NULL;
-        if (!JS_DefineDebugObject(cx, glob))
+        if (!JS_DefineDebuggerObject(cx, glob))
             return NULL;
         if (!JS::RegisterPerfMeasurement(cx, glob))
             return NULL;
         if (!JS_DefineFunctions(cx, glob, shell_functions) ||
             !JS_DefineProfilingFunctions(cx, glob)) {
             return NULL;
         }
 
--- a/js/src/vm/GlobalObject.cpp
+++ b/js/src/vm/GlobalObject.cpp
@@ -200,64 +200,64 @@ GlobalObject::isRuntimeCodeGenEnabled(JS
                      callbacks->contentSecurityPolicyAllows(cx));
     }
     return !v.isFalse();
 }
 
 void
 GlobalDebuggees_finalize(JSContext *cx, JSObject *obj)
 {
-    cx->delete_((GlobalObject::DebugVector *) obj->getPrivate());
+    cx->delete_((GlobalObject::DebuggerVector *) obj->getPrivate());
 }
 
 static Class
 GlobalDebuggees_class = {
     "GlobalDebuggee", JSCLASS_HAS_PRIVATE,
     PropertyStub, PropertyStub, PropertyStub, StrictPropertyStub,
     EnumerateStub, ResolveStub, ConvertStub, GlobalDebuggees_finalize
 };
 
-GlobalObject::DebugVector *
+GlobalObject::DebuggerVector *
 GlobalObject::getDebuggers()
 {
     Value debuggers = getReservedSlot(DEBUGGERS);
     if (debuggers.isUndefined())
         return NULL;
     JS_ASSERT(debuggers.toObject().clasp == &GlobalDebuggees_class);
-    return (DebugVector *) debuggers.toObject().getPrivate();
+    return (DebuggerVector *) debuggers.toObject().getPrivate();
 }
 
-GlobalObject::DebugVector *
+GlobalObject::DebuggerVector *
 GlobalObject::getOrCreateDebuggers(JSContext *cx)
 {
     assertSameCompartment(cx, this);
-    DebugVector *vec = getDebuggers();
+    DebuggerVector *vec = getDebuggers();
     if (vec)
         return vec;
 
     JSObject *obj = NewNonFunction<WithProto::Given>(cx, &GlobalDebuggees_class, NULL, NULL);
     if (!obj)
         return NULL;
-    vec = cx->new_<DebugVector>();
+    vec = cx->new_<DebuggerVector>();
     if (!vec)
         return NULL;
     obj->setPrivate(vec);
     if (!js_SetReservedSlot(cx, this, DEBUGGERS, ObjectValue(*obj)))
         return NULL;
     return vec;
 }
 
 bool
-GlobalObject::addDebug(JSContext *cx, Debug *dbg)
+GlobalObject::addDebugger(JSContext *cx, Debugger *dbg)
 {
-    DebugVector *vec = getOrCreateDebuggers(cx);
+    DebuggerVector *vec = getOrCreateDebuggers(cx);
     if (!vec)
         return false;
 #ifdef DEBUG
-    for (Debug **p = vec->begin(); p != vec->end(); p++)
+    for (Debugger **p = vec->begin(); p != vec->end(); p++)
         JS_ASSERT(*p != dbg);
 #endif
     if (vec->empty() && !compartment()->addDebuggee(cx, this))
         return false;
     if (!vec->append(dbg)) {
         compartment()->removeDebuggee(cx, this);
         return false;
     }
--- a/js/src/vm/GlobalObject.h
+++ b/js/src/vm/GlobalObject.h
@@ -149,27 +149,27 @@ class GlobalObject : public ::JSObject {
         // JS_ASSERT(v.isUndefined());
         v.setObject(*evalobj);
     }
 
     bool getFunctionNamespace(JSContext *cx, Value *vp);
 
     bool initStandardClasses(JSContext *cx);
 
-    typedef js::Vector<js::Debug *, 0, js::SystemAllocPolicy> DebugVector;
+    typedef js::Vector<js::Debugger *, 0, js::SystemAllocPolicy> DebuggerVector;
 
     // The collection of Debug objects debugging this global. If this global is
     // not a debuggee, this returns either NULL or an empty vector.
-    DebugVector *getDebuggers();
+    DebuggerVector *getDebuggers();
 
     // The same, but create the empty vector if one does not already
     // exist. Returns NULL only on OOM.
-    DebugVector *getOrCreateDebuggers(JSContext *cx);
+    DebuggerVector *getOrCreateDebuggers(JSContext *cx);
 
-    bool addDebug(JSContext *cx, Debug *dbg);
+    bool addDebugger(JSContext *cx, Debugger *dbg);
 };
 
 typedef HashSet<GlobalObject *, DefaultHasher<GlobalObject *>, SystemAllocPolicy> GlobalObjectSet;
 
 } // namespace js
 
 js::GlobalObject *
 JSObject::asGlobal()