Service isolate rework

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 1186 matching lines @@
 
 DART_EXPORT bool Dart_Initialize(
     Dart_IsolateCreateCallback create,
     Dart_IsolateInterruptCallback interrupt,
     Dart_IsolateUnhandledExceptionCallback unhandled,
     Dart_IsolateShutdownCallback shutdown,
     Dart_FileOpenCallback file_open,
     Dart_FileReadCallback file_read,
     Dart_FileWriteCallback file_write,
     Dart_FileCloseCallback file_close,
-    Dart_EntropySource entropy_source,
-    Dart_ServiceIsolateCreateCalback service_create) {
+    Dart_EntropySource entropy_source) {
   const char* err_msg = Dart::InitOnce(create, interrupt, unhandled, shutdown,
                                        file_open, file_read, file_write,
-                                       file_close, entropy_source,
-                                       service_create);
+                                       file_close, entropy_source);
   if (err_msg != NULL) {
     OS::PrintErr("Dart_Initialize: %s\n", err_msg);
     return false;
   }
   return true;
 }
 
 
 DART_EXPORT bool Dart_Cleanup() {
   CHECK_NO_ISOLATE(Isolate::Current());
@@ skipping 22 matching lines @@
                               const char* main) {
   if (script_uri == NULL) {
     // Just use the main as the name.
     if (main == NULL) {
       return strdup("isolate");
     } else {
       return strdup(main);
     }
   }
 
+  if (Service::IsServiceIsolateName(script_uri)) {
+    return strdup(script_uri);
+  }
+
   // Skip past any slashes and backslashes in the script uri.
   const char* last_slash = strrchr(script_uri, '/');
   if (last_slash != NULL) {
     script_uri = last_slash + 1;
   }
   const char* last_backslash = strrchr(script_uri, '\\');
   if (last_backslash != NULL) {
     script_uri = last_backslash + 1;
   }
   if (main == NULL) {
@@ skipping 249 matching lines @@
       ml.Wait();
     }
   }
   if (isolate->object_store()->sticky_error() != Object::null()) {
     Dart_Handle error = Api::NewHandle(isolate,
                                        isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return error;
   }
   if (FLAG_print_class_table) {
+    HANDLESCOPE(isolate);
     isolate->class_table()->Print();
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_HandleMessage() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
@@ skipping 3865 matching lines @@
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 
 // --- Service support ---
 
-DART_EXPORT Dart_Isolate Dart_GetServiceIsolate(void* callback_data) {
-  return Api::CastIsolate(Service::GetServiceIsolate(callback_data));
+DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate) {
+  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
+  return Service::IsServiceIsolate(iso);
 }
 
 
-DART_EXPORT bool Dart_IsServiceRunning() {
-  return Service::IsRunning();
+DART_EXPORT Dart_Port Dart_ServiceWaitForLoadPort() {
+  return Service::WaitForLoadPort();
 }
 
 
 DART_EXPORT void Dart_RegisterIsolateServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterIsolateEmbedderCallback(name, callback, user_data);
 }
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart