Rework service extensions to be safe

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 "include/dart_native_api.h"
 #include "platform/globals.h"
 
@@ skipping 487 matching lines @@
     }
     if (has_parameter && !parameter->Validate(value)) {
       PrintInvalidParamError(js, name);
       return false;
     }
   }
   return true;
 }
 
 
+void Service::PostError(const String& method_name,
+                        const Array& parameter_keys,
+                        const Array& parameter_values,
+                        const Instance& reply_port,
+                        const Instance& id,
+                        const Error& error) {
+  Isolate* isolate = Isolate::Current();
+  StackZone zone(isolate);
+  HANDLESCOPE(isolate);
+  JSONStream js;
+  js.Setup(zone.GetZone(), SendPort::Cast(reply_port).Id(),
+           id, method_name, parameter_keys, parameter_values);
+  js.PrintError(kExtensionError,
+                "Error in extension `%s`: %s",
+                js.method(), error.ToErrorCString());
+  js.PostReply();
+}
+
+
 void Service::InvokeMethod(Isolate* isolate, const Array& msg) {
   ASSERT(isolate != NULL);
   ASSERT(!msg.IsNull());
   ASSERT(msg.Length() == 6);
 
   {
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
 
     Instance& reply_port = Instance::Handle(isolate);
@@ skipping 66 matching lines @@
     if (handler == NULL) {
       handler = FindRootEmbedderHandler(c_method_name);
     }
 
     if (handler != NULL) {
       EmbedderHandleMessage(handler, &js);
       js.PostReply();
       return;
     }
 
-    if (ScheduleExtensionHandler(method_name,
-                                 param_keys,
-                                 param_values,
-                                 reply_port,
-                                 seq)) {
+    const Instance& extension_handler =
+        Instance::Handle(isolate->LookupExtensionHandler(method_name));
+    if (!extension_handler.IsNull()) {
+      ScheduleExtensionHandler(extension_handler,
+                               method_name,
+                               param_keys,
+                               param_values,
+                               reply_port,
+                               seq);
       // Schedule was successful. Extension code will post a reply
       // asynchronously.
       return;
     }
 
     PrintUnrecognizedMethodError(&js);
     js.PostReply();
     return;
   }
 }
@@ skipping 269 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 
-bool Service::ScheduleExtensionHandler(const String& method_name,
+void Service::ScheduleExtensionHandler(const Instance& handler,
+                                       const String& method_name,
                                        const Array& parameter_keys,
                                        const Array& parameter_values,
                                        const Instance& reply_port,
                                        const Instance& id) {
+  ASSERT(!handler.IsNull());
   ASSERT(!method_name.IsNull());
   ASSERT(!parameter_keys.IsNull());
   ASSERT(!parameter_values.IsNull());
   ASSERT(!reply_port.IsNull());
-  const Library& developer_lib = Library::Handle(Library::DeveloperLibrary());
-  ASSERT(!developer_lib.IsNull());
-  const Function& schedule_extension = Function::Handle(
-      developer_lib.LookupLocalFunction(Symbols::_scheduleExtension()));
-  ASSERT(!schedule_extension.IsNull());
-  const Array& arguments = Array::Handle(Array::New(5));
-  arguments.SetAt(0, method_name);
-  arguments.SetAt(1, parameter_keys);
-  arguments.SetAt(2, parameter_values);
-  arguments.SetAt(3, reply_port);
-  arguments.SetAt(4, id);
-  return (DartEntry::InvokeFunction(schedule_extension, arguments) ==
-          Object::bool_true().raw());
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  isolate->AppendExtensionCall(handler,
+                               method_name,
+                               parameter_keys,
+                               parameter_values,
+                               reply_port,
+                               id);
 }
 
 
 static const MethodParameter* get_isolate_params[] = {
   ISOLATE_PARAMETER,
   NULL,
 };
 
 
 static bool GetIsolate(Isolate* isolate, JSONStream* js) {
@@ skipping 2214 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart