Add pause/resume for isolates in vmservice/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"
@@ skipping 81 matching lines @@
   token_pos_ = token_pos;
   end_token_pos_ = token_pos;
   line_number_ = -1;  // Recalcualte 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) {
+void SourceBreakpoint::GetCodeLocation(Library* lib,
+                                       Script* script,
+                                       intptr_t* pos) {
   *script = this->script();
   *pos = token_pos_;
   if (IsResolved()) {
     const Function& func = Function::Handle(function_);
     ASSERT(!func.IsNull());
     const Class& cls = Class::Handle(func.origin());
     *lib = cls.library();
   } else {
     *lib = Library::null();
   }
@@ skipping 69 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()) {
 }
 
 
-void Debugger::SignalIsolateEvent(EventType type) {
+void Debugger::SignalIsolateEvent(DebuggerEvent::EventType type) {
   if (event_handler_ != NULL) {
     DebuggerEvent event(type);
-    event.isolate_id = isolate_id_;
-    ASSERT(event.isolate_id != ILLEGAL_ISOLATE_ID);
-    if (type == kIsolateInterrupted) {
+    event.set_isolate_id(isolate_id_);
+    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);
     }
   }
 }
 
 
 void Debugger::SignalIsolateInterrupted() {
   if (event_handler_ != NULL) {
     Debugger* debugger = Isolate::Current()->debugger();
     ASSERT(debugger != NULL);
-    debugger->SignalIsolateEvent(kIsolateInterrupted);
+    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());
   String& class_name = String::Handle(func_class.Name());
 
   const char* kFormat = "%s%s%s";
@@ skipping 249 matching lines @@
                      var_info.index);
       }
       return GetLocalContextVar(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";
+    default:
+      UNREACHABLE();
+      return "Unknown";
+  }
+}
+
+
+void DebuggerEvent::PrintJSON(JSONStream* js) const {
+  JSONObject jsobj(js);
+  jsobj.AddProperty("type", "DebuggerEvent");
+  // TODO(turnidge): Drop the 'id' for things like DebuggerEvent.
+  jsobj.AddProperty("id", "");
+  // TODO(turnidge): Add 'isolate'.
+  jsobj.AddProperty("eventType", EventTypeToCString(type()));
+  if (type() == kBreakpointResolved || type() == kBreakpointReached) {
+    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 523 matching lines @@
     src_breakpoints_ = src_breakpoints_->next();
     delete bpt;
   }
   while (code_breakpoints_ != NULL) {
     CodeBreakpoint* bpt = code_breakpoints_;
     code_breakpoints_ = code_breakpoints_->next();
     bpt->Disable();
     delete bpt;
   }
   // Signal isolate shutdown event.
-  SignalIsolateEvent(Debugger::kIsolateShutdown);
+  SignalIsolateEvent(DebuggerEvent::kIsolateShutdown);
 }
 
 
 static RawFunction* ResolveLibraryFunction(
                         const Library& library,
                         const String& fname) {
   ASSERT(!library.IsNull());
   const Object& object = Object::Handle(library.ResolveName(fname));
   if (!object.IsNull() && object.IsFunction()) {
     return Function::Cast(object).raw();
@@ skipping 125 matching lines @@
       bpt = new CodeBreakpoint(code, i);
       RegisterCodeBreakpoint(bpt);
       bpt->Enable();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(SourceBreakpoint* bpt) {
   if (event_handler_ != NULL) {
-    DebuggerEvent event(kBreakpointResolved);
-    event.breakpoint = bpt;
+    DebuggerEvent event(DebuggerEvent::kBreakpointResolved);
+    event.set_breakpoint(bpt);
     (*event_handler_)(&event);
   }
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
                                             const Code& code_param,
                                             const Array& deopt_frame,
@@ skipping 282 matching lines @@
   if (ignore_breakpoints_ ||
       IsPaused() ||
       (event_handler_ == NULL) ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
-  DebuggerEvent event(kExceptionThrown);
-  event.exception = &exc;
+  DebuggerEvent event(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
 // with the lowest compiled code address within the token range.
@@ skipping 664 matching lines @@
       ActivationFrame* frame = stack_trace->FrameAt(i);
       if (frame->IsDebuggable()) {
         stepping_fp_ = frame->fp();
         break;
       }
     }
   }
 }
 
 
+// static
 bool Debugger::IsDebuggable(const Function& func) {
   if (!IsDebuggableFunctionKind(func)) {
     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,
                                  SourceBreakpoint* bpt) {
   resume_action_ = kContinue;
   stepping_fp_ = 0;
   isolate_->set_single_step(false);
   ASSERT(!IsPaused());
   ASSERT(obj_cache_ == NULL);
-  DebuggerEvent event(kBreakpointReached);
-  event.top_frame = top_frame;
-  event.breakpoint = bpt;
+  DebuggerEvent event(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);
   // Don't pause recursively.
@@ skipping 91 matching lines @@
     return;
   }
   isolate_ = isolate;
   // Use the isolate's control port as the isolate_id for debugging.
   // This port will be used as a unique ID to represet the isolate in the
   // debugger wire protocol messages.
   isolate_id_ = isolate->main_port();
   initialized_ = true;
 
   // Signal isolate creation event.
-  SignalIsolateEvent(Debugger::kIsolateCreated);
+  SignalIsolateEvent(DebuggerEvent::kIsolateCreated);
 }
 
 
 // Return innermost closure contained in 'function' that contains
 // the given token position.
 RawFunction* Debugger::FindInnermostClosure(const Function& function,
                                             intptr_t token_pos) {
   const Class& owner = Class::Handle(isolate_, function.Owner());
   if (owner.closures() == GrowableObjectArray::null()) {
     return Function::null();
@@ skipping 222 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart