Remember when an isolate was paused and subtly display it in Obseravatory

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/message_handler.h"
+
 namespace dart {
 
 // 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),
+      exception_(NULL),
+      async_continuation_(NULL),
+      at_async_jump_(false),
+      inspectee_(NULL),
+      gc_stats_(NULL),
+      bytes_(NULL),
+      bytes_length_(0),
+      timestamp_(-1) {
+  if ((event_kind == ServiceEvent::kPauseStart) ||
+      (event_kind == ServiceEvent::kPauseExit)) {
+    timestamp_ = isolate->message_handler()->paused_timestamp();
+  } else {
+    timestamp_ = OS::GetCurrentTimeMillis();
+  }
+}
+
+
 ServiceEvent::ServiceEvent(const DebuggerEvent* debugger_event)
     : isolate_(debugger_event->isolate()),
       kind_(TranslateEventKind(debugger_event->type())),
       breakpoint_(NULL),
       top_frame_(NULL),
       exception_(NULL),
       async_continuation_(NULL),
       inspectee_(NULL),
       gc_stats_(NULL),
       bytes_(NULL),
-      bytes_length_(0) {
+      bytes_length_(0),
+      timestamp_(-1) {
   DebuggerEvent::EventType type = debugger_event->type();
   if (type == DebuggerEvent::kBreakpointReached) {
     set_breakpoint(debugger_event->breakpoint());
     set_async_continuation(debugger_event->async_continuation());
     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());
   }
+  timestamp_ = debugger_event->timestamp();

[turnidge, 2015/08/25 18:25:31]

Let's just use OS::GetCurrentTimeMillis() here too.

[turnidge, 2015/08/25 18:29:03]

Nevermind

 }
 
 
 const char* ServiceEvent::KindAsCString() const {
   switch (kind()) {
     case kIsolateStart:
       return "IsolateStart";
     case kIsolateRunnable:
       return "IsolateRunnable";
     case kIsolateExit:
@@ skipping 129 matching lines @@
     logRecord.AddProperty("stackTrace", *(log_record_.stack_trace));
   }
 }
 
 
 void ServiceEvent::PrintJSONHeader(JSONObject* jsobj) const {
   ASSERT(jsobj != NULL);
   jsobj->AddProperty("type", "Event");
   jsobj->AddProperty("kind", KindAsCString());
   jsobj->AddProperty("isolate", isolate());
+  ASSERT(timestamp_ != -1);
+  jsobj->AddPropertyTimeMillis("timestamp", timestamp_);
 }
 
 }  // namespace dart