Hide Isolate pointer from embedder

runtime/vm/service_isolate.cc

 // Copyright (c) 2015, 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_isolate.h"
 
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
@@ skipping 91 matching lines @@
 
 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 Dart_Port ExtractPort(Isolate* isolate, Dart_Handle receivePort) {
   const ReceivePort& rp = Api::UnwrapReceivePortHandle(isolate, receivePort);
   if (rp.IsNull()) {
-    return ILLEGAL_PORT;
+    return DART_ILLEGAL_PORT;
   }
   return rp.Id();
 }
 
 
 // These must be kept in sync with service/constants.dart
 #define VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID 0
 #define VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID 1
 #define VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID 2
 
@@ skipping 17 matching lines @@
   ASSERT(!list.IsNull());
   const intptr_t code = VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID;
   const Integer& code_int = Integer::Handle(Integer::New(code));
   list.SetAt(0, code_int);
   return list.raw();
 }
 
 
 const char* ServiceIsolate::kName = "vm-service";
 Isolate* ServiceIsolate::isolate_ = NULL;
-Dart_Port ServiceIsolate::port_ = ILLEGAL_PORT;
-Dart_Port ServiceIsolate::load_port_ = ILLEGAL_PORT;
-Dart_Port ServiceIsolate::origin_ = ILLEGAL_PORT;
+Dart_Port ServiceIsolate::port_ = DART_ILLEGAL_PORT;
+Dart_Port ServiceIsolate::load_port_ = DART_ILLEGAL_PORT;
+Dart_Port ServiceIsolate::origin_ = DART_ILLEGAL_PORT;
 Dart_IsolateCreateCallback ServiceIsolate::create_callback_ = NULL;
 uint8_t* ServiceIsolate::exit_message_ = NULL;
 intptr_t ServiceIsolate::exit_message_length_ = 0;
 Monitor* ServiceIsolate::monitor_ = NULL;
 bool ServiceIsolate::initializing_ = true;
 bool ServiceIsolate::shutting_down_ = false;
 
 
 class RegisterRunningIsolatesVisitor : public IsolateVisitor {
  public:
@@ skipping 100 matching lines @@
       // Boot the dart:vmservice library.
       Dart_EnterScope();
       Dart_Handle url_str =
           Dart_NewStringFromCString(Symbols::Name(Symbols::kDartVMServiceId));
       Dart_Handle library = Dart_LookupLibrary(url_str);
       ASSERT(Dart_IsLibrary(library));
       Dart_Handle result =
           Dart_Invoke(library, Dart_NewStringFromCString("boot"), 0, NULL);
       ASSERT(!Dart_IsError(result));
       Dart_Port port = ExtractPort(isolate, result);
-      ASSERT(port != ILLEGAL_PORT);
+      ASSERT(port != DART_ILLEGAL_PORT);
       ServiceIsolate::SetServicePort(port);
       Dart_ExitScope();
     }
 
     {
       if (FLAG_trace_service) {
         OS::Print("vm-service: Registering running isolates.\n");
       }
       // Register running isolates with service.
       RegisterRunningIsolatesVisitor register_isolates(isolate);
@@ skipping 65 matching lines @@
 
 
 bool ServiceIsolate::Exists() {
   MonitorLocker ml(monitor_);
   return isolate_ != NULL;
 }
 
 
 bool ServiceIsolate::IsRunning() {
   MonitorLocker ml(monitor_);
-  return (port_ != ILLEGAL_PORT) && (isolate_ != NULL);
+  return (port_ != DART_ILLEGAL_PORT) && (isolate_ != NULL);
 }
 
 
 bool ServiceIsolate::IsServiceIsolate(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   return isolate == isolate_;
 }
 
 
 bool ServiceIsolate::IsServiceIsolateDescendant(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   return isolate->origin_id() == origin_;
 }
 
 
 Dart_Port ServiceIsolate::Port() {
   MonitorLocker ml(monitor_);
   return port_;
 }
 
 
 Dart_Port ServiceIsolate::WaitForLoadPort() {
   MonitorLocker ml(monitor_);
 
-  while (initializing_ && (load_port_ == ILLEGAL_PORT)) {
+  while (initializing_ && (load_port_ == DART_ILLEGAL_PORT)) {
     ml.Wait();
   }
 
   return load_port_;
 }
 
 
 Dart_Port ServiceIsolate::LoadPort() {
   MonitorLocker ml(monitor_);
   return load_port_;
@@ skipping 85 matching lines @@
 }
 
 
 void ServiceIsolate::SetServiceIsolate(Isolate* isolate) {
   MonitorLocker ml(monitor_);
   isolate_ = isolate;
   if (isolate_ != NULL) {
     isolate_->is_service_isolate_ = true;
     origin_ = isolate_->origin_id();
   } else {
-    origin_ = ILLEGAL_PORT;
+    origin_ = DART_ILLEGAL_PORT;
   }
 }
 
 void ServiceIsolate::SetLoadPort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   load_port_ = port;
 }
 
 
 void ServiceIsolate::MaybeInjectVMServiceLibrary(Isolate* isolate) {
@@ skipping 89 matching lines @@
 
     Dart_IsolateCreateCallback create_callback =
         ServiceIsolate::create_callback();
     // TODO(johnmccutchan): Support starting up service isolate without embedder
     // provided isolate creation callback.
     if (create_callback == NULL) {
       ServiceIsolate::FinishedInitializing();
       return;
     }
 
-    isolate =
-        reinterpret_cast<Isolate*>(create_callback(ServiceIsolate::kName,
-                                                   NULL,
-                                                   NULL,
-                                                   NULL,
-                                                   &error));
+    isolate = Api::CastIsolate(create_callback(ServiceIsolate::kName,
+                                               NULL,
+                                               NULL,
+                                               NULL,
+                                               &error));
     if (isolate == NULL) {
       OS::PrintErr("vm-service: Isolate creation error: %s\n", error);
       ServiceIsolate::FinishedInitializing();
       return;
     }
 
     Thread::ExitIsolate();
 
     ServiceIsolate::ConstructExitMessageAndCache(isolate);
 
@@ skipping 23 matching lines @@
         OS::PrintErr("vm-service: Error: %s\n", error.ToErrorCString());
       }
       Dart::RunShutdownCallback();
     }
     {
       // Shut the isolate down.
       SwitchIsolateScope switch_scope(isolate);
       Dart::ShutdownIsolate();
     }
     ServiceIsolate::SetServiceIsolate(NULL);
-    ServiceIsolate::SetServicePort(ILLEGAL_PORT);
+    ServiceIsolate::SetServicePort(DART_ILLEGAL_PORT);
     if (FLAG_trace_service) {
       OS::Print("vm-service: Shutdown.\n");
     }
     ServiceIsolate::FinishedExiting();
   }
 
   void RunMain(Isolate* isolate) {
     StartIsolateScope iso_scope(isolate);
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
@@ skipping 57 matching lines @@
   if (!IsRunning()) {
     return;
   }
   {
     MonitorLocker ml(monitor_);
     shutting_down_ = true;
   }
   SendServiceExitMessage();
   {
     MonitorLocker ml(monitor_);
-    while (shutting_down_ && (port_ != ILLEGAL_PORT)) {
+    while (shutting_down_ && (port_ != DART_ILLEGAL_PORT)) {
       ml.Wait();
     }
   }
 }
 
 
 Dart_Handle ServiceIsolate::GetSource(const char* name) {
   ASSERT(name != NULL);
   int i = 0;
   while (true) {
@@ skipping 33 matching lines @@
     return result;
   }
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, source, 0, 0);
 }
 
 }  // namespace dart