Major rework of vm service events.

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
 #include "vm/compiler_stats.h"
 #include "vm/coverage.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
 #include "vm/log.h"
 #include "vm/message_handler.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/object.h"
 #include "vm/os_thread.h"
 #include "vm/parser.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/service.h"
+#include "vm/service_event.h"
 #include "vm/service_isolate.h"
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 #include "vm/thread_interrupter.h"
 #include "vm/timer.h"
 #include "vm/visitor.h"
 
@@ skipping 67 matching lines @@
 
 
 class IsolateMessageHandler : public MessageHandler {
  public:
   explicit IsolateMessageHandler(Isolate* isolate);
   ~IsolateMessageHandler();
 
   const char* name() const;
   void MessageNotify(Message::Priority priority);
   bool HandleMessage(Message* message);
+  void NotifyPauseOnStart();
+  void NotifyPauseOnExit();
 
 #if defined(DEBUG)
   // Check that it is safe to access this handler.
   void CheckAccess();
 #endif
   bool IsCurrentIsolate() const;
   virtual Isolate* isolate() const { return isolate_; }
 
  private:
   // Keep in sync with isolate_patch.dart.
@@ skipping 250 matching lines @@
       success = ProcessUnhandledException(Error::Cast(result));
     } else {
       ASSERT(result.IsNull());
     }
   }
   delete message;
   return success;
 }
 
 
+void IsolateMessageHandler::NotifyPauseOnStart() {
+  StartIsolateScope start_isolate(isolate());
+  StackZone zone(I);
+  HandleScope handle_scope(I);
+  ServiceEvent pause_event(isolate(), ServiceEvent::kPauseStart);
+  Service::HandleEvent(&pause_event);
+}
+
+
+void IsolateMessageHandler::NotifyPauseOnExit() {
+  StartIsolateScope start_isolate(isolate());
+  StackZone zone(I);
+  HandleScope handle_scope(I);
+  ServiceEvent pause_event(isolate(), ServiceEvent::kPauseExit);
+  Service::HandleEvent(&pause_event);
+}
+
+
 #if defined(DEBUG)
 void IsolateMessageHandler::CheckAccess() {
   ASSERT(IsCurrentIsolate());
 }
 #endif
 
 
 bool IsolateMessageHandler::IsCurrentIsolate() const {
   return (I == Isolate::Current());
 }
@@ skipping 914 matching lines @@
       func ^= entry.raw();
       jsobj.AddProperty("entry", func);
     }
   }
   {
     JSONObject jsheap(&jsobj, "heaps");
     heap()->PrintToJSONObject(Heap::kNew, &jsheap);
     heap()->PrintToJSONObject(Heap::kOld, &jsheap);
   }
 
-  // TODO(turnidge): Don't compute a full stack trace every time we
-  // request an isolate's info.
-  DebuggerStackTrace* stack = debugger()->StackTrace();
-  if (stack->Length() > 0) {
-    JSONObject jsframe(&jsobj, "topFrame");
-
-    ActivationFrame* frame = stack->FrameAt(0);
-    frame->PrintToJSONObject(&jsobj);
-    // TODO(turnidge): Implement depth differently -- differentiate
-    // inlined frames.
-    jsobj.AddProperty("depth", (intptr_t)0);
-  }
   jsobj.AddProperty("livePorts", message_handler()->live_ports());
   jsobj.AddProperty("pauseOnExit", message_handler()->pause_on_exit());
 
-  // TODO(turnidge): Make the debugger support paused_on_start/exit.
   if (message_handler()->paused_on_start()) {
     ASSERT(debugger()->PauseEvent() == NULL);
-    DebuggerEvent pauseEvent(this, DebuggerEvent::kIsolateCreated);
-    jsobj.AddProperty("pauseEvent", &pauseEvent);
+    ServiceEvent pause_event(this, ServiceEvent::kPauseStart);
+    jsobj.AddProperty("pauseEvent", &pause_event);
   } else if (message_handler()->paused_on_exit()) {
     ASSERT(debugger()->PauseEvent() == NULL);
-    DebuggerEvent pauseEvent(this, DebuggerEvent::kIsolateShutdown);
-    jsobj.AddProperty("pauseEvent", &pauseEvent);
+    ServiceEvent pause_event(this, ServiceEvent::kPauseExit);
+    jsobj.AddProperty("pauseEvent", &pause_event);
   } else if (debugger()->PauseEvent() != NULL) {
-    jsobj.AddProperty("pauseEvent", debugger()->PauseEvent());
+    ServiceEvent pause_event(debugger()->PauseEvent());
+    jsobj.AddProperty("pauseEvent", &pause_event);
+  } else {
+    ServiceEvent pause_event(this, ServiceEvent::kResume);
+
+    // TODO(turnidge): Don't compute a full stack trace.
+    DebuggerStackTrace* stack = debugger()->StackTrace();
+    if (stack->Length() > 0) {
+      pause_event.set_top_frame(stack->FrameAt(0));
+    }
+    jsobj.AddProperty("pauseEvent", &pause_event);
   }
 
   const Library& lib =
       Library::Handle(object_store()->root_library());
   jsobj.AddProperty("rootLib", lib);
 
   timer_list().PrintTimersToJSONProperty(&jsobj);
   {
     JSONObject tagCounters(&jsobj, "tagCounters");
     vm_tag_counters()->PrintToJSONObject(&tagCounters);
@@ skipping 23 matching lines @@
       lib ^= libs.At(i);
       name = lib.name();
       if (name.Equals(Symbols::DartIOLibName())) {
         is_io_enabled = true;
       }
       ASSERT(!lib.IsNull());
       lib_array.AddValue(lib);
     }
   }
   {
+    JSONArray breakpoints(&jsobj, "breakpoints");
+    debugger()->PrintBreakpointsToJSONArray(&breakpoints);
+  }
+  {
     JSONArray features_array(&jsobj, "features");
     if (is_io_enabled) {
       features_array.AddValue("io");
     }
   }
 }
 
 
 intptr_t Isolate::ProfileInterrupt() {
   // Other threads might be modifying these fields. Save them in locals so that
@@ skipping 325 matching lines @@
                            serialized_message_, serialized_message_len_);
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart