Move service into VM

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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debuginfo.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/message.h"
 #include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/reusable_handles.h"
+#include "vm/service.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 #include "vm/verifier.h"
 #include "vm/version.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
@@ skipping 746 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_EntropySource entropy_source,
+    Dart_ServiceIsolateCreateCallback service_create) {
   const char* err_msg = Dart::InitOnce(create, interrupt, unhandled, shutdown,
                                        file_open, file_read, file_write,
-                                       file_close, entropy_source);
+                                       file_close, entropy_source,
+                                       service_create);
   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 352 matching lines @@
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return isolate->main_port();
 }
 
 
+DART_EXPORT bool Dart_IsSendPort(Dart_Handle send_port) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Instance& port = Instance::Handle();
+  port ^= Api::UnwrapHandle(send_port);
+  return DartLibraryCalls::IsSendPort(port);
+}
+
+
+DART_EXPORT bool Dart_SendPortSend(Dart_Handle send_port, Dart_Handle object) {

[siva, 2014/01/10 00:01:54]

Dart_Handle Dart_PostMessage(....)

This function should check if send_port is valid and return an error if it is
not a valid send port.

false returns from Dart_Post should also be returned as an error object.

on Success it would return Api::Success();

Maybe we should also change Dart_Post to operate like that.

+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Instance& port_instance = Instance::Handle();
+  port_instance ^= Api::UnwrapHandle(send_port);
+  const Object& idObj = Object::Handle(
+      DartLibraryCalls::PortGetId(port_instance));
+  if (idObj.IsError()) {
+    // Not a valid port.
+    return false;
+  }
+  Integer& id = Integer::Handle();
+  id ^= idObj.raw();
+  Dart_Port port = static_cast<Dart_Port>(id.AsInt64Value());
+  return Dart_Post(port, object);
+}
+
+
 // --- Scopes ----
 
 DART_EXPORT void Dart_EnterScope() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* new_scope = state->reusable_scope();
   if (new_scope == NULL) {
     new_scope = new ApiLocalScope(state->top_scope(),
@@ skipping 3306 matching lines @@
     return Api::NewError(msg, CURRENT_FUNC);
   }
   {
     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 void Dart_RegisterWithService() {
+  CHECK_ISOLATE(Isolate::Current());
+  Service::SendIsolateStartupMessage();
+}
+
+
+DART_EXPORT void Dart_UnregisterFromService() {
+  CHECK_ISOLATE(Isolate::Current());
+  Service::SendIsolateShutdownMessage();
+}
+
 }  // namespace dart