Add new Dart API call Dart_MakeIsolateRunnable(). This would allow an

runtime/vm/isolate.h

 // 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.
 
 #ifndef VM_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/thread.h"
 #include "vm/base_isolate.h"
 #include "vm/class_table.h"
 #include "vm/gc_callbacks.h"
 #include "vm/megamorphic_cache_table.h"
 #include "vm/store_buffer.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 // Forward declarations.
 class ApiState;
 class CodeIndexTable;
 class Debugger;
+class Function;
 class HandleScope;
 class HandleVisitor;
 class Heap;
 class ICData;
 class LongJump;
 class MessageHandler;
 class Mutex;
 class ObjectPointerVisitor;
 class ObjectStore;
 class RawInstance;
 class RawArray;
 class RawContext;
 class RawDouble;
 class RawMint;
+class RawObject;
 class RawInteger;
 class RawError;
 class Simulator;
 class StackResource;
 class StackZone;
 class StubCode;
 class RawFloat32x4;
 class RawUint32x4;
 
 
@@ skipping 219 matching lines @@
     kInterruptsMask =
         kApiInterrupt |
         kMessageInterrupt |
         kStoreBufferInterrupt |
         kVmStatusInterrupt,
   };
 
   void ScheduleInterrupts(uword interrupt_bits);
   uword GetAndClearInterrupts();
 
+  bool MakeRunnable();
+  void Run();
+
   MessageHandler* message_handler() const { return message_handler_; }
   void set_message_handler(MessageHandler* value) { message_handler_ = value; }
 
+  bool is_runnable() const { return is_runnable_; }
+  void set_is_runnable(bool value) { is_runnable_ = value; }
+
   uword spawn_data() const { return spawn_data_; }
-  void set_spawn_data(uword value) { spawn_data_ = value; }
+  void set_spawn_data(uword value) {
+    ASSERT(this == Isolate::Current());
+    spawn_data_ = value;
+  }
 
   static const intptr_t kNoDeoptId = -1;
   intptr_t deopt_id() const { return deopt_id_; }
   void set_deopt_id(int value) {
     ASSERT(value >= 0);
     deopt_id_ = value;
   }
   intptr_t GetNextDeoptId() {
     ASSERT(deopt_id_ != kNoDeoptId);
     return deopt_id_++;
@@ skipping 164 matching lines @@
   Simulator* simulator_;
   LongJump* long_jump_base_;
   TimerList timer_list_;
   intptr_t deopt_id_;
   RawArray* ic_data_array_;
   Mutex* mutex_;  // protects stack_limit_ and saved_stack_limit_.
   uword stack_limit_;
   uword saved_stack_limit_;
   MessageHandler* message_handler_;
   uword spawn_data_;
+  bool is_runnable_;
   GcPrologueCallbacks gc_prologue_callbacks_;
   GcEpilogueCallbacks gc_epilogue_callbacks_;
 
   // Deoptimization support.
   intptr_t* deopt_cpu_registers_copy_;
   fpu_register_t* deopt_fpu_registers_copy_;
   intptr_t* deopt_frame_copy_;
   intptr_t deopt_frame_copy_size_;
   DeferredObject* deferred_objects_;
 
@@ skipping 70 matching lines @@
   }
 
  private:
   Isolate* new_isolate_;
   Isolate* saved_isolate_;
   uword saved_stack_limit_;
 
   DISALLOW_COPY_AND_ASSIGN(SwitchIsolateScope);
 };
 
+
+class IsolateSpawnState {
+ public:
+  IsolateSpawnState(const Function& func, const Function& callback_func);
+  explicit IsolateSpawnState(const char* script_url);
+  ~IsolateSpawnState();
+
+  Isolate* isolate() const { return isolate_; }
+  void set_isolate(Isolate* value) { isolate_ = value; }
+  char* script_url() const { return script_url_; }
+  char* library_url() const { return library_url_; }
+  char* function_name() const { return function_name_; }
+  char* exception_callback_name() const { return exception_callback_name_; }
+
+  RawObject* ResolveFunction();
+  void Cleanup();
+
+ private:
+  Isolate* isolate_;
+  char* script_url_;
+  char* library_url_;
+  char* function_name_;
+  char* exception_callback_name_;
+};
+
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_