VM Service isolate listing

runtime/vm/message.h

 // 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.
 
 #ifndef VM_MESSAGE_H_
 #define VM_MESSAGE_H_
 
 #include "vm/thread.h"
 
 // Duplicated from dart_api.h to avoid including the whole header.
 typedef int64_t Dart_Port;
 
 namespace dart {
 
 class Message {
  public:
   typedef enum {
     kNormalPriority = 0,  // Deliver message when idle.
     kOOBPriority = 1,     // Deliver message asap.
 
     // Iteration.
     kFirstPriority = 0,
     kNumPriorities = 2,
   } Priority;
 
+  typedef enum {
+    kNormalType = 0,     // Normal message.
+    kServiceType = 1,    // Service isolate message.

[siva, 2013/07/19 17:41:16]

I am not sure about this message type encoding here.

Another possible model is we have OOB messages and then
we have the Service handler taking a shot at handling the message
and if it does not recognize it then we move on to Mirror message
handler and then onto any other such handlers that we have.

Let us discuss this.

+
+    // Iteration.
+    kFirstType = 0,
+    kNumTypes = 2,
+  } Type;
+
   // A port number which is never used.
   static const Dart_Port kIllegalPort = 0;
 
   // A new message to be sent between two isolates. The data handed to this
   // message will be disposed by calling free() once the message object is
   // being destructed (after delivery or when the receiving port is closed).
   //
   // If reply_port is kIllegalPort, then there is no reply port.
-  Message(Dart_Port dest_port, Dart_Port reply_port,
-          uint8_t* data, intptr_t len, Priority priority)
+  Message(Dart_Port dest_port, Dart_Port reply_port, uint8_t* data,
+          intptr_t len, Priority priority, Type type = kNormalType)
       : next_(NULL),
         dest_port_(dest_port),
         reply_port_(reply_port),
         data_(data),
         len_(len),
-        priority_(priority) {}
+        priority_(priority),
+        type_(type) {}
   ~Message() {
     free(data_);
   }
 
   Dart_Port dest_port() const { return dest_port_; }
   Dart_Port reply_port() const { return reply_port_; }
   uint8_t* data() const { return data_; }
   intptr_t len() const { return len_; }
   Priority priority() const { return priority_; }
+  Type type() const { return type_; }
 
   bool IsOOB() const { return priority_ == Message::kOOBPriority; }
+  bool IsService() const { return type_ == Message::kServiceType; }
 
  private:
   friend class MessageQueue;
 
   Message* next_;
   Dart_Port dest_port_;
   Dart_Port reply_port_;
   uint8_t* data_;
   intptr_t len_;
   Priority priority_;
+  Type type_;
 
   DISALLOW_COPY_AND_ASSIGN(Message);
 };
 
 // There is a message queue per isolate.
 class MessageQueue {
  public:
   MessageQueue();
   ~MessageQueue();
 
@@ skipping 11 matching lines @@
 
   Message* head_;
   Message* tail_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageQueue);
 };
 
 }  // namespace dart
 
 #endif  // VM_MESSAGE_H_