Add support for asynchronous event notification to the observatory.

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 171 matching lines @@
 static void SendRootServiceMessage(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   StackZone zone(isolate);
   HANDLESCOPE(isolate);
   GET_NON_NULL_NATIVE_ARGUMENT(Instance, message, arguments->NativeArgAt(0));
   Service::HandleRootMessage(message);
 }
 
 
+void Service::SetEventMask(uint32_t mask) {
+  event_mask_ = mask;
+}
+
+
+void SetEventMask(Dart_NativeArguments args) {
+  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
+  Isolate* isolate = arguments->isolate();
+  StackZone zone(isolate);
+  HANDLESCOPE(isolate);
+  GET_NON_NULL_NATIVE_ARGUMENT(Integer, mask, arguments->NativeArgAt(0));
+  Service::SetEventMask(mask.AsTruncatedUint32Value());
+}
+
+
 struct VmServiceNativeEntry {
   const char* name;
   int num_arguments;
   Dart_NativeFunction function;
 };
 
 
 static VmServiceNativeEntry _VmServiceNativeEntries[] = {
   {"VMService_SendIsolateServiceMessage", 2, SendIsolateServiceMessage},
-  {"VMService_SendRootServiceMessage", 1, SendRootServiceMessage}
+  {"VMService_SendRootServiceMessage", 1, SendRootServiceMessage},
+  {"VMService_SetEventMask", 1, SetEventMask},
 };
 
 
 static Dart_NativeFunction VmServiceNativeResolver(Dart_Handle name,
                                                    int num_arguments,
                                                    bool* auto_setup_scope) {
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   if (!obj.IsString()) {
     return NULL;
   }
@@ skipping 12 matching lines @@
   }
   return NULL;
 }
 
 
 EmbedderServiceHandler* Service::isolate_service_handler_head_ = NULL;
 EmbedderServiceHandler* Service::root_service_handler_head_ = NULL;
 Isolate* Service::service_isolate_ = NULL;
 Dart_LibraryTagHandler Service::default_handler_ = NULL;
 Dart_Port Service::port_ = ILLEGAL_PORT;
+uint32_t Service::event_mask_ = 0;
 
 
 static Dart_Port ExtractPort(Dart_Handle receivePort) {
   HANDLESCOPE(Isolate::Current());
   const Object& unwrapped_rp = Object::Handle(Api::UnwrapHandle(receivePort));
   const Instance& rp = Instance::Cast(unwrapped_rp);
   // Extract RawReceivePort port id.
   if (!rp.IsReceivePort()) {
     return ILLEGAL_PORT;
   }
@@ skipping 208 matching lines @@
   if (FLAG_trace_service) {
     OS::Print("Isolate %s %" Pd64 " deregistered with service \n",
               name.ToCString(),
               Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
-bool Service::IsRunning() {
-  return port_ != ILLEGAL_PORT;
-}
-
-
 Dart_Handle Service::GetSource(const char* name) {
   ASSERT(name != NULL);
   int i = 0;
   while (true) {
     const char* path = Resources::Path(i);
     if (path == NULL) {
       break;
     }
     ASSERT(*path != '\0');
     // Skip the '/'.
@@ skipping 1629 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) {
+  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::HandleDebuggerEvent(DebuggerEvent* event) {
+  JSONStream js;
+  event->PrintJSON(&js);
+  const String& message = String::Handle(String::New(js.ToCString()));
+  SendEvent(kEventFamilyDebug, message);
+}
+
+
 void Service::EmbedderHandleMessage(EmbedderServiceHandler* handler,
                                     JSONStream* js) {
   ASSERT(handler != NULL);
   Dart_ServiceRequestCallback callback = handler->callback();
   ASSERT(callback != NULL);
   const char* r = NULL;
   const char* name = js->command();
   const char** arguments = js->arguments();
   const char** keys = js->option_keys();
   const char** values = js->option_values();
@@ skipping 76 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart