Some cleanups in the code that posts results to service clients.

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"
@@ skipping 26 matching lines @@
 namespace dart {
 
 DECLARE_FLAG(bool, trace_service);
 DECLARE_FLAG(bool, trace_service_pause_events);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, enable_asserts);
 
 // TODO(johnmccutchan): Unify embedder service handler lists and their APIs.
 EmbedderServiceHandler* Service::isolate_service_handler_head_ = NULL;
 EmbedderServiceHandler* Service::root_service_handler_head_ = NULL;
-uint32_t Service::event_mask_ = 0;
 struct ServiceMethodDescriptor;
 ServiceMethodDescriptor* FindMethod(const char* method_name);
 
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 static void PrintRequest(const JSONObject& obj, JSONStream* js) {
   JSONObject jsobj(&obj, "request");
@@ skipping 436 matching lines @@
   InvokeMethod(isolate, msg_instance);
 }
 
 
 void Service::HandleIsolateMessage(Isolate* isolate, const Array& msg) {
   ASSERT(isolate != NULL);
   InvokeMethod(isolate, msg);
 }
 
 
-bool Service::EventMaskHas(uint32_t mask) {
-  return (event_mask_ & mask) != 0;
-}
-
-
 bool Service::NeedsEvents() {
   return ServiceIsolate::IsRunning();
 }
 
 
-bool Service::NeedsDebuggerEvents() {
-  return NeedsEvents() && EventMaskHas(kEventFamilyDebugMask);
-}
-
-
-bool Service::NeedsGCEvents() {
-  return NeedsEvents() && EventMaskHas(kEventFamilyGCMask);
-}
-
-
-void Service::SetEventMask(uint32_t mask) {
-  event_mask_ = mask;
-}
-
-
-void Service::SendEvent(intptr_t eventFamilyId,
-                        intptr_t eventType,
+void Service::SendEvent(intptr_t eventType,
                         const Object& eventMessage) {
   ASSERT(!ServiceIsolate::IsServiceIsolateDescendant(Isolate::Current()));
   if (!ServiceIsolate::IsRunning()) {
     return;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
 
-  // Construct a list of the form [eventFamilyId, eventMessage].
-  //
-  // TODO(turnidge): Revisit passing the eventFamilyId here at all.
-  const Array& list = Array::Handle(Array::New(2));
-  ASSERT(!list.IsNull());
-  list.SetAt(0, Integer::Handle(Integer::New(eventFamilyId)));
-  list.SetAt(1, eventMessage);
-
   // Push the event to port_.
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
-  writer.WriteMessage(list);
+  writer.WriteMessage(eventMessage);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
     OS::Print("vm-service: Pushing event of type %" Pd ", len %" Pd "\n",
               eventType, len);
   }
   // TODO(turnidge): For now we ignore failure to send an event.  Revisit?
   PortMap::PostMessage(
       new Message(ServiceIsolate::Port(), data, len, Message::kNormalPriority));
 }
 
 
-void Service::SendEvent(intptr_t eventFamilyId,
-                        const String& meta,
+void Service::SendEvent(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;
   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);
   {
     NoSafepointScope no_safepoint;
     meta.ToUTF8(static_cast<uint8_t*>(message.DataAddr(offset)), meta_bytes);
     offset += meta_bytes;
   }
   // TODO(koda): It would be nice to avoid this copy (requires changes to
   // MessageWriter code).
   {
     NoSafepointScope no_safepoint;
     memmove(message.DataAddr(offset), data, size);
     offset += size;
   }
   ASSERT(offset == total_bytes);
   // TODO(turnidge): Pass the real eventType here.
-  SendEvent(eventFamilyId, 0, message);
+  SendEvent(0, message);
 }
 
 
 void Service::HandleGCEvent(GCEvent* event) {
   if (ServiceIsolate::IsServiceIsolateDescendant(Isolate::Current())) {
     return;
   }
   JSONStream js;
   event->PrintJSON(&js);
   const String& message = String::Handle(String::New(js.ToCString()));
   // TODO(turnidge): Pass the real eventType here.
-  SendEvent(kEventFamilyGC, 0, message);
+  SendEvent(0, message);
 }
 
 
 void Service::HandleEvent(ServiceEvent* event) {
   JSONStream js;
   event->PrintJSON(&js);
   const String& message = String::Handle(String::New(js.ToCString()));
-  SendEvent(kEventFamilyDebug, event->type(), message);
+  SendEvent(event->type(), message);
 }
 
 
 class EmbedderServiceHandler {
  public:
   explicit EmbedderServiceHandler(const char* name) : name_(NULL),
                                                       callback_(NULL),
                                                       user_data_(NULL),
                                                       next_(NULL) {
     ASSERT(name != NULL);
@@ skipping 174 matching lines @@
     JSONObject jsobj(&js);
     jsobj.AddProperty("type", "ServiceEvent");
     jsobj.AddProperty("eventType", "_Echo");
     jsobj.AddProperty("isolate", isolate);
     if (text != NULL) {
       jsobj.AddProperty("text", text);
     }
   }
   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));
+  SendEvent(message, data, sizeof(data));
 }
 
 
 static bool _TriggerEchoEvent(Isolate* isolate, JSONStream* js) {
   Service::SendEchoEvent(isolate, js->LookupParam("text"));
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
 
 
@@ skipping 1412 matching lines @@
 
 void Service::SendGraphEvent(Isolate* isolate) {
   uint8_t* buffer = NULL;
   WriteStream stream(&buffer, &allocator, 1 * MB);
   ObjectGraph graph(isolate);
   graph.Serialize(&stream);
   JSONStream js;
   {
     JSONObject jsobj(&js);
     jsobj.AddProperty("type", "ServiceEvent");
-    jsobj.AddPropertyF("id", "_graphEvent");
     jsobj.AddProperty("eventType", "_Graph");
     jsobj.AddProperty("isolate", isolate);
   }
   const String& message = String::Handle(String::New(js.ToCString()));
-  SendEvent(kEventFamilyDebug, message, buffer, stream.bytes_written());
+  SendEvent(message, buffer, stream.bytes_written());
 }
 
 
 class ContainsAddressVisitor : public FindObjectVisitor {
  public:
   ContainsAddressVisitor(Isolate* isolate, uword addr)
       : FindObjectVisitor(isolate), addr_(addr) { }
   virtual ~ContainsAddressVisitor() { }
 
   virtual uword filter_addr() const { return addr_; }
@@ skipping 354 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart