Allow for embedder provided service request handlers

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 "vm/compiler.h"
 #include "vm/coverage.h"
@@ skipping 86 matching lines @@
 
   static ResourcesEntry* ResourceTable() {
     return &__service_resources_[0];
   }
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(Resources);
 };
 
 
+class EmbedderServiceHandler {
+ public:
+  explicit EmbedderServiceHandler(const char* name) : name_(NULL),
+                                                      callback_(NULL),
+                                                      user_data_(NULL),
+                                                      next_(NULL) {
+    ASSERT(name != NULL);
+    name_ = strdup(name);
+  }
+
+  ~EmbedderServiceHandler() {
+    free(name_);
+  }
+
+  const char* name() const { return name_; }
+
+  Dart_ServiceRequestCallback callback() const { return callback_; }
+  void set_callback(Dart_ServiceRequestCallback callback) {
+    callback_ = callback;
+  }
+
+  void* user_data() const { return user_data_; }
+  void set_user_data(void* user_data) {
+    user_data_ = user_data;
+  }
+
+  EmbedderServiceHandler* next() const { return next_; }
+  void set_next(EmbedderServiceHandler* next) {
+    next_ = next;
+  }
+
+ private:
+  char* name_;
+  Dart_ServiceRequestCallback callback_;
+  void* user_data_;
+  EmbedderServiceHandler* next_;
+};
+
+
 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 SendIsolateServiceMessage(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   StackZone zone(isolate);
@@ skipping 62 matching lines @@
     VmServiceNativeEntry entry = _VmServiceNativeEntries[i];
     if (!strcmp(function_name, entry.name) &&
         (num_arguments == entry.num_arguments)) {
       return entry.function;
     }
   }
   return NULL;
 }
 
 
+EmbedderServiceHandler* Service::service_handler_head_ = NULL;
 Isolate* Service::service_isolate_ = NULL;
 Dart_LibraryTagHandler Service::default_handler_ = NULL;
 Dart_Port Service::port_ = ILLEGAL_PORT;
 
+
 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.
   const Object& rp_id_obj = Object::Handle(DartLibraryCalls::PortGetId(rp));
   if (rp_id_obj.IsError()) {
     return ILLEGAL_PORT;
   }
   ASSERT(rp_id_obj.IsSmi() || rp_id_obj.IsMint());
@@ skipping 314 matching lines @@
     if (path.Length() > 0) {
       path_segment ^= path.At(0);
     } else {
       path_segment ^= Symbols::Empty().raw();
     }
     ASSERT(!path_segment.IsNull());
     const char* path_segment_c = path_segment.ToCString();
 
     IsolateMessageHandler handler =
         FindIsolateMessageHandler(path_segment_c);
+    if (handler == NULL) {
+      // Check for an embedder handler.
+      EmbedderServiceHandler* e_handler = FindEmbedderHandler(path_segment_c);
+      if (e_handler != NULL) {
+        JSONStream js;
+        js.Setup(zone.GetZone(), reply_port, path, option_keys, option_values);
+        EmbedderHandleIsolateMessage(e_handler, &js);

[turnidge, 2014/02/18 21:27:05]

Do we want to allow for asynchronous replies?  Should we have a TODO for this?

+        js.PostReply();
+      }
+    }
     {
       JSONStream js;
       js.Setup(zone.GetZone(), reply_port, path, option_keys, option_values);
-
       if (handler == NULL) {
         PrintError(&js, "Unrecognized path");
         js.PostReply();
       } else {
         if (handler(isolate, &js)) {
           // Handler returns true if the reply is ready to be posted.
           js.PostReply();
         }
       }
     }
@@ skipping 608 matching lines @@
     if (!strcmp(command, entry.command)) {
       return entry.handler;
     }
   }
   if (FLAG_trace_service) {
     OS::Print("Service has no root message handler for <%s>\n", command);
   }
   return NULL;
 }
 
+
+void Service::EmbedderHandleIsolateMessage(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();
+  r = callback(name, arguments, js->num_arguments(), keys, values,
+               js->num_options(), handler->user_data());
+  ASSERT(r != NULL);
+  // TODO(johnmccutchan): Allow for NULL returns?
+  TextBuffer* buffer = js->buffer();
+  buffer->AddString(r);
+  free(const_cast<char*>(r));
+}
+
+
+void Service::RegisterEmbedderCallback(const char* name,
+                                       Dart_ServiceRequestCallback callback,
+                                       void* user_data) {

[turnidge, 2014/02/18 21:27:05]

Add a heartbeat unit test for embedder callbacks in service_test.cc

[Cutch, 2014/02/18 22:18:51]

Done.

+  if (name == NULL) {
+    return;
+  }
+  EmbedderServiceHandler* handler = FindEmbedderHandler(name);
+  if (handler != NULL) {
+    // Update existing handler entry.
+    handler->set_callback(callback);
+    handler->set_user_data(user_data);
+    return;
+  }
+  // Create a new handler.
+  handler = new EmbedderServiceHandler(name);
+  handler->set_callback(callback);
+  handler->set_user_data(user_data);
+
+  // Insert into list.
+  handler->set_next(service_handler_head_);
+  service_handler_head_ = handler;
+}
+
+
+EmbedderServiceHandler* Service::FindEmbedderHandler(
+    const char* name) {
+  EmbedderServiceHandler* current = service_handler_head_;
+  while (current != NULL) {
+    if (!strcmp(name, current->name())) {
+      return current;
+    }
+  }
+  return NULL;
+}
+
+
 }  // namespace dart