Major rework of vm service events.

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_event.h"
 #include "vm/service_isolate.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 {
 
@@ skipping 77 matching lines @@
 
 void SourceBreakpoint::SetResolved(const Function& func, intptr_t token_pos) {
   ASSERT(!IsLatent());
   ASSERT(func.script() == script_);
   ASSERT((func.token_pos() <= token_pos) &&
          (token_pos <= func.end_token_pos()));
   ASSERT(func.is_debuggable());
   function_ = func.raw();
   token_pos_ = token_pos;
   end_token_pos_ = token_pos;
-  line_number_ = -1;  // Recalcualte lazily.
+  line_number_ = -1;  // Recalculate lazily.
   is_resolved_ = true;
 }
 
 
 // TODO(hausner): Get rid of library parameter. A source breakpoint location
 // does not imply a library, since the same source code can be included
 // in more than one library, e.g. the text location of mixin functions.
 void SourceBreakpoint::GetCodeLocation(Library* lib,
                                        Script* script,
                                        intptr_t* pos) {
@@ skipping 36 matching lines @@
 
 
 void SourceBreakpoint::PrintJSON(JSONStream* stream) {
   Isolate* isolate = Isolate::Current();
 
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", "Breakpoint");
 
   jsobj.AddPropertyF("id", "breakpoints/%" Pd "", id());
   jsobj.AddProperty("breakpointNumber", id());
-  jsobj.AddProperty("enabled", IsEnabled());
   jsobj.AddProperty("resolved", IsResolved());
 
   Library& library = Library::Handle(isolate);
   Script& script = Script::Handle(isolate);
   intptr_t token_pos;
   GetCodeLocation(&library, &script, &token_pos);
   {
     JSONObject location(&jsobj, "location");
     location.AddProperty("type", "Location");
     location.AddProperty("script", script);
@@ skipping 36 matching lines @@
 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);
+  //
+  // kBreakpointResolved events are handled differently in the vm
+  // service, so suppress them here.
+  if (Service::NeedsDebuggerEvents() &&
+      (event->type() != DebuggerEvent::kBreakpointResolved)) {
+    ServiceEvent service_event(event);
+    Service::HandleEvent(&service_event);
   }
 
   if (event_handler_ != NULL) {
     (*event_handler_)(event);
   }
+
+  if (Service::NeedsDebuggerEvents() && event->IsPauseEvent()) {
+    // If we were paused, notify the service that we have resumed.
+    ServiceEvent service_event(event->isolate(), ServiceEvent::kResume);
+    service_event.set_top_frame(event->top_frame());
+    Service::HandleEvent(&service_event);
+  }
 }
 
 
 void Debugger::SignalIsolateEvent(DebuggerEvent::EventType type) {
   if (HasEventHandler()) {
     DebuggerEvent event(isolate_, type);
     ASSERT(event.isolate_id() != ILLEGAL_ISOLATE_ID);
     if (type == DebuggerEvent::kIsolateInterrupted) {
       DebuggerStackTrace* trace = CollectStackTrace();
       ASSERT(trace->Length() > 0);
+      event.set_top_frame(trace->FrameAt(0));
       ASSERT(stack_trace_ == NULL);
       stack_trace_ = trace;
       resume_action_ = kContinue;
       Pause(&event);
       HandleSteppingRequest(trace);
       stack_trace_ = NULL;
     } else {
       InvokeEventHandler(&event);
     }
   }
 }
 
 
 void Debugger::SignalIsolateInterrupted() {
   if (HasEventHandler()) {
     Debugger* debugger = Isolate::Current()->debugger();
     ASSERT(debugger != NULL);
     debugger->SignalIsolateEvent(DebuggerEvent::kIsolateInterrupted);
   }
 }
 
 
+// The vm service handles breakpoint notifications in a different way
+// than the regular debugger breakpoint notifications.
+static void SendServiceBreakpointEvent(ServiceEvent::EventType type,
+                                       SourceBreakpoint* bpt) {
+  if (Service::NeedsDebuggerEvents() /*&& !bpt->IsOneShot()*/) {
+    ServiceEvent service_event(Isolate::Current(), type);
+    service_event.set_breakpoint(bpt);
+    Service::HandleEvent(&service_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 220 matching lines @@
       }
       ASSERT(Object::Handle(GetLocalVar(var_info.index())).IsContext());
       return Context::RawCast(GetLocalVar(var_info.index()));
     }
   }
   UNREACHABLE();
   return Context::null();
 }
 
 
