- Refactor the isolate callback mechanism to also include creation of the

lib/isolate.cc

 // Copyright (c) 2011, 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/bootstrap_natives.h"
 
 #include "vm/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_entry.h"
@@ skipping 240 matching lines @@
 
 DEFINE_NATIVE_ENTRY(IsolateNatives_start, 2) {
   Isolate* preserved_isolate = Isolate::Current();
   const Instance& runnable = Instance::CheckedHandle(arguments->At(0));
   const Class& runnable_class = Class::Handle(runnable.clazz());
   const char* class_name = String::Handle(runnable_class.Name()).ToCString();
   const Library& library = Library::Handle(runnable_class.library());
   ASSERT(!library.IsNull());
   const char* library_url = String::Handle(library.url()).ToCString();
   intptr_t port_id = 0;
-  const char* error_msg = NULL;
+  static const int kEMsgLength = 256;
   LongJump jump;
   bool init_successful = true;
+  Isolate* spawned_isolate = NULL;
+  Zone* preserved_zone = preserved_isolate->current_zone();
+  void* callback_data = preserved_isolate->init_callback_data();
+  Dart_ErrorBuffer error;
+  error.buffer = reinterpret_cast<char*>(preserved_zone->Allocate(kEMsgLength));
+  error.length = kEMsgLength;
 
-  Isolate* spawned_isolate = Dart::CreateIsolate();
-  if (spawned_isolate != NULL) {
-    // First initialize the spawned isolate.
-    LongJump* base = spawned_isolate->long_jump_base();
-    spawned_isolate->set_long_jump_base(&jump);
-    if (setjmp(*jump.Set()) == 0) {
-      Dart::InitializeIsolate(NULL, preserved_isolate->init_callback_data());
-    } else {
-      init_successful = false;
-    }
-    spawned_isolate->set_long_jump_base(base);
+  if ((Isolate::CreateCallback())(callback_data, error)) {
+    spawned_isolate = Isolate::Current();
+    ASSERT(spawned_isolate != NULL);
     // Check arguments to see if the specified library and classes are
     // loaded, this check will throw an exception if they are not loaded.
     if (init_successful && CheckArguments(library_url, class_name)) {
       port_id = PortMap::CreatePort();
       uword data = reinterpret_cast<uword>(
           new IsolateStartData(spawned_isolate,
                                strdup(library_url),
                                strdup(class_name),
                                port_id));
       new Thread(RunIsolate, data);
     } else {
       // Error spawning the isolate, maybe due to initialization errors or
       // errors while loading the application into spawned isolate, shut
       // it down and report error.
       // Make sure to grab the error message out of the isolate before it has
       // been shutdown and to allocate it in the preserved isolates zone.
       {
         Zone zone(spawned_isolate);
         HandleScope scope(spawned_isolate);
-        const String& error = String::Handle(
+        const String& errmsg = String::Handle(
             spawned_isolate->object_store()->sticky_error());
-        const char* temp_error_msg = error.ToCString();
-        intptr_t err_len = strlen(temp_error_msg) + 1;
-        Zone* preserved_zone = preserved_isolate->current_zone();
-        error_msg = reinterpret_cast<char*>(preserved_zone->Allocate(err_len));
-        OS::SNPrint(
-            const_cast<char*>(error_msg), err_len, "%s", temp_error_msg);
+        OS::SNPrint(const_cast<char*>(error.buffer),
+                    kEMsgLength, "%s", errmsg.ToCString());
       }
       Dart::ShutdownIsolate();
       spawned_isolate = NULL;
     }
-  } else {
-    error_msg = "Creation of Isolate failed : ";
   }
 
   // Switch back to the original isolate and return.
   Isolate::SetCurrent(preserved_isolate);
   if (spawned_isolate == NULL) {
     // Unable to spawn isolate correctly, throw exception.
-    ASSERT(error_msg != NULL);
     ThrowErrorException(Exceptions::kIllegalArgument,
-                        error_msg,
+                        error.buffer,
                         library_url,
                         class_name);
   }
   const Instance& port = Instance::Handle(SendPortCreate(port_id));
   if (port.IsUnhandledException()) {
     ThrowErrorException(Exceptions::kInternalError,
                         "Unable to create send port to isolate",
                         library_url,
                         class_name);
   }
@@ skipping 19 matching lines @@
   intptr_t send_id = Smi::CheckedHandle(arguments->At(0)).Value();
   intptr_t reply_id = Smi::CheckedHandle(arguments->At(1)).Value();
   // TODO(iposva): Allow for arbitrary messages to be sent.
   void* data = SerializeObject(Instance::CheckedHandle(arguments->At(2)));
 
   // TODO(turnidge): Throw an exception when the return value is false?
   PortMap::PostMessage(send_id, reply_id, data);
 }
 
 }  // namespace dart