Remove DebuggerEvent. Refactor remaining code.

runtime/vm/service_event.cc

 // Copyright (c) 2015, 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/service_event.h"
 
+#include "vm/debugger.h"
 #include "vm/message_handler.h"
+#include "vm/service_isolate.h"
 
 namespace dart {
 
 #ifndef PRODUCT
 
-// Translate from the legacy DebugEvent to a ServiceEvent.
-static ServiceEvent::EventKind TranslateEventKind(
-    DebuggerEvent::EventType kind) {
-    switch (kind) {
-      case DebuggerEvent::kIsolateCreated:
-        return ServiceEvent::kIsolateStart;
-
-      case DebuggerEvent::kIsolateShutdown:
-        return ServiceEvent::kIsolateExit;
-
-      case DebuggerEvent::kBreakpointReached:
-        return ServiceEvent::kPauseBreakpoint;
-
-      case DebuggerEvent::kIsolateInterrupted:
-        return ServiceEvent::kPauseInterrupted;
-
-      case DebuggerEvent::kExceptionThrown:
-        return ServiceEvent::kPauseException;
-      default:
-        UNREACHABLE();
-        return ServiceEvent::kIllegal;
-    }
-}
-
-
 ServiceEvent::ServiceEvent(Isolate* isolate, EventKind event_kind)
     : isolate_(isolate),
       kind_(event_kind),
       embedder_kind_(NULL),
       embedder_stream_id_(NULL),
       breakpoint_(NULL),
       top_frame_(NULL),
       timeline_event_block_(NULL),
       extension_rpc_(NULL),
       exception_(NULL),
       at_async_jump_(false),
       inspectee_(NULL),
       gc_stats_(NULL),
       bytes_(NULL),
       bytes_length_(0),
       timestamp_(OS::GetCurrentTimeMillis()) {
+  // We should never generate events for the vm or service isolates.
+  ASSERT(isolate_ != Dart::vm_isolate());
+  ASSERT(isolate == NULL ||
+         !ServiceIsolate::IsServiceIsolateDescendant(isolate_));
+
   if ((event_kind == ServiceEvent::kPauseStart) &&
       !isolate->message_handler()->is_paused_on_start()) {
     // We will pause on start but the message handler lacks a valid
     // paused timestamp because we haven't paused yet. Use the current time.
     timestamp_ = OS::GetCurrentTimeMillis();
   } else if ((event_kind == ServiceEvent::kPauseStart) ||
              (event_kind == ServiceEvent::kPauseExit)) {
     timestamp_ = isolate->message_handler()->paused_timestamp();
   } else if (event_kind == ServiceEvent::kResume) {
     timestamp_ = isolate->last_resume_timestamp();
   }
 }
 
 
-ServiceEvent::ServiceEvent(const DebuggerEvent* debugger_event)
-    : isolate_(debugger_event->isolate()),
-      kind_(TranslateEventKind(debugger_event->type())),
-      breakpoint_(NULL),
-      top_frame_(NULL),
-      timeline_event_block_(NULL),
-      extension_rpc_(NULL),
-      exception_(NULL),
-      at_async_jump_(false),
-      inspectee_(NULL),
-      gc_stats_(NULL),
-      bytes_(NULL),
-      bytes_length_(0),
-      timestamp_(OS::GetCurrentTimeMillis()) {
-  DebuggerEvent::EventType type = debugger_event->type();
-  if (type == DebuggerEvent::kBreakpointReached) {
-    set_breakpoint(debugger_event->breakpoint());
-    set_at_async_jump(debugger_event->at_async_jump());
-  }
-  if (type == DebuggerEvent::kExceptionThrown) {
-    set_exception(debugger_event->exception());
-  }
-  if (type == DebuggerEvent::kBreakpointReached ||
-      type == DebuggerEvent::kIsolateInterrupted ||
-      type == DebuggerEvent::kExceptionThrown) {
-    set_top_frame(debugger_event->top_frame());
-  }
-  if (debugger_event->timestamp() != -1) {
-    timestamp_ = debugger_event->timestamp();
-  }
+void ServiceEvent::UpdateTimestamp() {
+  timestamp_ = OS::GetCurrentTimeMillis();
 }
 
 
 const char* ServiceEvent::KindAsCString() const {
   switch (kind()) {
     case kVMUpdate:
       return "VMUpdate";
     case kIsolateStart:
       return "IsolateStart";
     case kIsolateRunnable:
@@ skipping 40 matching lines @@
       return "Extension";
     case kTimelineEvents:
       return "TimelineEvents";
     default:
       UNREACHABLE();
       return "Unknown";
   }
 }
 
 
-const char* ServiceEvent::stream_id() const {
+const StreamInfo* ServiceEvent::stream_info() const {
   switch (kind()) {
     case kVMUpdate:
-      return Service::vm_stream.id();
+      return &Service::vm_stream;
 
     case kIsolateStart:
     case kIsolateRunnable:
     case kIsolateExit:
     case kIsolateUpdate:
     case kServiceExtensionAdded:
-      return Service::isolate_stream.id();
+      return &Service::isolate_stream;
 
     case kPauseStart:
     case kPauseExit:
     case kPauseBreakpoint:
     case kPauseInterrupted:
     case kPauseException:
     case kNone:
     case kResume:
     case kBreakpointAdded:
     case kBreakpointResolved:
     case kBreakpointRemoved:
     case kInspect:
     case kDebuggerSettingsUpdate:
-      return Service::debug_stream.id();
+      return &Service::debug_stream;
 
     case kGC:
-      return Service::gc_stream.id();
+      return &Service::gc_stream;
+
+    case kLogging:
+      return &Service::logging_stream;
+
+    case kExtension:
+      return &Service::extension_stream;
+
+    case kTimelineEvents:
+      return &Service::timeline_stream;
 
     case kEmbedder:
-      return embedder_stream_id_;
-
-    case kLogging:
-      return Service::logging_stream.id();
-
-    case kExtension:
-      return Service::extension_stream.id();
-
-    case kTimelineEvents:
-      return Service::timeline_stream.id();
+      return NULL;
 
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
+const char* ServiceEvent::stream_id() const {
+  const StreamInfo* stream = stream_info();
+  if (stream == NULL) {
+    ASSERT(kind() == kEmbedder);
+    return embedder_stream_id_;
+  } else {
+    return stream->id();
+  }
+}
+
+
 void ServiceEvent::PrintJSON(JSONStream* js) const {
   JSONObject jsobj(js);
   PrintJSONHeader(&jsobj);
   if (kind() == kServiceExtensionAdded) {
     ASSERT(extension_rpc_ != NULL);
     jsobj.AddProperty("extensionRPC", extension_rpc_->ToCString());
   }
   if (kind() == kPauseBreakpoint) {
     JSONArray jsarr(&jsobj, "pauseBreakpoints");
     // TODO(rmacnak): If we are paused at more than one breakpoint,
@@ skipping 68 matching lines @@
   } else {
     jsobj->AddProperty("isolate", isolate());
   }
   ASSERT(timestamp_ != -1);
   jsobj->AddPropertyTimeMillis("timestamp", timestamp_);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart