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

runtime/vm/message_handler.cc

 // Copyright (c) 2011, 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/message_handler.h"
 
 #include "vm/dart.h"
 #include "vm/lockers.h"
+#include "vm/os.h"
 #include "vm/port.h"
 #include "vm/thread_interrupter.h"
 
+
 namespace dart {
 
 DECLARE_FLAG(bool, trace_isolates);
 DECLARE_FLAG(bool, trace_service_pause_events);
 
 class MessageHandlerTask : public ThreadPool::Task {
  public:
   explicit MessageHandlerTask(MessageHandler* handler)
       : handler_(handler) {
     ASSERT(handler != NULL);
@@ skipping 13 matching lines @@
 MessageHandler::MessageHandler()
     : queue_(new MessageQueue()),
       oob_queue_(new MessageQueue()),
       oob_message_handling_allowed_(true),
       live_ports_(0),
       paused_(0),
       pause_on_start_(false),
       pause_on_exit_(false),
       paused_on_start_(false),
       paused_on_exit_(false),
+      paused_timestamp_(-1),
       pool_(NULL),
       task_(NULL),
       start_callback_(NULL),
       end_callback_(NULL),
       callback_data_(0) {
   ASSERT(queue_ != NULL);
   ASSERT(oob_queue_ != NULL);
 }
 
 
@@ skipping 188 matching lines @@
     // main() function.
     if (pause_on_start()) {
       if (!paused_on_start_) {
         // Temporarily drop the lock when calling out to NotifyPauseOnStart.
         // This avoids a dead lock that can occur when this message handler
         // tries to post a message while a message is being posted to it.
         monitor_.Exit();
         NotifyPauseOnStart();
         monitor_.Enter();
         paused_on_start_ = true;
+        paused_timestamp_ = OS::GetCurrentTimeMillis();
       }
       HandleMessages(false, false);
       if (pause_on_start()) {
         // Still paused.
         task_ = NULL;  // No task in queue.
         return;
       } else {
         paused_on_start_ = false;
+        paused_timestamp_ = -1;
       }
     }
 
     if (start_callback_) {
       // Release the monitor_ temporarily while we call the start callback.
       // The monitor was acquired with the MonitorLocker above.
       monitor_.Exit();
       ok = start_callback_(callback_data_);
       ASSERT(Isolate::Current() == NULL);
       start_callback_ = NULL;
       monitor_.Enter();
     }
 
     // Handle any pending messages for this message handler.
     if (ok) {
       ok = HandleMessages(true, true);
     }
     task_ = NULL;  // No task in queue.
 
     if (!ok || !HasLivePorts()) {
       if (pause_on_exit()) {
         if (!paused_on_exit_) {
           if (FLAG_trace_service_pause_events) {
             OS::PrintErr("Isolate %s paused before exiting. "
                        "Use the Observatory to release it.\n", name());
           }
           notify_paused_on_exit = true;
           paused_on_exit_ = true;
+          paused_timestamp_ = OS::GetCurrentTimeMillis();
         }
       } else {
         if (FLAG_trace_isolates) {
         OS::Print("[-] Stopping message handler (%s):\n"
                   "\thandler:    %s\n",
                   (ok ? "no live ports" : "error"),
                   name());
         }
         pool_ = NULL;
         run_end_callback = true;
         paused_on_exit_ = false;
+        paused_timestamp_ = -1;
       }
     }
   }
   // At this point we no longer hold the message handler lock.
   if (notify_paused_on_exit) {
     NotifyPauseOnExit();
   }
   if (run_end_callback && end_callback_ != NULL) {
     end_callback_(callback_data_);
     // The handler may have been deleted after this point.
@@ skipping 71 matching lines @@
 
 
 void MessageHandler::AcquireQueues(AcquiredQueues* acquired_queues) {
   ASSERT(acquired_queues != NULL);
   // No double dipping.
   ASSERT(acquired_queues->handler_ == NULL);
   acquired_queues->Reset(this);
 }
 
 }  // namespace dart