Transmit breakpoint id on paused event

runtime/vm/debugger.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 "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 137 matching lines @@
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
 void Debugger::SignalIsolateEvent(EventType type) {
   if (event_handler_ != NULL) {
     Debugger* debugger = Isolate::Current()->debugger();
     ASSERT(debugger != NULL);
-    DebuggerEvent event;
-    event.type = type;
+    DebuggerEvent event(type);
     event.isolate_id = debugger->GetIsolateId();
     ASSERT(event.isolate_id != ILLEGAL_ISOLATE_ID);
     if (type == kIsolateInterrupted) {
       DebuggerStackTrace* stack_trace = debugger->CollectStackTrace();
       ASSERT(stack_trace->Length() > 0);
       ASSERT(debugger->stack_trace_ == NULL);
       ASSERT(debugger->obj_cache_ == NULL);
       debugger->obj_cache_ = new RemoteObjectCache(64);
       debugger->stack_trace_ = stack_trace;
       (*event_handler_)(&event);
@@ skipping 867 matching lines @@
       bpt = new CodeBreakpoint(target_function, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
-    DebuggerEvent event;
-    event.type = kBreakpointResolved;
+    DebuggerEvent event(kBreakpointResolved);
     event.breakpoint = bpt;
     (*event_handler_)(&event);
   }
 }
 
 
 static void PrintStackTraceError(const char* message,
                                  ActivationFrame* current_activation,
                                  ActivationFrame* callee_activation) {
   const Function& current = current_activation->function();
@@ skipping 324 matching lines @@
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   ASSERT(obj_cache_ == NULL);
   in_event_notification_ = true;
   obj_cache_ = new RemoteObjectCache(64);
-  DebuggerEvent event;
-  event.type = kExceptionThrown;
+  DebuggerEvent event(kExceptionThrown);
   event.exception = &exc;
   (*event_handler_)(&event);
   in_event_notification_ = false;
   stack_trace_ = NULL;
   obj_cache_ = NULL;  // Remote object cache is zone allocated.
 }
 
 
 // Given a function and a token position range, return the best fit
 // token position to set a breakpoint.
@@ skipping 471 matching lines @@
       (fkind == RawFunction::kNoSuchMethodDispatcher) ||
       (fkind == RawFunction::kInvokeFieldDispatcher)) {
     return false;
   }
   const Class& cls = Class::Handle(func.Owner());
   const Library& lib = Library::Handle(cls.library());
   return lib.IsDebuggable();
 }
 
 
-void Debugger::SignalPausedEvent(ActivationFrame* top_frame) {
+void Debugger::SignalPausedEvent(ActivationFrame* top_frame,
+                                 SourceBreakpoint* bpt) {
   resume_action_ = kContinue;
   isolate_->set_single_step(false);
   ASSERT(!in_event_notification_);
   ASSERT(obj_cache_ == NULL);
   in_event_notification_ = true;
   obj_cache_ = new RemoteObjectCache(64);
-  DebuggerEvent event;
-  event.type = kBreakpointReached;
+  DebuggerEvent event(kBreakpointReached);
   event.top_frame = top_frame;
+  event.breakpoint = bpt;
   (*event_handler_)(&event);
   in_event_notification_ = false;
   obj_cache_ = NULL;  // Remote object cache is zone allocated.
 }
 
 
 void Debugger::SingleStepCallback() {
   ASSERT(resume_action_ == kSingleStep);
   ASSERT(isolate_->single_step());
   // We can't get here unless the debugger event handler enabled
@@ skipping 16 matching lines @@
 
   if (FLAG_verbose_debug) {
     OS::Print(">>> single step break at %s:%" Pd " (func %s token %" Pd ")\n",
               String::Handle(frame->SourceUrl()).ToCString(),
               frame->LineNumber(),
               String::Handle(frame->QualifiedFunctionName()).ToCString(),
               frame->TokenPos());
   }
 
   stack_trace_ = CollectStackTrace();
-  SignalPausedEvent(frame);
+  SignalPausedEvent(frame, NULL);
 
   RemoveInternalBreakpoints();
   if (resume_action_ == kStepOver) {
     InstrumentForStepping(func);
   } else if (resume_action_ == kStepOut) {
     if (stack_trace_->Length() > 1) {
       ActivationFrame* caller_frame = stack_trace_->FrameAt(1);
       InstrumentForStepping(caller_frame->function());
     }
   }
@@ skipping 25 matching lines @@
               report_bp ? "hit" : "ignore",
               bpt->IsInternal() ? "internal" : "user",
               String::Handle(bpt->SourceUrl()).ToCString(),
               bpt->LineNumber(),
               bpt->token_pos(),
               top_frame->pc());
   }
 
   if (report_bp && (event_handler_ != NULL)) {
     stack_trace_ = stack_trace;
-    SignalPausedEvent(top_frame);
+    SignalPausedEvent(top_frame, bpt->src_bpt_);
     stack_trace_ = NULL;
   }
 
   Function& func_to_instrument = Function::Handle();
   if (resume_action_ == kStepOver) {
     if (bpt->breakpoint_kind_ == PcDescriptors::kReturn) {
       // Step over return is converted into a single step so we break at
       // the caller.
       SetSingleStep();
     } else {
@@ skipping 251 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart