File missing from http://codereview.chromium.org/19753.

test/cctest/test-debug.cc

 // Copyright 2007-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 805 matching lines @@
   CHECK(!HasDebugInfo(foo));
   CHECK(!HasDebugInfo(bar));
 }
 
 
 // Test that a break point can be set at an IC store location.
 TEST(BreakPointICStore) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function foo(){bar=0;}"))->Run();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that a break point can be set at an IC load location.
 TEST(BreakPointICLoad) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("bar=1"))->Run();
   v8::Script::Compile(v8::String::New("function foo(){var x=bar;}"))->Run();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that a break point can be set at an IC call location.
 TEST(BreakPointICCall) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function bar(){}"))->Run();
   v8::Script::Compile(v8::String::New("function foo(){bar();}"))->Run();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that a break point can be set at a return store location.
 TEST(BreakPointReturn) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function foo(){}"))->Run();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
 
   // Run without breakpoints.
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
   // Run with breakpoint
   int bp = SetBreakPoint(foo, 0);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPoint(bp);
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 static void CallWithBreakPoints(v8::Local<v8::Object> recv,
                                 v8::Local<v8::Function> f,
                                 int break_point_count,
                                 int call_count) {
   break_point_hit_count = 0;
   for (int i = 0; i < call_count; i++) {
     f->Call(recv, 0, NULL);
     CHECK_EQ((i + 1) * break_point_count, break_point_hit_count);
   }
 }
 
 // Test GC during break point processing.
 TEST(GCDuringBreakPointProcessing) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointCollectGarbage,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointCollectGarbage,
                                    v8::Undefined());
   v8::Local<v8::Function> foo;
 
   // Test IC store break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(env->Global(), foo, 1, 10);
 
   // Test IC load break point with garbage collection.
   foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(env->Global(), foo, 1, 10);
 
   // Test IC call break point with garbage collection.
   foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(env->Global(), foo, 1, 10);
 
   // Test return break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){}", "foo");
   SetBreakPoint(foo, 0);
   CallWithBreakPoints(env->Global(), foo, 1, 25);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointCollectGarbage);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Call the function three times with different garbage collections in between
 // and make sure that the break point survives.
 static void CallAndGC(v8::Local<v8::Object> recv, v8::Local<v8::Function> f) {
   break_point_hit_count = 0;
 
   for (int i = 0; i < 3; i++) {
     // Call function.
@@ skipping 12 matching lines @@
   }
 }
 
 
 // Test that a break point can be set at a return store location.
 TEST(BreakPointSurviveGC) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Local<v8::Function> foo;
 
   // Test IC store break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){bar=0;}", "foo");
   SetBreakPoint(foo, 0);
   CallAndGC(env->Global(), foo);
 
   // Test IC load break point with garbage collection.
   foo = CompileFunction(&env, "bar=1;function foo(){var x=bar;}", "foo");
   SetBreakPoint(foo, 0);
   CallAndGC(env->Global(), foo);
 
   // Test IC call break point with garbage collection.
   foo = CompileFunction(&env, "function bar(){};function foo(){bar();}", "foo");
   SetBreakPoint(foo, 0);
   CallAndGC(env->Global(), foo);
 
   // Test return break point with garbage collection.
   foo = CompileFunction(&env, "function foo(){}", "foo");
   SetBreakPoint(foo, 0);
   CallAndGC(env->Global(), foo);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that break points can be set using the global Debug object.
 TEST(BreakPointThroughJavaScript) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function bar(){}"))->Run();
   v8::Script::Compile(v8::String::New("function foo(){bar();bar();}"))->Run();
   //                                               012345678901234567890
   //                                                         1         2
   // Break points are set at position 3 and 9
   v8::Local<v8::Script> foo = v8::Script::Compile(v8::String::New("foo()"));
 
   // Run without breakpoints.
   foo->Run();
