Optional binary payloads in VM service events.

runtime/vm/service.cc

 // Copyright (c) 2013, 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.h"
 
 #include "include/dart_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
 #include "vm/coverage.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
 #include "vm/object_graph.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/reusable_handles.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
+#include "vm/unicode.h"
 #include "vm/version.h"
 
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_service, false, "Trace VM service requests.");
 DEFINE_FLAG(bool, trace_service_pause_events, false,
             "Trace VM service isolate pause events.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, enable_asserts);
@@ skipping 742 matching lines @@
     JSONObject jsobj(&jsarr);
     frame->PrintToJSONObject(&jsobj);
     // TODO(turnidge): Implement depth differently -- differentiate
     // inlined frames.
     jsobj.AddProperty("depth", i);
   }
   return true;
 }
 
 
-static bool HandleIsolateEcho(Isolate* isolate, JSONStream* js) {
+static bool HandleCommonEcho(JSONObject* jsobj, JSONStream* js) {
+  jsobj->AddProperty("type", "message");
+  PrintArgumentsAndOptions(*jsobj, js);
+  return true;
+}
+
+
+void Service::SendEchoEvent(Isolate* isolate) {
+  JSONStream js;
+  {
+    JSONObject jsobj(&js);
+    jsobj.AddProperty("type", "ServiceEvent");
+    jsobj.AddPropertyF("id", "_echo/event");
+    jsobj.AddProperty("eventType", "_Echo");
+    jsobj.AddProperty("isolate", isolate);
+  }
+  const String& message = String::Handle(String::New(js.ToCString()));
+  uint8_t data[] = {0, 128, 255};
+  // TODO(koda): Add 'testing' event family.
+  SendEvent(kEventFamilyDebug, message, data, sizeof(data));
+}
+
+
+bool HandleIsolateEcho(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
-  jsobj.AddProperty("type", "message");
-  PrintArgumentsAndOptions(jsobj, js);
-  return true;
+  jsobj.AddProperty("id", "_echo/isolate");
+  if (js->num_arguments() == 2 && strcmp(js->GetArgument(1), "event") == 0) {
+    Service::SendEchoEvent(isolate);
+  }
+  return HandleCommonEcho(&jsobj, js);
 }
 
 
 // Print an error message if there is no ID argument.
 #define REQUIRE_COLLECTION_ID(collection)                                      \
   if (js->num_arguments() == 1) {                                              \
     PrintError(js, "Must specify collection object id: /%s/id", collection);   \
     return true;                                                               \
   }
 
@@ skipping 1463 matching lines @@
           js.PostReply();
         }
       }
     }
   }
 }
 
 
 static bool HandleRootEcho(JSONStream* js) {
   JSONObject jsobj(js);
-  jsobj.AddProperty("type", "message");
-  PrintArgumentsAndOptions(jsobj, js);
-  return true;
+  jsobj.AddProperty("id", "_echo/root");
+  return HandleCommonEcho(&jsobj, js);
 }
 
 
 class ServiceIsolateVisitor : public IsolateVisitor {
  public:
   explicit ServiceIsolateVisitor(JSONArray* jsarr)
       : jsarr_(jsarr) {
   }
 
   virtual ~ServiceIsolateVisitor() {}
@@ skipping 92 matching lines @@
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
     OS::Print("Service has no root message handler for <%s>\n", command);
   }
   return NULL;
 }
 
 
-void Service::SendEvent(intptr_t eventId, const String& eventMessage) {
+void Service::SendEvent(intptr_t eventId, const Object& eventMessage) {
   if (!IsRunning()) {
     return;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
 
   // Construct a list of the form [eventId, eventMessage].
   const Array& list = Array::Handle(Array::New(2));
   ASSERT(!list.IsNull());
   list.SetAt(0, Integer::Handle(Integer::New(eventId)));
   list.SetAt(1, eventMessage);
 
   // Push the event to port_.
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
     OS::Print("Pushing event of type %" Pd ", len %" Pd "\n", eventId, len);
   }
   // TODO(turnidge): For now we ignore failure to send an event.  Revisit?
   PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
+void Service::SendEvent(intptr_t eventId,
+                        const String& meta,
+                        const uint8_t* data,
+                        intptr_t size) {
+  // Bitstream: [meta data size (big-endian 64 bit)] [meta data (UTF-8)] [data]
+  const intptr_t meta_bytes = Utf8::Length(meta);
+  const intptr_t total_bytes = sizeof(uint64_t) + meta_bytes + size;

[Cutch, 2014/08/15 21:33:58]

Do we really need 64-bits to encode the meta-data size? I guess it's future
proof but seems big.

[koda, 2014/08/15 22:20:53]

Do we really need more than 32 bits for IP addresses? ;)

+  const TypedData& message = TypedData::Handle(
+      TypedData::New(kTypedDataUint8ArrayCid, total_bytes));
+  intptr_t offset = 0;
+  // TODO(koda): Rename these methods SetHostUint64, etc.
+  message.SetUint64(0, Utils::HostToBigEndian64(meta_bytes));
+  offset += sizeof(uint64_t);
+  {
+    NoGCScope no_gc;
+    meta.ToUTF8(static_cast<uint8_t*>(message.DataAddr(offset)), meta_bytes);
+    offset += meta_bytes;
+  }
+  memmove(message.DataAddr(offset), data, size);
+  offset += size;
+  ASSERT(offset == total_bytes);
+  SendEvent(eventId, message);
+}
+
+
 void Service::HandleGCEvent(GCEvent* event) {
   JSONStream js;
   event->PrintJSON(&js);
   const String& message = String::Handle(String::New(js.ToCString()));
   SendEvent(kEventFamilyGC, message);
 }
 
 
 void Service::HandleDebuggerEvent(DebuggerEvent* event) {
   JSONStream js;
@@ skipping 92 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart