Add support for asynchronous event notification to the observatory.

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"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flags.h"
 #include "vm/globals.h"
 #include "vm/longjump.h"
 #include "vm/json_stream.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/port.h"
+#include "vm/service.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_debugger, true, "Enables debugger step checks");
 DEFINE_FLAG(bool, show_invisible_frames, false,
@@ skipping 153 matching lines @@
       context_level_(-1),
       deopt_frame_(Array::ZoneHandle(deopt_frame.raw())),
       deopt_frame_offset_(deopt_frame_offset),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
+bool Debugger::HasEventHandler() {
+  return (event_handler_ != NULL) || Service::NeedsDebuggerEvents();
+}
+
+
+void Debugger::InvokeEventHandler(DebuggerEvent* event) {
+  ASSERT(HasEventHandler());
+
+  // Give the event to the Service first, as the debugger event handler
+  // may go into a message loop and the Service will not.
+  if (Service::NeedsDebuggerEvents()) {
+    Service::HandleDebuggerEvent(event);
+  }
+
+  if (event_handler_ != NULL) {
+    (*event_handler_)(event);
+  }
+}
+
+
 void Debugger::SignalIsolateEvent(DebuggerEvent::EventType type) {
-  if (event_handler_ != NULL) {
-    DebuggerEvent event(type);
-    event.set_isolate_id(isolate_id_);
+  if (HasEventHandler()) {
+    DebuggerEvent event(isolate_, type);
     ASSERT(event.isolate_id() != ILLEGAL_ISOLATE_ID);
     if (type == DebuggerEvent::kIsolateInterrupted) {
       DebuggerStackTrace* trace = CollectStackTrace();
       ASSERT(trace->Length() > 0);
       ASSERT(stack_trace_ == NULL);
       stack_trace_ = trace;
       resume_action_ = kContinue;
       Pause(&event);
       HandleSteppingRequest(trace);
       stack_trace_ = NULL;
     } else {
-      (*event_handler_)(&event);
+      InvokeEventHandler(&event);
     }
   }
 }
 
 
 void Debugger::SignalIsolateInterrupted() {
-  if (event_handler_ != NULL) {
+  if (HasEventHandler()) {
     Debugger* debugger = Isolate::Current()->debugger();
     ASSERT(debugger != NULL);
     debugger->SignalIsolateEvent(DebuggerEvent::kIsolateInterrupted);
   }
 }
 
 
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.Owner());
@@ skipping 275 matching lines @@
       return "IsolateInterrupted";
     default:
       UNREACHABLE();
       return "Unknown";
   }
 }
 
 
 void DebuggerEvent::PrintJSON(JSONStream* js) const {
   JSONObject jsobj(js);
-  jsobj.AddProperty("type", "DebuggerEvent");
+  jsobj.AddProperty("type", "ServiceEvent");
   // TODO(turnidge): Drop the 'id' for things like DebuggerEvent.
   jsobj.AddProperty("id", "");
-  // TODO(turnidge): Add 'isolate'.
   jsobj.AddProperty("eventType", EventTypeToCString(type()));
+  jsobj.AddProperty("isolate", isolate());
   if (type() == kBreakpointResolved || type() == kBreakpointReached) {
     jsobj.AddProperty("breakpoint", breakpoint());
   }
   if (type() == kExceptionThrown) {
     jsobj.AddProperty("exception", *(exception()));
   }
 }
 
 
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
@@ skipping 677 matching lines @@
       }
       bpt = new CodeBreakpoint(code, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
-  if (event_handler_ != NULL) {
-    DebuggerEvent event(DebuggerEvent::kBreakpointResolved);
+  if (HasEventHandler()) {
+    DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointResolved);
     event.set_breakpoint(bpt);
-    (*event_handler_)(&event);
+    InvokeEventHandler(&event);
   }
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code,
                                             const Array& deopt_frame,
                                             intptr_t deopt_frame_offset,
@@ skipping 264 matching lines @@
 }
 
 
 void Debugger::SignalExceptionThrown(const Instance& exc) {
   // We ignore this exception event when the VM is executing code invoked
   // by the debugger to evaluate variables values, when we see a nested
   // breakpoint or exception event, or if the debugger is not
   // interested in exception events.
   if (ignore_breakpoints_ ||
       IsPaused() ||
-      (event_handler_ == NULL) ||
+      (!HasEventHandler()) ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
-  DebuggerEvent event(DebuggerEvent::kExceptionThrown);
+  DebuggerEvent event(isolate_, DebuggerEvent::kExceptionThrown);
   event.set_exception(&exc);
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   Pause(&event);
   stack_trace_ = NULL;
 }
 
 
 // Given a function and a token range, return the best fit
 // token position to set a breakpoint. The best fit is the safe point
@@ skipping 609 matching lines @@
     prefix_name = String::Concat(prefix_name, Symbols::Dot());
     for (intptr_t i = 0; i < prefix.num_imports(); i++) {
       imported = prefix.GetLibrary(i);
       CollectLibraryFields(field_list, imported, prefix_name, false);
     }
   }
   return Array::MakeArray(field_list);
 }
 
 