@@ skipping 18 matching lines @@
   foo->Run();
   CHECK_EQ(7, break_point_hit_count);
   foo->Run();
   CHECK_EQ(8, break_point_hit_count);
 
   // Run without breakpoints.
   ClearBreakPointFromJS(bp1);
   foo->Run();
   CHECK_EQ(8, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, bp1);
   CHECK_EQ(2, bp2);
 }
 
 
 // Test that break points can be set using the global Debug object.
 TEST(ScriptBreakPointThroughJavaScript) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function foo(){bar();bar();}"))->Run();
 
   v8::Local<v8::String> script = v8::String::New(
     "function f() {\n"
     "  function h() {\n"
     "    a = 0;  // line 2\n"
     "  }\n"
     "  b = 1;  // line 4\n"
     "  return h();\n"
@@ skipping 78 matching lines @@
   CHECK_EQ(1, break_point_hit_count);
 
   // Reload the script and get g again checking that the break point survives.
   // This tests that the function break point was converted to a script break
   // point.
   v8::Script::Compile(script, &origin)->Run();
   g = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("g")));
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 
   // Make sure that the break point numbers are consecutive.
   CHECK_EQ(1, sbp1);
   CHECK_EQ(2, sbp2);
   CHECK_EQ(3, sbp3);
   CHECK_EQ(4, sbp4);
   CHECK_EQ(5, sbp5);
   CHECK_EQ(6, sbp6);
   CHECK_EQ(7, bp7);
 }
 
 
 // Test conditional script break points.
 TEST(EnableDisableScriptBreakPoint) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
 
   v8::Local<v8::String> script = v8::String::New(
     "function f() {\n"
     "  a = 0;  // line 1\n"
     "};");
 
   // Compile the script and get function f.
   v8::ScriptOrigin origin =
       v8::ScriptOrigin(v8::String::New("test"));
@@ skipping 24 matching lines @@
   // Reload the script and get f again checking that the disabeling survives.
   v8::Script::Compile(script, &origin)->Run();
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   EnableScriptBreakPointFromJS(sbp);
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test conditional script break points.
 TEST(ConditionalScriptBreakPoint) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
 
   v8::Local<v8::String> script = v8::String::New(
     "count = 0;\n"
     "function f() {\n"
     "  g(count++);  // line 2\n"
     "};\n"
     "function g(x) {\n"
     "  var a=x;  // line 5\n"
     "};");
@@ skipping 29 matching lines @@
   // Reload the script and get f again checking that the condition survives.
   v8::Script::Compile(script, &origin)->Run();
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
 
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test ignore count on script break points.
 TEST(ScriptBreakPointIgnoreCount) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
 
   v8::Local<v8::String> script = v8::String::New(
     "function f() {\n"
     "  a = 0;  // line 1\n"
     "};");
 
   // Compile the script and get function f.
   v8::ScriptOrigin origin =
       v8::ScriptOrigin(v8::String::New("test"));