-const char* DebuggerEvent::EventTypeToCString(EventType type) {
-  switch (type) {
-    case kBreakpointReached:
-      return "BreakpointReached";
-    case kBreakpointResolved:
-      return "BreakpointResolved";
-    case kExceptionThrown:
-      return "ExceptionThrown";
-    case kIsolateCreated:
-      return "IsolateCreated";
-    case kIsolateShutdown:
-      return "IsolateShutdown";
-    case kIsolateInterrupted:
-      return "IsolateInterrupted";
-    case kIsolateResumed:
-      return "IsolateResumed";
-    default:
-      UNREACHABLE();
-      return "Unknown";
-  }
-}
-
-
-void DebuggerEvent::PrintJSON(JSONStream* js) const {
-  JSONObject jsobj(js);
-  jsobj.AddProperty("type", "ServiceEvent");
-  // TODO(turnidge): Drop the 'id' for things like DebuggerEvent.
-  jsobj.AddProperty("id", "");
-  jsobj.AddProperty("eventType", EventTypeToCString(type()));
-  jsobj.AddProperty("isolate", isolate());
-  if ((type() == kBreakpointResolved || type() == kBreakpointReached) &&
-      breakpoint() != NULL) {
-    // TODO(turnidge): Make this a breakpoint ref.
-    jsobj.AddProperty("breakpoint", breakpoint());
-  }
-  if (type() == kExceptionThrown) {
-    jsobj.AddProperty("exception", *(exception()));
-  }
-}
-
-
 ActivationFrame* DebuggerStackTrace::GetHandlerFrame(
     const Instance& exc_obj) const {
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const TypeArguments& no_instantiator = TypeArguments::Handle();
   for (intptr_t frame_index = 0;
        frame_index < Length();
        frame_index++) {
     ActivationFrame* frame = FrameAt(frame_index);
@@ skipping 318 matching lines @@
                     func_name,
                     url.ToCString(),
                     line,
                     ctx_.ToCString(),
                     ContextLevel());
 }
 
 
 void ActivationFrame::PrintToJSONObject(JSONObject* jsobj) {
   const Script& script = Script::Handle(SourceScript());
+  jsobj->AddProperty("type", "Frame");
   jsobj->AddProperty("script", script);
   jsobj->AddProperty("tokenPos", TokenPos());
   jsobj->AddProperty("function", function());
   jsobj->AddProperty("code", code());
   {
     JSONArray jsvars(jsobj, "vars");
     const int num_vars = NumLocalVariables();
     for (intptr_t v = 0; v < num_vars; v++) {
       JSONObject jsvar(&jsvars);
       String& var_name = String::Handle();
@@ skipping 503 matching lines @@
       (!HasEventHandler()) ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
   DebuggerEvent event(isolate_, DebuggerEvent::kExceptionThrown);
   event.set_exception(&exc);
+  ASSERT(stack_trace->Length() > 0);
+  event.set_top_frame(stack_trace->FrameAt(0));
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
   Pause(&event);
   stack_trace_ = NULL;
 }
 
 
 static intptr_t LastTokenOnLine(const TokenStream& tokens, intptr_t pos) {
   TokenStream::Iterator iter(tokens, pos, TokenStream::Iterator::kAllTokens);
   ASSERT(iter.IsValid());
@@ skipping 301 matching lines @@
       bpt->Enable();
       if (FLAG_verbose_debug) {
         intptr_t line_number;
         script.GetTokenLocation(breakpoint_pos, &line_number, NULL);
         OS::Print("Resolved BP for "
                   "function '%s' at line %" Pd "\n",
                   func.ToFullyQualifiedCString(),
                   line_number);
       }
       SignalBpResolved(bpt);
+      SendServiceBreakpointEvent(ServiceEvent::kBreakpointAdded, bpt);
       return bpt;
     }
   }
   // There is no compiled function at this token position.
   // Register an unresolved breakpoint.
   if (FLAG_verbose_debug && !func.IsNull()) {
     intptr_t line_number;
     script.GetTokenLocation(token_pos, &line_number, NULL);
     OS::Print("Registering pending breakpoint for "
               "uncompiled function '%s' at line %" Pd "\n",
               func.ToFullyQualifiedCString(),
               line_number);
   }
   SourceBreakpoint* bpt = GetSourceBreakpoint(script, token_pos);
   if (bpt == NULL) {
     bpt = new SourceBreakpoint(nextId(), script, token_pos, last_token_pos);
     RegisterSourceBreakpoint(bpt);
+    SendServiceBreakpointEvent(ServiceEvent::kBreakpointAdded, bpt);
   }
   bpt->Enable();
   return bpt;
 }
 
 
 // Synchronize the enabled/disabled state of all code breakpoints
 // associated with the source breakpoint bpt.
 void Debugger::SyncBreakpoint(SourceBreakpoint* bpt) {
   CodeBreakpoint* cbpt = code_breakpoints_;
@@ skipping 604 matching lines @@
           OS::Print("Resolved BP %" Pd " to pos %" Pd ", line %" Pd ", "
                     "function '%s' (requested range %" Pd "-%" Pd ")\n",
                     bpt->id(),
                     bpt->token_pos(),
                     bpt->LineNumber(),
                     func.ToFullyQualifiedCString(),
                     requested_pos,
                     requested_end_pos);
         }
         SignalBpResolved(bpt);
+        SendServiceBreakpointEvent(ServiceEvent::kBreakpointResolved, bpt);
       }
       ASSERT(bpt->IsResolved());
       if (FLAG_verbose_debug) {
         OS::Print("Setting breakpoint %" Pd " at line %" Pd " for %s '%s'\n",
                   bpt->id(),
                   bpt->LineNumber(),
                   func.IsClosureFunction() ? "closure" : "function",
                   String::Handle(func.name()).ToCString());
       }
       MakeCodeBreakpointAt(func, bpt);
@@ skipping 137 matching lines @@
 void Debugger::RemoveBreakpoint(intptr_t bp_id) {
   SourceBreakpoint* prev_bpt = NULL;
   SourceBreakpoint* curr_bpt = src_breakpoints_;
   while (curr_bpt != NULL) {
     if (curr_bpt->id() == bp_id) {
       if (prev_bpt == NULL) {
         src_breakpoints_ = src_breakpoints_->next();
       } else {
         prev_bpt->set_next(curr_bpt->next());
       }
+      SendServiceBreakpointEvent(ServiceEvent::kBreakpointRemoved, curr_bpt);
 
       // Remove references from code breakpoints to this source breakpoint,
       // and disable the code breakpoints.
       UnlinkCodeBreakpoints(curr_bpt);
       delete curr_bpt;
 
       // Remove references from the current debugger pause event.
       if (pause_event_ != NULL &&
           pause_event_->type() == DebuggerEvent::kBreakpointReached &&
           pause_event_->breakpoint() == curr_bpt) {
@@ skipping 101 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart