Deprecate old debugger breakpoint handler

runtime/vm/debugger_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_debugger_api.h"
 #include "platform/assert.h"
 #include "vm/dart_api_impl.h"
 #include "vm/thread.h"
 #include "vm/unit_test.h"
 
@@ skipping 219 matching lines @@
     EXPECT_TRUE(res);
     if (i < expected_frames) {
       VerifyStackFrame(frame, func_names[i], local_vars[i], skip_null_expects);
     } else {
       VerifyStackFrame(frame, NULL, Dart_Null(), skip_null_expects);
     }
   }
 }
 
 
+// TODO(hausner): Convert this one remaining use of the legacy
+// breakpoint handler once Dart_SetBreakpointHandler goes away.
 void TestBreakpointHandler(Dart_IsolateId isolate_id,
                            Dart_Breakpoint bpt,
                            Dart_StackTrace trace) {
   const char* expected_trace[] = {"A.foo", "main"};
   const intptr_t expected_trace_length = 2;
   breakpoint_hit = true;
   breakpoint_hit_counter++;
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
@@ skipping 31 matching lines @@
   SetBreakpointAtEntry("A", "foo");
 
   breakpoint_hit = false;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(breakpoint_hit == true);
 }
 
 
 void TestStepOutHandler(Dart_IsolateId isolate_id,
-                        Dart_Breakpoint bpt,
-                        Dart_StackTrace trace) {
+                        const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   const char* expected_bpts[] = {"f1", "foo", "main"};
   const intptr_t expected_bpts_length = ARRAY_SIZE(expected_bpts);
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
   EXPECT(breakpoint_hit_counter < expected_bpts_length);
   Dart_ActivationFrame frame;
   res = Dart_GetActivationFrame(trace, 0, &frame);
   EXPECT_VALID(res);
   Dart_Handle func_name;
@@ skipping 22 matching lines @@
       "foo() {                  \n"
       "  f1();                  \n"
       "  return f2();           \n"
       "}                        \n"
       "                         \n"
       "main() {                 \n"
       "  return foo();          \n"
       "}                        \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&TestStepOutHandler);
+  Dart_SetPausedEventHandler(&TestStepOutHandler);
 
   // Set a breakpoint in function f1, then repeatedly step out until
   // we get to main. We should see one breakpoint each in f1,
   // foo, main, but not in f2.
   SetBreakpointAtEntry("", "f1");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(2, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 void TestStepIntoHandler(Dart_IsolateId isolate_id,
-                         Dart_Breakpoint bpt,
-                         Dart_StackTrace trace) {
+                         const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   const char* expected_bpts[] = {
       "main",
         "foo",
           "f1",
         "foo",
           "X.X.",
         "foo",
           "X.kvmk",
             "f2",
           "X.kvmk",
@@ skipping 41 matching lines @@
       "  f1();                  \n"
       "  var o = new X();       \n"
       "  return o.kvmk(3, c:5); \n"
       "}                        \n"
       "                         \n"
       "main() {                 \n"
       "  return foo();          \n"
       "}                        \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&TestStepIntoHandler);
+  Dart_SetPausedEventHandler(&TestStepIntoHandler);
 
   // Set a breakpoint in function f1, then repeatedly step out until
   // we get to main. We should see one breakpoint each in f1,
   // foo, main, but not in f2.
   SetBreakpointAtEntry("", "main");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(7, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 static void StepIntoHandler(Dart_IsolateId isolate_id,
-                            Dart_Breakpoint bpt,
-                            Dart_StackTrace trace) {
+                            const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   if (verbose) {
     OS::Print(">>> Breakpoint nr. %d in %s <<<\n",
               breakpoint_hit_counter, BreakpointInfo(trace));
     PrintStackTrace(trace);
   }
   breakpoint_hit = true;
   breakpoint_hit_counter++;
   Dart_SetStepInto();
 }
 
 
 TEST_CASE(Debug_IgnoreBP) {
   const char* kScriptChars =
       "class B {                \n"
       "  static var z = 0;      \n"
       "  var i = 100;           \n"
       "  var d = 3.14;          \n"
       "  var s = 'Dr Seuss';    \n"
       "}                        \n"
       "                         \n"
       "main() {                 \n"
       "  var x = new B();       \n"
       "  return x.i + 1;        \n"
       "}                        \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&StepIntoHandler);
+  Dart_SetPausedEventHandler(&StepIntoHandler);
 
   SetBreakpointAtEntry("", "main");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
@@ skipping 10 matching lines @@
       "  for (int i = 0; i < 5000; i++) {   \n"
       "    foo(i);                          \n"
       "  }                                  \n"
       "}                                    \n"
       "                                     \n"
       "main() {                             \n"
       "  return foo(99);                    \n"
       "}                                    \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&StepIntoHandler);
+  Dart_SetPausedEventHandler(&StepIntoHandler);
 
 
   // Cause function foo to be optimized before we set a BP.
   Dart_Handle res = Invoke("warmup");
   EXPECT_VALID(res);
 
   // Now set breakpoint in main and then step into optimized function foo.
   SetBreakpointAtEntry("", "main");
 
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(2 * 99, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 void TestSingleStepHandler(Dart_IsolateId isolate_id,
-                           Dart_Breakpoint bpt,
-                           Dart_StackTrace trace) {
+                           const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   const char* expected_bpts[] = {
       "moo", "foo", "moo", "foo", "moo", "foo", "main"};
   const intptr_t expected_bpts_length = ARRAY_SIZE(expected_bpts);
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
   EXPECT(breakpoint_hit_counter < expected_bpts_length);
   Dart_ActivationFrame frame;
   res = Dart_GetActivationFrame(trace, 0, &frame);
   EXPECT_VALID(res);
@@ skipping 23 matching lines @@
       "  moo('step one');        \n"
       "  moo('step two');        \n"
       "  moo('step three');      \n"
       "}                         \n"
       "                          \n"
       "void main() {             \n"
       "  foo();                  \n"
       "}                         \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&TestSingleStepHandler);
+  Dart_SetPausedEventHandler(&TestSingleStepHandler);
 
   SetBreakpointAtEntry("", "moo");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(breakpoint_hit == true);
 }
 
 
 static void ClosureBreakpointHandler(Dart_IsolateId isolate_id,
-                                     Dart_Breakpoint bpt,
-                                     Dart_StackTrace trace) {
+                                     const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   const char* expected_trace[] = {"callback", "main"};
   const intptr_t expected_trace_length = 2;
   breakpoint_hit_counter++;
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
   EXPECT_EQ(expected_trace_length, trace_len);
   for (int i = 0; i < trace_len; i++) {
     Dart_ActivationFrame frame;
     res = Dart_GetActivationFrame(trace, i, &frame);
@@ skipping 17 matching lines @@
       "}                      \n"
       "                       \n"
       "main() {               \n"
       "  var h = callback;    \n"
       "  h('bla');            \n"
       "  callback('jada');    \n"
       "  return 442;          \n"
       "}                      \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&ClosureBreakpointHandler);
+  Dart_SetPausedEventHandler(&ClosureBreakpointHandler);
 
   SetBreakpointAtEntry("", "callback");
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(442, int_value);
   EXPECT_EQ(2, breakpoint_hit_counter);
 }
 
 
 static void ExprClosureBreakpointHandler(Dart_IsolateId isolate_id,
-                                         Dart_Breakpoint bpt,
-                                         Dart_StackTrace trace) {
+                                         const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   static const char* expected_trace[] = {"<anonymous closure>", "main"};
   Dart_Handle add_locals = Dart_NewList(4);
   Dart_ListSetAt(add_locals, 0, NewString("a"));
   Dart_ListSetAt(add_locals, 1, Dart_NewInteger(10));
   Dart_ListSetAt(add_locals, 2, NewString("b"));
   Dart_ListSetAt(add_locals, 3, Dart_NewInteger(20));
   Dart_Handle expected_locals[] = {add_locals, Dart_Null()};
   breakpoint_hit_counter++;
   PrintStackTrace(trace);
   VerifyStackTrace(trace, expected_trace, expected_locals, 2, false);
 }
 
 
 TEST_CASE(Debug_ExprClosureBreakpoint) {
   const char* kScriptChars =
       "var c;                 \n"
       "                       \n"
       "main() {               \n"
       "  c = (a, b) {         \n"
       "    return a + b;      \n"
       "  };                   \n"
       "  return c(10, 20);    \n"
       "}                      \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&ExprClosureBreakpointHandler);
+  Dart_SetPausedEventHandler(&ExprClosureBreakpointHandler);
 
   Dart_Handle script_url = NewString(TestCase::url());
   intptr_t line_no = 5;  // In closure 'add'.
   Dart_Handle res = Dart_SetBreakpoint(script_url, line_no);
   EXPECT_VALID(res);
   EXPECT(Dart_IsInteger(res));
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   int64_t int_value = 0;
   Dart_IntegerToInt64(retval, &int_value);
   EXPECT_EQ(30, int_value);
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 
 static intptr_t bp_id_to_be_deleted;
 
 static void DeleteBreakpointHandler(Dart_IsolateId isolate_id,
-                                    Dart_Breakpoint bpt,
-                                    Dart_StackTrace trace) {
+                                    const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   const char* expected_trace[] = {"foo", "main"};
   const intptr_t expected_trace_length = 2;
   breakpoint_hit_counter++;
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_VALID(res);
   EXPECT_EQ(expected_trace_length, trace_len);
   for (int i = 0; i < trace_len; i++) {
     Dart_ActivationFrame frame;
     res = Dart_GetActivationFrame(trace, i, &frame);
@@ skipping 28 matching lines @@
       "  foo();               \n"
       "  foo();               \n"
       "  foo();               \n"
       "}                      \n";
 
   LoadScript(kScriptChars);
 
   Dart_Handle script_url = NewString(TestCase::url());
   intptr_t line_no = 4;  // In function 'foo'.
 
-  Dart_SetBreakpointHandler(&DeleteBreakpointHandler);
+  Dart_SetPausedEventHandler(&DeleteBreakpointHandler);
 
   Dart_Handle res = Dart_SetBreakpoint(script_url, line_no);
   EXPECT_VALID(res);
   EXPECT(Dart_IsInteger(res));
   int64_t bp_id = 0;
   Dart_IntegerToInt64(res, &bp_id);
 
   // Function main() calls foo() 3 times. On the second iteration, the
   // breakpoint is removed by the handler, so we expect the breakpoint
   // to fire twice only.
   bp_id_to_be_deleted = bp_id;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT_EQ(2, breakpoint_hit_counter);
 }
 
 
 static void InspectStaticFieldHandler(Dart_IsolateId isolate_id,
-                                      Dart_Breakpoint bpt,
-                                      Dart_StackTrace trace) {
+                                      const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   ASSERT(script_lib != NULL);
   ASSERT(!Dart_IsError(script_lib));
   ASSERT(Dart_IsLibrary(script_lib));
   Dart_Handle class_A = Dart_GetClass(script_lib, NewString("A"));
   EXPECT_VALID(class_A);
 
   const int expected_num_fields = 2;
   struct {
     const char* field_name;
     const char* field_value;
@@ skipping 51 matching lines @@
     " debugBreak() { }                          \n"
     " main() {                                  \n"
     "   var a = new A();                        \n"
     "   debugBreak();                           \n"
     "   A.u = 442;                              \n"
     "   A.bla = 'silence is golden';            \n"
     "   debugBreak();                           \n"
     " }                                         \n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&InspectStaticFieldHandler);
+  Dart_SetPausedEventHandler(&InspectStaticFieldHandler);
   SetBreakpointAtEntry("", "debugBreak");
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
 }
 
 
 TEST_CASE(Debug_InspectObject) {
   const char* kScriptChars =
@@ skipping 363 matching lines @@
   {
     MonitorLocker ml(sync);
     while (interrupt_isolate_id != ILLEGAL_ISOLATE_ID) {
       ml.Wait();
     }
   }
   EXPECT(interrupt_isolate_id == ILLEGAL_ISOLATE_ID);
 }
 
 
-static void StackTraceDump1BreakpointHandler(Dart_IsolateId isolate_id,
-                                             Dart_Breakpoint bpt,
-                                             Dart_StackTrace trace) {
+static void StackTraceDump1BreakpointHandler(
+                Dart_IsolateId isolate_id,
+                const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
   const int kStackTraceLen = 4;
   static const char* expected_trace[kStackTraceLen] = {
     "local_to_main",
     "Test.local1_to_func1",
     "Test.func1",
     "main"
   };
 
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
@@ skipping 116 matching lines @@
       "    return i + j;\n"
       "  }\n"
       "  var sum = 0;\n"
       "  Test value = new Test(10);\n"
       "  var func1 = value.func1;\n"
       "  var main_local = local_to_main;\n"
       "  return func1(main_local);\n"
       "}\n";
 
   LoadScript(kScriptChars);
-  Dart_SetBreakpointHandler(&StackTraceDump1BreakpointHandler);
+  Dart_SetPausedEventHandler(&StackTraceDump1BreakpointHandler);
 
   Dart_Handle script_url = NewString(TestCase::url());
   intptr_t line_no = 34;  // In closure 'local_to_main'.
   Dart_Handle res = Dart_SetBreakpoint(script_url, line_no);
   EXPECT_VALID(res);
   EXPECT(Dart_IsInteger(res));
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
@@ skipping 159 matching lines @@
 
   Dart_Handle retval = Invoke("main");
   EXPECT(Dart_IsError(retval));
   EXPECT(Dart_IsUnhandledExceptionError(retval));
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart