Display isolate message queue in Observatory debugger

runtime/vm/message.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.h"
 
+#include "vm/dart_entry.h"
+#include "vm/json_stream.h"
+#include "vm/object.h"
 #include "vm/port.h"
 
 namespace dart {
 
 bool Message::RedirectToDeliveryFailurePort() {
   if (delivery_failure_port_ == kIllegalPort) {
     return false;
   }
   dest_port_ = delivery_failure_port_;
   delivery_failure_port_ = kIllegalPort;
   return true;
 }
 
 
+intptr_t Message::Id() const {
+  // Messages are allocated on the C heap. Use the raw address as the id.
+  return reinterpret_cast<intptr_t>(this);
+}
+
+const char* Message::PriorityAsString(Priority priority) {
+  switch (priority) {
+    case kNormalPriority:
+      return "Normal";
+    break;
+    case kOOBPriority:
+      return "OOB";
+    break;
+    default:
+      UNIMPLEMENTED();
+      return NULL;
+  }
+}
+
+
 MessageQueue::MessageQueue() {
   head_ = NULL;
   tail_ = NULL;
 }
 
 
 MessageQueue::~MessageQueue() {
   // Ensure that all pending messages have been released.
   Clear();
   ASSERT(head_ == NULL);
@@ skipping 68 matching lines @@
     if (cur->RedirectToDeliveryFailurePort()) {
       PortMap::PostMessage(cur);
     } else {
       delete cur;
     }
     cur = next;
   }
 }
 
 
+MessageQueue::Iterator::Iterator(const MessageQueue* queue)
+    : current_(NULL),
+      queue_(queue) {
+  Reset(queue);
+}
+
+
+MessageQueue::Iterator::~Iterator() {
+}
+
+void MessageQueue::Iterator::Reset(const MessageQueue* queue) {
+  queue_ = queue;
+  current_ = NULL;

[turnidge, 2015/05/04 20:11:51]

next_ = queue_->head_;

+}
+
+// returns false when there are no more messages left.
+bool MessageQueue::Iterator::HasNext() {

[turnidge, 2015/05/04 20:11:51]

return next_ != NULL

+  if (current() == NULL) {
+    if (queue_ == NULL) {
+      return false;
+    }
+    // Does the queue contain anything?
+    return (queue_->head_ != NULL);
+  }
+  ASSERT(current_ != NULL);
+  return (current_->next_ != NULL);
+}
+
+// Moves forward and then returns current().
+Message* MessageQueue::Iterator::Next() {

[turnidge, 2015/05/04 20:11:51]

ASSERT(next_ != NULL);
Message* current = next_;
next_ = next_->next_;
return current;

+  if (queue_ != NULL) {
+    // First call to Next().
+    current_ = queue_->head_;
+    queue_ = NULL;
+  } else {
+    current_ = current_->next_;
+  }
+  return current();
+}
+
+
+intptr_t MessageQueue::Length() const {
+  MessageQueue::Iterator it(this);
+  intptr_t length = 0;
+  while (it.HasNext()) {
+    it.Next();
+    length++;
+  }
+  return length;
+}
+
+
+Message* MessageQueue::FindMessageById(intptr_t id) {
+  MessageQueue::Iterator it(this);
+  while (it.HasNext()) {
+    Message* current = it.Next();
+     ASSERT(current != NULL);
+    if (current->Id() == id) {
+      return current;
+    }
+  }
+  return NULL;
+}
+
+
+void MessageQueue::PrintJSON(JSONStream* stream) {
+  Isolate* isolate = Isolate::Current();
+  JSONArray messages(stream);
+
+  Object& msg_handler = Object::Handle(isolate);
+
+  MessageQueue::Iterator it(this);
+  intptr_t depth = 0;
+  while (it.HasNext()) {
+    Message* current = it.Next();
+    JSONObject message(&messages);
+    message.AddProperty("type", "Message");
+    message.AddPropertyF("name", "Isolate Message (%" Px ")", current->Id());
+    message.AddPropertyF("messageObjectId", "messages/%" Px "",
+                         current->Id());
+    message.AddProperty("size", current->len());
+    message.AddProperty("depth", depth++);
+    message.AddProperty("_destinationPort",
+        static_cast<intptr_t>(current->dest_port()));
+    message.AddProperty("priority",
+        Message::PriorityAsString(current->priority()));
+    // TODO(johnmccutchan): Move port -> handler map out of Dart and into the
+    // VM, that way we can lookup the handler without invoking Dart code.
+    msg_handler = DartLibraryCalls::LookupHandler(current->dest_port());
+    if (msg_handler.IsInstance() && Instance::Cast(msg_handler).IsClosure()) {
+      // Grab function from closure.
+      msg_handler = Closure::function(Instance::Cast(msg_handler));
+    }
+    if (!msg_handler.IsFunction()) {
+      // No handler function.
+      continue;
+    }
+    const Function& function = Function::Cast(msg_handler);
+    const Script& script = Script::Handle(function.script());
+    message.AddProperty("handlerFunction", function);
+    message.AddProperty("handlerScript", script);
+    message.AddProperty("handlerTokenPos", function.token_pos());
+  }
+}
+
 }  // namespace dart