@@ skipping 22 matching lines @@
   // Reload the script and get f again checking that the ignore survives.
   v8::Script::Compile(script, &origin)->Run();
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
 
   break_point_hit_count = 0;
   for (int i = 0; i < 10; i++) {
     f->Call(env->Global(), 0, NULL);
   }
   CHECK_EQ(5, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that script break points survive when a script is reloaded.
 TEST(ScriptBreakPointReload) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
 
   v8::Local<v8::Function> f;
   v8::Local<v8::String> script = v8::String::New(
     "function f() {\n"
     "  function h() {\n"
     "    a = 0;  // line 2\n"
     "  }\n"
     "  b = 1;  // line 4\n"
     "  return h();\n"
@@ skipping 26 matching lines @@
 
   // Compile the script again and get the function.
   v8::Script::Compile(script, &origin_1)->Run();
   f = v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("f")));
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test when several scripts has the same script data
 TEST(ScriptBreakPointMultiple) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
 
   v8::Local<v8::Function> f;
   v8::Local<v8::String> script_f = v8::String::New(
     "function f() {\n"
     "  a = 0;  // line 1\n"
     "}");
 
   v8::Local<v8::Function> g;
   v8::Local<v8::String> script_g = v8::String::New(
@@ skipping 33 matching lines @@
   // Set script break point with the scripts loaded.
   sbp = SetScriptBreakPointFromJS("test", 1, 0);
 
   // Call f and g and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
   g->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test the script origin which has both name and line offset.
 TEST(ScriptBreakPointLineOffset) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
 
   v8::Local<v8::Function> f;
   v8::Local<v8::String> script = v8::String::New(
     "function f() {\n"
     "  a = 0;  // line 8 as this script has line offset 7\n"
     "  b = 0;  // line 9 as this script has line offset 7\n"
     "}");
 
   // Create script origin both name and line offset.
@@ skipping 23 matching lines @@
   CHECK_EQ(0, break_point_hit_count);
 
   // Set a script break point with the script loaded.
   sbp1 = SetScriptBreakPointFromJS("test.html", 9, 0);
 
   // Call f and check that the script break point is active.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test script break points set on lines.
 TEST(ScriptBreakPointLine) {
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
 
   v8::Local<v8::Function> f;
   v8::Local<v8::Function> g;
   v8::Local<v8::String> script = v8::String::New(
     "a = 0                      // line 0\n"
     "function f() {\n"
     "  a = 1;                   // line 2\n"
     "}\n"
     " a = 2;                    // line 4\n"
@@ skipping 69 matching lines @@
 
   // Clear the last break points, and reload the script which should not hit any
   // break points.
   ClearBreakPointFromJS(sbp1);
   ClearBreakPointFromJS(sbp5);
   ClearBreakPointFromJS(sbp6);
   break_point_hit_count = 0;
   v8::Script::Compile(script, &origin)->Run();
   CHECK_EQ(0, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that it is possible to remove the last break point for a function
 // inside the break handling of that break point.
 TEST(RemoveBreakPointInBreak) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   v8::Local<v8::Function> foo =
       CompileFunction(&env, "function foo(){a=1;}", "foo");
   debug_event_remove_break_point = SetBreakPoint(foo, 0);
 
   // Register the debug event listener pasing the function
-  v8::Debug::AddDebugEventListener(DebugEventRemoveBreakPoint, foo);
+  v8::Debug::SetDebugEventListener(DebugEventRemoveBreakPoint, foo);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventRemoveBreakPoint);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that the debugger statement causes a break.
 TEST(DebuggerStatement) {
   break_point_hit_count = 0;
   v8::HandleScope scope;
   DebugLocalContext env;
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount,
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount,
                                    v8::Undefined());
   v8::Script::Compile(v8::String::New("function bar(){debugger}"))->Run();
   v8::Script::Compile(v8::String::New(
       "function foo(){debugger;debugger;}"))->Run();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("foo")));
   v8::Local<v8::Function> bar =
       v8::Local<v8::Function>::Cast(env->Global()->Get(v8::String::New("bar")));
 
   // Run function with debugger statement
   bar->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   // Run function with two debugger statement
   foo->Call(env->Global(), 0, NULL);
   CHECK_EQ(3, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Thest that the evaluation of expressions when a break point is hit generates
 // the correct results.
 TEST(DebugEvaluate) {
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
   // Create a function for checking the evaluation when hitting a break point.
   evaluate_check_function = CompileFunction(&env,
                                             evaluate_check_source,
                                             "evaluate_check");
   // Register the debug event listener
-  v8::Debug::AddDebugEventListener(DebugEventEvaluate);
+  v8::Debug::SetDebugEventListener(DebugEventEvaluate);
 
   // Different expected vaules of x and a when in a break point (u = undefined,
   // d = Hello, world!).
   struct EvaluateCheck checks_uu[] = {
     {"x", v8::Undefined()},
     {"a", v8::Undefined()},
     {NULL, v8::Handle<v8::Value>()}
   };
   struct EvaluateCheck checks_hu[] = {
     {"x", v8::String::New("Hello, world!")},
@@ skipping 77 matching lines @@
 
   // Call bar setting breakpoint after a=x in barbar and parameter
   // "Hello, world!".
   checks = checks_hh;
   v8::Handle<v8::Value> argv_bar_3[2] = {
     v8::String::New("Hello, world!"),
     v8::Number::New(barbar_break_position + 1)
   };
   bar->Call(env->Global(), 2, argv_bar_3);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventEvaluate);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Simple test of the stepping mechanism using only store ICs.
 TEST(DebugStepLinear) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for testing stepping.
   v8::Local<v8::Function> foo = CompileFunction(&env,
                                                 "function foo(){a=1;b=1;c=1;}",
                                                 "foo");
   SetBreakPoint(foo, 3);
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(DebugEventStep);
 
   step_action = StepIn;
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // With stepping all break locations are hit.
   CHECK_EQ(4, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(NULL);
 
   // Register a debug event listener which just counts.
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // Without stepping only active break points are hit.
   CHECK_EQ(1, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test the stepping mechanism with different ICs.
 TEST(DebugStepLinearMixedICs) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for testing stepping.
   v8::Local<v8::Function> foo = CompileFunction(&env,
       "function bar() {};"
       "function foo() {"
       "  var x;"
       "  var index='name';"
       "  var y = {};"
       "  a=1;b=2;x=a;y[index]=3;x=y[index];bar();}", "foo");
   SetBreakPoint(foo, 0);
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(DebugEventStep);
 
   step_action = StepIn;
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // With stepping all break locations are hit. For ARM the keyed load/store
   // is not hit as they are not implemented as ICs.
 #if defined (__arm__) || defined(__thumb__)
   CHECK_EQ(6, break_point_hit_count);
 #else
   CHECK_EQ(8, break_point_hit_count);
 #endif
 
-  v8::Debug::RemoveDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(NULL);
 
   // Register a debug event listener which just counts.
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // Without stepping only active break points are hit.
   CHECK_EQ(1, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 TEST(DebugStepIf) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(DebugEventStep);
 
   // Create a function for testing stepping.
   const int argc = 1;
   const char* src = "function foo(x) { "
                     "  a = 1;"
                     "  if (x) {"
                     "    b = 1;"
                     "  } else {"
                     "    c = 1;"
                     "    d = 1;"
@@ skipping 10 matching lines @@
   CHECK_EQ(3, break_point_hit_count);
 
   // Stepping through the false part.
   step_action = StepIn;
   break_point_hit_count = 0;
   v8::Handle<v8::Value> argv_false[argc] = { v8::False() };
   foo->Call(env->Global(), argc, argv_false);
   CHECK_EQ(4, break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 TEST(DebugStepSwitch) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(DebugEventStep);
 
   // Create a function for testing stepping.
   const int argc = 1;
   const char* src = "function foo(x) { "
                     "  a = 1;"
                     "  switch (x) {"
                     "    case 1:"
                     "      b = 1;"
                     "    case 2:"
                     "      c = 1;"
@@ skipping 22 matching lines @@
   CHECK_EQ(3, break_point_hit_count);
 
   // Last case.
   step_action = StepIn;
   break_point_hit_count = 0;
   v8::Handle<v8::Value> argv_3[argc] = { v8::Number::New(3) };
   foo->Call(env->Global(), argc, argv_3);
   CHECK_EQ(4, break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 TEST(DebugStepFor) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(DebugEventStep);
 
   // Create a function for testing stepping.
   const int argc = 1;
   const char* src = "function foo(x) { "
                     "  a = 1;"
                     "  for (i = 0; i < x; i++) {"
                     "    b = 1;"
                     "  }"
                     "}";
   v8::Local<v8::Function> foo = CompileFunction(&env, src, "foo");
   SetBreakPoint(foo, 8);  // "a = 1;"
 
   // Looping 10 times.
   step_action = StepIn;
   break_point_hit_count = 0;
   v8::Handle<v8::Value> argv_10[argc] = { v8::Number::New(10) };
   foo->Call(env->Global(), argc, argv_10);
   CHECK_EQ(23, break_point_hit_count);
 
   // Looping 100 times.
   step_action = StepIn;
   break_point_hit_count = 0;
   v8::Handle<v8::Value> argv_100[argc] = { v8::Number::New(100) };
   foo->Call(env->Global(), argc, argv_100);
   CHECK_EQ(203, break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 TEST(StepInOutSimple) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
 
   // Create functions for testing stepping.
   const char* src = "function a() {b();c();}; "
                     "function b() {c();}; "
                     "function c() {}; ";
   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
   SetBreakPoint(a, 0);
 
   // Step through invocation of a with step in.
   step_action = StepIn;
@@ skipping 10 matching lines @@
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Step through invocation of a with step out.
   step_action = StepOut;
   break_point_hit_count = 0;
   expected_step_sequence = "a";
   a->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 TEST(StepInOutTree) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
 
   // Create functions for testing stepping.
   const char* src = "function a() {b(c(d()),d());c(d());d()}; "
                     "function b(x,y) {c();}; "
                     "function c(x) {}; "
                     "function d() {}; ";
   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
   SetBreakPoint(a, 0);
 
   // Step through invocation of a with step in.
@@ skipping 11 matching lines @@
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Step through invocation of a with step out.
   step_action = StepOut;
   break_point_hit_count = 0;
   expected_step_sequence = "a";
   a->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 TEST(StepInOutBranch) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
 
   // Create functions for testing stepping.
   const char* src = "function a() {b(false);c();}; "
                     "function b(x) {if(x){c();};}; "
                     "function c() {}; ";
   v8::Local<v8::Function> a = CompileFunction(&env, src, "a");
   SetBreakPoint(a, 0);
 
   // Step through invocation of a.
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "abaca";
   a->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test that step in does not step into native functions.
 TEST(DebugStepNatives) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for testing stepping.
   v8::Local<v8::Function> foo = CompileFunction(
       &env,
       "function foo(){debugger;Math.sin(1);}",
       "foo");
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(DebugEventStep);
 
   step_action = StepIn;
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // With stepping all break locations are hit.
   CHECK_EQ(3, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventStep);
+  v8::Debug::SetDebugEventListener(NULL);
 
   // Register a debug event listener which just counts.
-  v8::Debug::AddDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(DebugEventBreakPointHitCount);
 
   break_point_hit_count = 0;
   foo->Call(env->Global(), 0, NULL);
 
   // Without stepping only active break points are hit.
   CHECK_EQ(1, break_point_hit_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventBreakPointHitCount);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test break on exceptions. For each exception break combination the number
 // of debug event exception callbacks and message callbacks are collected. The
 // number of debug event exception callbacks are used to check that the
 // debugger is called correctly and the number of message callbacks is used to
 // check that uncaught exceptions are still returned even if there is a break
 // for them.
 TEST(BreakOnException) {
   v8::HandleScope scope;
   DebugLocalContext env;
   env.ExposeDebug();
 
   v8::internal::Top::TraceException(false);
 
   // Create functions for testing break on exception.
   v8::Local<v8::Function> throws =
       CompileFunction(&env, "function throws(){throw 1;}", "throws");
   v8::Local<v8::Function> caught =
       CompileFunction(&env,
                       "function caught(){try {throws();} catch(e) {};}",
                       "caught");
   v8::Local<v8::Function> notCaught =
       CompileFunction(&env, "function notCaught(){throws();}", "notCaught");
 
   v8::V8::AddMessageListener(MessageCallbackCount);
-  v8::Debug::AddDebugEventListener(DebugEventCounter);
+  v8::Debug::SetDebugEventListener(DebugEventCounter);
 
   // Initial state should be break on uncaught exception.
   DebugEventCounterClear();
   MessageCallbackCountClear();
   caught->Call(env->Global(), 0, NULL);
   CHECK_EQ(0, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, exception_hit_count);
@@ skipping 97 matching lines @@
   ChangeBreakOnExceptionFromJS(true, false);
   caught->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   notCaught->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, exception_hit_count);
   CHECK_EQ(1, uncaught_exception_hit_count);
   CHECK_EQ(1, message_callback_count);
 
-  v8::Debug::RemoveDebugEventListener(DebugEventCounter);
+  v8::Debug::SetDebugEventListener(NULL);
   v8::V8::RemoveMessageListeners(MessageCallbackCount);
 }
 
 
 // Test break on exception from compiler errors. When compiling using
 // v8::Script::Compile there is no JavaScript stack whereas when compiling using
 // eval there are JavaScript frames.
 TEST(BreakOnCompileException) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   v8::internal::Top::TraceException(false);
 
   // Create a function for checking the function when hitting a break point.
   frame_count = CompileFunction(&env, frame_count_source, "frame_count");
 
   v8::V8::AddMessageListener(MessageCallbackCount);
-  v8::Debug::AddDebugEventListener(DebugEventCounter);
+  v8::Debug::SetDebugEventListener(DebugEventCounter);
 
   DebugEventCounterClear();
   MessageCallbackCountClear();
 
   // Check initial state.
   CHECK_EQ(0, exception_hit_count);
   CHECK_EQ(0, uncaught_exception_hit_count);
   CHECK_EQ(0, message_callback_count);
   CHECK_EQ(-1, last_js_stack_height);
 
@@ skipping 30 matching lines @@
 TEST(StepWithException) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Create a function for checking the function when hitting a break point.
   frame_function_name = CompileFunction(&env,
                                         frame_function_name_source,
                                         "frame_function_name");
 
   // Register a debug event listener which steps and counts.
-  v8::Debug::AddDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(DebugEventStepSequence);
 
   // Create functions for testing stepping.
   const char* src = "function a() { n(); }; "
                     "function b() { c(); }; "
                     "function c() { n(); }; "
                     "function d() { x = 1; try { e(); } catch(x) { x = 2; } }; "
                     "function e() { n(); }; "
                     "function f() { x = 1; try { g(); } catch(x) { x = 2; } }; "
                     "function g() { h(); }; "
                     "function h() { x = 1; throw 1; }; ";
@@ skipping 46 matching lines @@
 
   // Step through invocation of f + g + h now with break on caught exceptions.
   ChangeBreakOnException(true, true);
   step_action = StepIn;
   break_point_hit_count = 0;
   expected_step_sequence = "ffghhf";
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(strlen(expected_step_sequence), break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventStepSequence);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 TEST(DebugBreak) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // This test should be run with option --verify-heap. This is an ASSERT and
   // not a CHECK as --verify-heap is only available in debug mode.
   ASSERT(v8::internal::FLAG_verify_heap);
 
   // Register a debug event listener which sets the break flag and counts.
-  v8::Debug::AddDebugEventListener(DebugEventBreak);
+  v8::Debug::SetDebugEventListener(DebugEventBreak);
 
   // Create a function for testing stepping.
   const char* src = "function f0() {}"
                     "function f1(x1) {}"
                     "function f2(x1,x2) {}"
                     "function f3(x1,x2,x3) {}";
   v8::Local<v8::Function> f0 = CompileFunction(&env, src, "f0");
   v8::Local<v8::Function> f1 = CompileFunction(&env, src, "f1");
   v8::Local<v8::Function> f2 = CompileFunction(&env, src, "f2");
   v8::Local<v8::Function> f3 = CompileFunction(&env, src, "f3");
@@ skipping 19 matching lines @@
     f0->Call(env->Global(), i, argv);
     f1->Call(env->Global(), i, argv);
     f2->Call(env->Global(), i, argv);
     f3->Call(env->Global(), i, argv);
   }
 
   // One break for each function called.
   CHECK_EQ(4 * ARRAY_SIZE(argv), break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventBreak);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 // Test to ensure that JavaScript code keeps running while the debug break
 // through the stack limit flag is set but breaks are disabled.
 TEST(DisableBreak) {
   v8::HandleScope scope;
   DebugLocalContext env;
 
   // Register a debug event listener which sets the break flag and counts.
-  v8::Debug::AddDebugEventListener(DebugEventCounter);
+  v8::Debug::SetDebugEventListener(DebugEventCounter);
 
   // Create a function for testing stepping.
   const char* src = "function f() {g()};function g(){i=0; while(i<10){i++}}";
   v8::Local<v8::Function> f = CompileFunction(&env, src, "f");
 
   // Set the debug break flag.
   v8::Debug::DebugBreak();
 
   // Call all functions with different argument count.
   break_point_hit_count = 0;
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(1, break_point_hit_count);
 
   {
     v8::Debug::DebugBreak();
     v8::internal::DisableBreak disable_break(true);
     f->Call(env->Global(), 0, NULL);
     CHECK_EQ(1, break_point_hit_count);
   }
 
   f->Call(env->Global(), 0, NULL);
   CHECK_EQ(2, break_point_hit_count);
 
   // Get rid of the debug event listener.
-  v8::Debug::RemoveDebugEventListener(DebugEventBreak);
+  v8::Debug::SetDebugEventListener(NULL);
 }
 
 
 static v8::Handle<v8::Array> NamedEnum(const v8::AccessorInfo&) {
   v8::Handle<v8::Array> result = v8::Array::New(3);
   result->Set(v8::Integer::New(0), v8::String::New("a"));
   result->Set(v8::Integer::New(1), v8::String::New("b"));
   result->Set(v8::Integer::New(2), v8::String::New("c"));
   return result;
 }
@@ skipping 741 matching lines @@
 }
 
 
 static void DummyDebugEventListener(v8::DebugEvent event,
                                     v8::Handle<v8::Object> exec_state,
                                     v8::Handle<v8::Object> event_data,
                                     v8::Handle<v8::Value> data) {
 }
 
 
-TEST(AddDebugEventListenerOnUninitializedVM) {
-  v8::Debug::AddDebugEventListener(DummyDebugEventListener);
+TEST(SetDebugEventListenerOnUninitializedVM) {
+  v8::Debug::SetDebugEventListener(DummyDebugEventListener);
 }
 
 
 static void DummyMessageHandler(const uint16_t* message,
                                 int length, void *data) {
 }
 
 
 TEST(SetMessageHandlerOnUninitializedVM) {
   v8::Debug::SetMessageHandler(DummyMessageHandler);
@@ skipping 148 matching lines @@
                                       "  CheckSourceLine(2)\n"
                                       "  CheckSourceLine(3)\n"
                                       "}; f()"))->Run();
 
   // Test that a parameter can be passed to a function called in the debugger.
   v8::Script::Compile(v8::String::New("CheckDataParameter()"))->Run();
 
   // Test that a function with closure can be run in the debugger.
   v8::Script::Compile(v8::String::New("CheckClosure()"))->Run();
 }