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::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;
 
+
 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 317 matching lines @@
       path_segment ^= Symbols::Empty().raw();
     }
     ASSERT(!path_segment.IsNull());
     const char* path_segment_c = path_segment.ToCString();
 
     IsolateMessageHandler handler =
         FindIsolateMessageHandler(path_segment_c);
     {
       JSONStream js;
       js.Setup(zone.GetZone(), reply_port, path, option_keys, option_values);
-
       if (handler == NULL) {
-        PrintError(&js, "Unrecognized path");
+        // Check for an embedder handler.
+        EmbedderServiceHandler* e_handler =
+            FindIsolateEmbedderHandler(path_segment_c);
+        if (e_handler != NULL) {
+          EmbedderHandleMessage(e_handler, &js);
+        } else {
+          PrintError(&js, "Unrecognized path");
+        }
         js.PostReply();
       } else {
         if (handler(isolate, &js)) {
           // Handler returns true if the reply is ready to be posted.
+          // TODO(johnmccutchan): Support asynchronous replies.
           js.PostReply();
         }
       }
     }
   }
 }
 
 
 static bool HandleIsolate(Isolate* isolate, JSONStream* js) {
   isolate->PrintToJSONStream(js);
@@ skipping 542 matching lines @@
 
     ASSERT(!path.IsNull());
     ASSERT(!option_keys.IsNull());
     ASSERT(!option_values.IsNull());
     // Path always has at least one entry in it.
     ASSERT(path.Length() > 0);
     // Same number of option keys as values.
     ASSERT(option_keys.Length() == option_values.Length());
 
     String& path_segment = String::Handle();
-    path_segment ^= path.At(0);
+    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();
+
     RootMessageHandler handler =
         FindRootMessageHandler(path_segment_c);
-
     {
       JSONStream js;
       js.Setup(zone.GetZone(), reply_port, path, option_keys, option_values);
       if (handler == NULL) {
-        PrintError(&js, "Unrecognized path");
+        // Check for an embedder handler.
+        EmbedderServiceHandler* e_handler =
+            FindRootEmbedderHandler(path_segment_c);
+        if (e_handler != NULL) {
+          EmbedderHandleMessage(e_handler, &js);
+        } else {
+          PrintError(&js, "Unrecognized path");
+        }
         js.PostReply();
       } else {
         if (handler(&js)) {
           // Handler returns true if the reply is ready to be posted.
+          // TODO(johnmccutchan): Support asynchronous replies.
           js.PostReply();
         }
       }
     }
   }
 }
 
 
 static bool HandleRootEcho(JSONStream* js) {
   JSONObject jsobj(js);
@@ skipping 25 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::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();
+  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::RegisterIsolateEmbedderCallback(
+    const char* name,
+    Dart_ServiceRequestCallback callback,
+    void* user_data) {
+  if (name == NULL) {
+    return;
+  }
+  EmbedderServiceHandler* handler = FindIsolateEmbedderHandler(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 isolate_service_handler_head_ list.
+  handler->set_next(isolate_service_handler_head_);
+  isolate_service_handler_head_ = handler;
+}
+
+
+EmbedderServiceHandler* Service::FindIsolateEmbedderHandler(
+    const char* name) {
+  EmbedderServiceHandler* current = isolate_service_handler_head_;
+  while (current != NULL) {
+    if (!strcmp(name, current->name())) {
+      return current;
+    }
+    current = current->next();
+  }
+  return NULL;
+}
+
+
+void Service::RegisterRootEmbedderCallback(
+    const char* name,
+    Dart_ServiceRequestCallback callback,
+    void* user_data) {
+  if (name == NULL) {
+    return;
+  }
+  EmbedderServiceHandler* handler = FindRootEmbedderHandler(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 root_service_handler_head_ list.
+  handler->set_next(root_service_handler_head_);
+  root_service_handler_head_ = handler;
+}
+
+
+EmbedderServiceHandler* Service::FindRootEmbedderHandler(
+    const char* name) {
+  EmbedderServiceHandler* current = root_service_handler_head_;
+  while (current != NULL) {
+    if (!strcmp(name, current->name())) {
+      return current;
+    }
+    current = current->next();
+  }
+  return NULL;
+}
+
 }  // namespace dart