Add isolate event handler setup in order to be able to propagate isolate

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 "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, verbose_debug, false, "Verbose debugger messages");
 
+
+static void DefaultBreakpointHandler(SourceBreakpoint* bpt,
+                                     DebuggerStackTrace* stack) {
+  String& var_name = String::Handle();
+  Instance& value = Instance::Handle();
+  for (intptr_t i = 0; i < stack->Length(); i++) {
+    ActivationFrame* frame = stack->ActivationFrameAt(i);
+    OS::Print("   %"Pd". %s\n",
+              i + 1, frame->ToCString());
+    intptr_t num_locals = frame->NumLocalVariables();
+    for (intptr_t i = 0; i < num_locals; i++) {
+      intptr_t token_pos, end_pos;
+      frame->VariableAt(i, &var_name, &token_pos, &end_pos, &value);
+      OS::Print("      var %s (pos %"Pd") = %s\n",
+                var_name.ToCString(), token_pos, value.ToCString());
+    }
+  }
+}
+
+
+BreakpointHandler* Debugger::bp_handler_ = DefaultBreakpointHandler;
+Debugger::EventHandler* Debugger::event_handler_ = NULL;
+
+
 class RemoteObjectCache : public ZoneAllocated {
  public:
   explicit RemoteObjectCache(intptr_t initial_size);
   intptr_t AddObject(const Object& obj);
   RawObject* GetObj(intptr_t obj_id) const;
   bool IsValidId(intptr_t obj_id) const {
     return obj_id < objs_->Length();
   }
 
  private:
@@ skipping 89 matching lines @@
   if (function_.IsNull()) {
     Isolate* isolate = Isolate::Current();
     ASSERT(isolate != NULL);
     const Code& code = Code::Handle(Code::LookupCode(pc_));
     function_ = code.function();
   }
   return function_;
 }
 
 
+void Debugger::SignalIsolateEvent(EventType type) {
+  if (event_handler_ != NULL) {
+    DebuggerEvent event;
+    event.type = type;
+    event.isolate = Isolate::Current();
+    (*event_handler_)(&event);
+  }
+}
+
+
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.Owner());
   String& class_name = String::Handle(func_class.Name());
 
   const char* kFormat = "%s%s%s";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat,
       func_class.IsTopLevel() ? "" : class_name.ToCString(),
       func_class.IsTopLevel() ? "" : ".",
       func_name.ToCString());
@@ skipping 445 matching lines @@
 
 RawObject* RemoteObjectCache::GetObj(intptr_t obj_id) const {
   ASSERT(IsValidId(obj_id));
   return objs_->At(obj_id);
 }
 
 
 Debugger::Debugger()
     : isolate_(NULL),
       initialized_(false),
-      bp_handler_(NULL),
-      event_handler_(NULL),
       next_id_(1),
       stack_trace_(NULL),
       obj_cache_(NULL),
       src_breakpoints_(NULL),
       code_breakpoints_(NULL),
       resume_action_(kContinue),
       last_bpt_line_(-1),
       ignore_breakpoints_(false),
       exc_pause_info_(kNoPauseOnExceptions) {
 }
@@ skipping 619 matching lines @@
     bpt = bpt->next();
   }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     cbpt->VisitObjectPointers(visitor);
     cbpt = cbpt->next();
   }
 }
 
 
-static void DefaultBreakpointHandler(SourceBreakpoint* bpt,
-                                     DebuggerStackTrace* stack) {
-  String& var_name = String::Handle();
-  Instance& value = Instance::Handle();
-  for (intptr_t i = 0; i < stack->Length(); i++) {
-    ActivationFrame* frame = stack->ActivationFrameAt(i);
-    OS::Print("   %"Pd". %s\n",
-              i + 1, frame->ToCString());
-    intptr_t num_locals = frame->NumLocalVariables();
-    for (intptr_t i = 0; i < num_locals; i++) {
-      intptr_t token_pos, end_pos;
-      frame->VariableAt(i, &var_name, &token_pos, &end_pos, &value);
-      OS::Print("      var %s (pos %"Pd") = %s\n",
-                var_name.ToCString(), token_pos, value.ToCString());
-    }
-  }
-}
-
-
 void Debugger::SetBreakpointHandler(BreakpointHandler* handler) {
-  bp_handler_ = handler;
-  if (bp_handler_ == NULL) {
-    bp_handler_ = &DefaultBreakpointHandler;
+  if (bp_handler_ != NULL) {
+    bp_handler_ = handler;
   }
 }
 
 
 void Debugger::SetEventHandler(EventHandler* handler) {
   event_handler_ = handler;
 }
 
 
 bool Debugger::IsDebuggable(const Function& func) {
@@ skipping 123 matching lines @@
   }
 }
 
 
 void Debugger::Initialize(Isolate* isolate) {
   if (initialized_) {
     return;
   }
   isolate_ = isolate;
   initialized_ = true;
-  SetBreakpointHandler(DefaultBreakpointHandler);
 }
 
 
 void Debugger::NotifyCompilation(const Function& func) {
   if (src_breakpoints_ == NULL) {
     // Return with minimal overhead if there are no breakpoints.
     return;
   }
   Function& lookup_function = Function::Handle(func.raw());
   if (func.IsImplicitClosureFunction()) {
@@ skipping 152 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart