Very simple version of Isolates.

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 "lib/mirrors.h"
@@ skipping 492 matching lines @@
     }
 
     // Set up specific unhandled exception handler.
     const String& callback_name = String::Handle(
         isolate, String::New(state->exception_callback_name()));
     isolate->object_store()->
         set_unhandled_exception_handler(callback_name);
 
     Object& result = Object::Handle();
     result = state->ResolveFunction();
+    bool is_function_spawn = state->library_url() != NULL;

[Ivan Posva, 2013/10/25 07:01:46]

I find this is rather brittle and would suggest that you keep the fact whether
this was spawnFunction or spawnUri in an IsolateSpawnState::was_spawn_uri()
method. Within that method it is OK to rely on the above check, but then it is
all encapsulated within the IsolateSpawnState.

[floitsch, 2013/10/25 13:11:01]

Done.

     delete state;
     state = NULL;
     if (result.IsError()) {
       StoreError(isolate, result);
       return false;
     }
     ASSERT(result.IsFunction());
     Function& func = Function::Handle(isolate);
     func ^= result.raw();
-    result = DartEntry::InvokeFunction(func, Object::empty_array());
+    func = func.ImplicitClosureFunction();
+
+    // Instead of directly invoking the entry point we call '_startIsolate' with

[Ivan Posva, 2013/10/25 07:01:46]

This trampoline through _startIsolate will have the effect that this function
will be shown in the stack traces for spawned isolates. I am not concerned about
exposing this, but I just wanted to mention it.

[floitsch, 2013/10/25 13:11:01]

Yes. It's something we can live with in the near future.
Eventually we want to remove the trampoline.

+    // 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.
+    // 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_function_spawn ? Bool::True() : Bool::False());
+
+    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);
       return false;
     }
   }
   return true;
 }
 
 
 static void ShutdownIsolate(uword parameter) {
@@ skipping 437 matching lines @@
 
 static char* GetRootScriptUri(Isolate* isolate) {
   const Library& library =
       Library::Handle(isolate->object_store()->root_library());
   ASSERT(!library.IsNull());
   const String& script_name = String::Handle(library.url());
   return isolate->current_zone()->MakeCopyOfString(script_name.ToCString());
 }
 
 
-IsolateSpawnState::IsolateSpawnState(const Function& func,
-                                     const Function& callback_func)
+IsolateSpawnState::IsolateSpawnState(const Function& func)
     : isolate_(NULL),
       script_url_(NULL),
       library_url_(NULL),
       function_name_(NULL),
       exception_callback_name_(NULL) {
   script_url_ = strdup(GetRootScriptUri(Isolate::Current()));

[Ivan Posva, 2013/10/25 07:01:46]

There have been changes in this area, so you'll need to update for that. But I
expect that they should not have any immediate impact, but it would be good for
you to verify.

[floitsch, 2013/10/25 13:11:01]

Done.

   const Class& cls = Class::Handle(func.Owner());
   ASSERT(cls.IsTopLevel());
   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 (!callback_func.IsNull()) {
-    const String& callback_name = String::Handle(callback_func.name());
-    exception_callback_name_ = strdup(callback_name.ToCString());
-  } else {
-    exception_callback_name_ = strdup("_unhandledExceptionCallback");
-  }
+  exception_callback_name_ = strdup("_unhandledExceptionCallback");
 }
 
 
 IsolateSpawnState::IsolateSpawnState(const char* script_url)
     : isolate_(NULL),
       library_url_(NULL),
       function_name_(NULL),
       exception_callback_name_(NULL) {
   script_url_ = strdup(script_url);
   library_url_ = NULL;
@@ skipping 39 matching lines @@
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(isolate());
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart