Refactor isolate startup code in preparation for making isolate spawning more truly non-blocking.

runtime/vm/isolate.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 "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "vm/code_observers.h"
@@ skipping 759 matching lines @@
     bool is_spawn_uri = state->is_spawn_uri();
     if (result.IsError()) {
       StoreError(isolate, result);
       return false;
     }
     ASSERT(result.IsFunction());
     Function& func = Function::Handle(isolate);
     func ^= result.raw();
     func = func.ImplicitClosureFunction();
 
+    const Array& capabilities = Array::Handle(Array::New(2));
+    Capability& capability = Capability::Handle();
+    capability = Capability::New(isolate->pause_capability());
+    capabilities.SetAt(0, capability);
+    capability = Capability::New(isolate->terminate_capability());
+    capabilities.SetAt(1, capability);
+
     // Instead of directly invoking the entry point we call '_startIsolate' with
-    // the entry point as argument. The '_startIsolate' function will
-    // communicate with the spawner to receive the initial message before it
-    // executes the real entry point.
+    // the entry point as argument.
     // Since this function ("RunIsolate") is used for both Isolate.spawn and
     // Isolate.spawnUri we also send a boolean flag as argument so that the
     // "_startIsolate" function can act corresponding to how the isolate was
     // created.
-    const Array& args = Array::Handle(Array::New(2));
-    args.SetAt(0, Instance::Handle(func.ImplicitStaticClosure()));
-    args.SetAt(1, is_spawn_uri ? Bool::True() : Bool::False());
+    const Array& args = Array::Handle(Array::New(7));
+    args.SetAt(0, SendPort::Handle(SendPort::New(state->parent_port())));
+    args.SetAt(1, Instance::Handle(func.ImplicitStaticClosure()));
+    args.SetAt(2, Instance::Handle(state->BuildArgs()));
+    args.SetAt(3, Instance::Handle(state->BuildMessage()));
+    args.SetAt(4, is_spawn_uri ? Bool::True() : Bool::False());
+    args.SetAt(5, ReceivePort::Handle(
+        ReceivePort::New(isolate->main_port(), true /* control port */)));
+    args.SetAt(6, capabilities);
 
     const Library& lib = Library::Handle(Library::IsolateLibrary());
     const String& entry_name = String::Handle(String::New("_startIsolate"));
     const Function& entry_point =
         Function::Handle(lib.LookupLocalFunction(entry_name));
     ASSERT(entry_point.IsFunction() && !entry_point.IsNull());
 
     result = DartEntry::InvokeFunction(entry_point, args);
     if (result.IsError()) {
       StoreError(isolate, result);
@@ skipping 307 matching lines @@
   if (stack->Length() > 0) {
     JSONObject jsframe(&jsobj, "topFrame");
 
     ActivationFrame* frame = stack->FrameAt(0);
     frame->PrintToJSONObject(&jsobj);
     // TODO(turnidge): Implement depth differently -- differentiate
     // inlined frames.
     jsobj.AddProperty("depth", (intptr_t)0);
   }
   jsobj.AddProperty("livePorts", message_handler()->live_ports());
-  jsobj.AddProperty("controlPorts", message_handler()->control_ports());
   jsobj.AddProperty("pauseOnExit", message_handler()->pause_on_exit());
 
   // TODO(turnidge): Make the debugger support paused_on_start/exit.
   if (message_handler()->paused_on_start()) {
     ASSERT(debugger()->PauseEvent() == NULL);
     DebuggerEvent pauseEvent(this, DebuggerEvent::kIsolateCreated);
     jsobj.AddProperty("pauseEvent", &pauseEvent);
   } else if (message_handler()->paused_on_exit()) {
     ASSERT(debugger()->PauseEvent() == NULL);
     DebuggerEvent pauseEvent(this, DebuggerEvent::kIsolateShutdown);
@@ skipping 174 matching lines @@
 
 
 template<class T>
 T* Isolate::AllocateReusableHandle() {
   T* handle = reinterpret_cast<T*>(reusable_handles_.AllocateScopedHandle());
   T::initializeHandle(handle, T::null());
   return handle;
 }
 
 
-IsolateSpawnState::IsolateSpawnState(const Function& func)
+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 void SerializeObject(const Instance& obj,
+                            uint8_t** obj_data,
+                            intptr_t* obj_len) {
+  MessageWriter writer(obj_data, &allocator);
+  writer.WriteMessage(obj);
+  *obj_len = writer.BytesWritten();
+}
+
+
+static RawInstance* DeserializeObject(Isolate* isolate,
+                                      uint8_t* obj_data,
+                                      intptr_t obj_len) {
+  if (obj_data == NULL) {
+    return Instance::null();
+  }
+  SnapshotReader reader(obj_data, obj_len, Snapshot::kMessage, isolate);
+  const Object& obj = Object::Handle(isolate, reader.ReadObject());
+  ASSERT(!obj.IsError());
+  Instance& instance = Instance::Handle(isolate);
+  instance ^= obj.raw();  // Can't use Instance::Cast because may be null.
+  return instance.raw();
+}
+
+
+IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
+                                     const Function& func,
+                                     const Instance& message)
     : isolate_(NULL),
+      parent_port_(parent_port),
       script_url_(NULL),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
-      exception_callback_name_(NULL) {
+      exception_callback_name_(NULL),
+      serialized_args_(NULL),
+      serialized_args_len_(0),
+      serialized_message_(NULL),
+      serialized_message_len_(0) {
   script_url_ = NULL;
   const Class& cls = Class::Handle(func.Owner());
   const Library& lib = Library::Handle(cls.library());
   const String& lib_url = String::Handle(lib.url());
   library_url_ = strdup(lib_url.ToCString());
 
   const String& func_name = String::Handle(func.name());
   function_name_ = strdup(func_name.ToCString());
   if (!cls.IsTopLevel()) {
     const String& class_name = String::Handle(cls.Name());
     class_name_ = strdup(class_name.ToCString());
   }
   exception_callback_name_ = strdup("_unhandledExceptionCallback");
+  SerializeObject(message, &serialized_message_, &serialized_message_len_);
 }
 
 
-IsolateSpawnState::IsolateSpawnState(const char* script_url)
+IsolateSpawnState::IsolateSpawnState(Dart_Port parent_port,
+                                     const char* script_url,
+                                     const Instance& args,
+                                     const Instance& message)
     : isolate_(NULL),
+      parent_port_(parent_port),
       library_url_(NULL),
       class_name_(NULL),
       function_name_(NULL),
-      exception_callback_name_(NULL) {
+      exception_callback_name_(NULL),
+      serialized_args_(NULL),
+      serialized_args_len_(0),
+      serialized_message_(NULL),
+      serialized_message_len_(0) {
   script_url_ = strdup(script_url);
   library_url_ = NULL;
   function_name_ = strdup("main");
   exception_callback_name_ = strdup("_unhandledExceptionCallback");
+  SerializeObject(args, &serialized_args_, &serialized_args_len_);
+  SerializeObject(message, &serialized_message_, &serialized_message_len_);
 }
 
 
 IsolateSpawnState::~IsolateSpawnState() {
   free(script_url_);
   free(library_url_);
   free(function_name_);
   free(class_name_);
   free(exception_callback_name_);
+  free(serialized_args_);
+  free(serialized_message_);
 }
 
 
 RawObject* IsolateSpawnState::ResolveFunction() {
   // Resolve the library.
   Library& lib = Library::Handle();
   if (library_url()) {
     const String& lib_url = String::Handle(String::New(library_url()));
     lib = Library::LookupLibrary(lib_url);
     if (lib.IsNull() || lib.IsError()) {
@@ skipping 36 matching lines @@
     const String& msg = String::Handle(String::NewFormatted(
           "Unable to resolve static method '%s.%s' in library '%s'.",
           class_name(), function_name(),
           (library_url() != NULL ? library_url() : script_url())));
     return LanguageError::New(msg);
   }
   return func.raw();
 }
 
 
+RawInstance* IsolateSpawnState::BuildArgs() {
+  return DeserializeObject(isolate_, serialized_args_, serialized_args_len_);
+}
+
+
+RawInstance* IsolateSpawnState::BuildMessage() {
+  return DeserializeObject(isolate_,
+                           serialized_message_, serialized_message_len_);
+}
+
+
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(I);
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart