Hide Isolate pointer from embedder

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 372 matching lines @@
   }
   if (ClassFinalizer::ProcessPendingClasses()) {
     return Api::Success();
   }
   ASSERT(isolate->object_store()->sticky_error() != Object::null());
   return Api::NewHandle(isolate, isolate->object_store()->sticky_error());
 }
 
 
 Dart_Isolate Api::CastIsolate(Isolate* isolate) {
-  return reinterpret_cast<Dart_Isolate>(isolate);
+  if (isolate == NULL) {
+    return DART_ILLEGAL_ISOLATE;
+  }
+  return static_cast<Dart_Isolate>(isolate->main_port());
 }
 
 
+Isolate* Api::CastIsolate(Dart_Isolate isolate) {
+  return PortMap::GetIsolate(static_cast<Dart_Port>(isolate));
+}
+
+
 Dart_Handle Api::NewError(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
@@ skipping 887 matching lines @@
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
     const Error& error_obj =
         Error::Handle(isolate,
                       Dart::InitializeIsolate(snapshot, callback_data));
     if (error_obj.IsNull()) {
       if (FLAG_check_function_fingerprints) {
         Library::CheckFunctionFingerprints();
       }
       START_TIMER(isolate, time_total_runtime);
-      return reinterpret_cast<Dart_Isolate>(isolate);
+      return Api::CastIsolate(isolate);
     }
     *error = strdup(error_obj.ToErrorCString());
   }
   Dart::ShutdownIsolate();
-  return reinterpret_cast<Dart_Isolate>(NULL);
+  return DART_ILLEGAL_ISOLATE;
 }
 
 
 DART_EXPORT void Dart_ShutdownIsolate() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   {
     StackZone zone(isolate);
     HandleScope handle_scope(isolate);
     Dart::RunShutdownCallback();
@@ skipping 10 matching lines @@
 
 DART_EXPORT void* Dart_CurrentIsolateData() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return isolate->init_callback_data();
 }
 
 
 DART_EXPORT void* Dart_IsolateData(Dart_Isolate isolate) {
   TRACE_API_CALL(CURRENT_FUNC);
-  if (isolate == NULL) {
-    FATAL1("%s expects argument 'isolate' to be non-null.",  CURRENT_FUNC);
+  Isolate* iso = Api::CastIsolate(isolate);
+  if (iso == NULL) {
+    return NULL;
   }
-  // TODO(16615): Validate isolate parameter.
-  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   return iso->init_callback_data();
 }
 
 
 DART_EXPORT Dart_Handle Dart_DebugName() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, String::New(isolate->name()));
 }
 
 
 
-DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate) {
+DART_EXPORT bool Dart_EnterIsolate(Dart_Isolate isolate) {
   CHECK_NO_ISOLATE(Isolate::Current());
-  // TODO(16615): Validate isolate parameter.
-  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
+  Isolate* iso = Api::CastIsolate(isolate);
+  if (iso == NULL) {
+    return false;
+  }
   if (iso->mutator_thread() != NULL) {
     FATAL("Multiple mutators within one isolate is not supported.");
+    return false;
   }
   Thread::EnterIsolate(iso);
+  return true;
 }
 
 
 DART_EXPORT void Dart_IsolateBlocked() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   IsolateProfilerData* profiler_data = isolate->profiler_data();
   if (profiler_data == NULL) {
     return;
   }
@@ skipping 98 matching lines @@
         Api::NewError("%s expects the isolate to have a script loaded in it.",
                       CURRENT_FUNC);
   }
   ScriptSnapshotWriter writer(buffer, ApiReallocate);
   writer.WriteScriptSnapshot(library);
   *size = writer.BytesWritten();
   return Api::Success();
 }
 
 
-DART_EXPORT void Dart_InterruptIsolate(Dart_Isolate isolate) {
+DART_EXPORT bool Dart_InterruptIsolate(Dart_Isolate isolate) {
   TRACE_API_CALL(CURRENT_FUNC);
-  if (isolate == NULL) {
-    FATAL1("%s expects argument 'isolate' to be non-null.",  CURRENT_FUNC);
+  Isolate* iso = Api::CastIsolate(isolate);
+  if (iso == NULL) {
+    return false;
   }
-  // TODO(16615): Validate isolate parameter.
-  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   iso->ScheduleInterrupts(Isolate::kApiInterrupt);
   // Can't use Dart_Post() since there isn't a current isolate.
   Dart_CObject api_null = { Dart_CObject_kNull , { 0 } };
-  Dart_PostCObject(iso->main_port(), &api_null);
+  return Dart_PostCObject(iso->main_port(), &api_null);
 }
 
 
 DART_EXPORT bool Dart_IsolateMakeRunnable(Dart_Isolate isolate) {
   CHECK_NO_ISOLATE(Isolate::Current());
-  if (isolate == NULL) {
-    FATAL1("%s expects argument 'isolate' to be non-null.",  CURRENT_FUNC);
+  Isolate* iso = Api::CastIsolate(isolate);
+  if (iso == NULL) {
+    return false;
   }
-  // TODO(16615): Validate isolate parameter.
-  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   if (iso->object_store()->root_library() == Library::null()) {
     // The embedder should have called Dart_LoadScript by now.
     return false;
   }
   return iso->MakeRunnable();
 }
 
 
 // --- Messages and Ports ---
 
@@ skipping 94 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);
 }
 
 
 DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-  if (port_id == ILLEGAL_PORT) {
+  if (port_id == DART_ILLEGAL_PORT) {
     return false;
   }
   const Object& object = Object::Handle(isolate, Api::UnwrapHandle(handle));
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(object);
   intptr_t len = writer.BytesWritten();
   return PortMap::PostMessage(new Message(
       port_id, data, len, Message::kNormalPriority));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_CALLBACK_STATE(isolate);
-  if (port_id == ILLEGAL_PORT) {
+  if (port_id == DART_ILLEGAL_PORT) {
     return Api::NewError("%s: illegal port_id %" Pd64 ".",
                          CURRENT_FUNC,
                          port_id);
   }
   return Api::NewHandle(isolate, SendPort::New(port_id));
 }
 
 
 DART_EXPORT Dart_Handle Dart_SendPortGetId(Dart_Handle port,
                                            Dart_Port* port_id) {
@@ skipping 3894 matching lines @@
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 
 // --- Service support ---
 
 DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate) {
-  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
+  Isolate* iso = Api::CastIsolate(isolate);
+  if (iso == NULL) {
+    return false;
+  }
   return ServiceIsolate::IsServiceIsolate(iso);
 }
 
 
 DART_EXPORT Dart_Port Dart_ServiceWaitForLoadPort() {
   return ServiceIsolate::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