+// static
 void Debugger::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   ASSERT(visitor != NULL);
   SourceBreakpoint* bpt = src_breakpoints_;
   while (bpt != NULL) {
     bpt->VisitObjectPointers(visitor);
     bpt = bpt->next();
   }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     cbpt->VisitObjectPointers(visitor);
     cbpt = cbpt->next();
   }
 }
 
 
+// static
 void Debugger::SetEventHandler(EventHandler* handler) {
   event_handler_ = handler;
 }
 
 
 void Debugger::Pause(DebuggerEvent* event) {
   ASSERT(!IsPaused());  // No recursive pausing.
   ASSERT(obj_cache_ == NULL);
 
   pause_event_ = event;
   obj_cache_ = new RemoteObjectCache(64);
 
-  (*event_handler_)(event);
+  InvokeEventHandler(event);
 
   pause_event_ = NULL;
   obj_cache_ = NULL;    // Zone allocated
 }
 
 
 void Debugger::HandleSteppingRequest(DebuggerStackTrace* stack_trace) {
   stepping_fp_ = 0;
   if (resume_action_ == kSingleStep) {
     isolate_->set_single_step(true);
@@ skipping 26 matching lines @@
 }
 
 
 void Debugger::SignalPausedEvent(ActivationFrame* top_frame,
                                  SourceBreakpoint* bpt) {
   resume_action_ = kContinue;
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
-  DebuggerEvent event(DebuggerEvent::kBreakpointReached);
+  DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointReached);
   event.set_top_frame(top_frame);
   event.set_breakpoint(bpt);
   Pause(&event);
 }
 
 
 void Debugger::DebuggerStepCallback() {
   ASSERT(isolate_->single_step());
   // We can't get here unless the debugger event handler enabled
   // single stepping.
-  ASSERT(event_handler_ != NULL);
+  ASSERT(HasEventHandler());
   // Don't pause recursively.
   if (IsPaused()) return;
 
   // Check whether we are in a Dart function that the user is
   // interested in. If we saved the frame pointer of a stack frame
   // the user is interested in, we ignore the single step if we are
   // in a callee of that frame. Note that we assume that the stack
   // grows towards lower addresses.
   ActivationFrame* frame = TopDartFrame();
   ASSERT(frame != NULL);
@@ skipping 39 matching lines @@
   SignalPausedEvent(frame, NULL);
   HandleSteppingRequest(stack_trace_);
   stack_trace_ = NULL;
 }
 
 
 void Debugger::SignalBpReached() {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
-  if (ignore_breakpoints_ || IsPaused() || (event_handler_ == NULL)) {
+  if (ignore_breakpoints_ || IsPaused() || !HasEventHandler()) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ActivationFrame* top_frame = stack_trace->FrameAt(0);
   ASSERT(top_frame != NULL);
   CodeBreakpoint* bpt = GetCodeBreakpoint(top_frame->pc());
   ASSERT(bpt != NULL);
 
   if (FLAG_verbose_debug) {
@@ skipping 265 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart