Use the ThreadPool for all isolates and native ports. Previously,

runtime/vm/isolate.h

 // Copyright (c) 2012, 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"
@@ skipping 15 matching lines @@
 class MessageHandler;
 class Mutex;
 class ObjectPointerVisitor;
 class ObjectStore;
 class RawContext;
 class RawError;
 class StackResource;
 class StubCode;
 class Zone;
 
-
 class Isolate : public BaseIsolate {
  public:
   ~Isolate();
 
   static inline Isolate* Current() {
     return reinterpret_cast<Isolate*>(Thread::GetThreadLocal(isolate_key));
   }
 
   static void SetCurrent(Isolate* isolate);
 
@@ skipping 90 matching lines @@
   void SetStackLimitFromCurrentTOS(uword isolate_stack_top);
 
   uword stack_limit_address() const {
     return reinterpret_cast<uword>(&stack_limit_);
   }
 
   // The current stack limit.  This may be overwritten with a special
   // value to trigger interrupts.
   uword stack_limit() const { return stack_limit_; }
 
-  // The true stack limit for this isolate.  This does not change
-  // after isolate initialization.
+  // The true stack limit for this isolate.
   uword saved_stack_limit() const { return saved_stack_limit_; }
 
   enum {
     kApiInterrupt = 0x1,      // An interrupt from Dart_InterruptIsolate.
     kMessageInterrupt = 0x2,  // An interrupt to process an out of band message.
 
     kInterruptsMask = kApiInterrupt | kMessageInterrupt,
   };
 
   void ScheduleInterrupts(uword interrupt_bits);
   uword GetAndClearInterrupts();
 
   MessageHandler* message_handler() const { return message_handler_; }
   void set_message_handler(MessageHandler* value) { message_handler_ = value; }
 
-  // Returns null on success, a RawError on failure.
-  RawError* StandardRunLoop();
+  uword spawn_data() const { return spawn_data_; }
+  void set_spawn_data(uword value) { spawn_data_ = value; }
 
   intptr_t ast_node_id() const { return ast_node_id_; }
   void set_ast_node_id(int value) { ast_node_id_ = value; }
 
   Debugger* debugger() const { return debugger_; }
 
   static void SetCreateCallback(Dart_IsolateCreateCallback cback);
   static Dart_IsolateCreateCallback CreateCallback();
 
   static void SetInterruptCallback(Dart_IsolateInterruptCallback cback);
@@ skipping 34 matching lines @@
   StubCode* stub_code_;
   CodeIndexTable* code_index_table_;
   Debugger* debugger_;
   LongJump* long_jump_base_;
   TimerList timer_list_;
   intptr_t ast_node_id_;
   Mutex* mutex_;  // protects stack_limit_ and saved_stack_limit_.
   uword stack_limit_;
   uword saved_stack_limit_;
   MessageHandler* message_handler_;
+  uword spawn_data_;
   GcPrologueCallbacks gc_prologue_callbacks_;
   GcEpilogueCallbacks gc_epilogue_callbacks_;
 
   static Dart_IsolateCreateCallback create_callback_;
   static Dart_IsolateInterruptCallback interrupt_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
+// When we are starting to execute code in a new isolate, we use the
+// StartIsolateScope.

[siva, 2012/04/18 22:05:00]

It is not necessarily a new isolate right, anytime we execute code in an isolate
(i.e handle a message) we call StartIsolateScope.

[turnidge, 2012/04/19 19:46:55]

Done.

+class StartIsolateScope {
+ public:
+  explicit StartIsolateScope(Isolate* new_isolate)
+      : saved_isolate_(Isolate::Current()) {
+    if (saved_isolate_ != new_isolate) {
+      ASSERT(Isolate::Current() == NULL);
+      Isolate::SetCurrent(new_isolate);
+      new_isolate->SetStackLimitFromCurrentTOS(reinterpret_cast<uword>(this));
+    }
+  }
+
+  ~StartIsolateScope() {

[siva, 2012/04/18 22:05:00]

Should we set the stack limit of the isolate we are about to switch out of to
some value like 0. It will ensure that we don't ever run code without going
through the constructor above.

[turnidge, 2012/04/19 19:46:55]

Done.  Had to rework ShutdownIsolate a bit in lib/isolate.cc to avoid deleting
the isolate during a StartIsolateScope.

+    Isolate::SetCurrent(saved_isolate_);
+  }
+
+ private:
+  Isolate* saved_isolate_;
+
+  DISALLOW_COPY_AND_ASSIGN(StartIsolateScope);
+};
+
+// When we need to temporarily become another isolate, we use the
+// SwitchIsolateScope.  It is not permitted to run dart code while in
+// a SwitchIsolateScope.
+class SwitchIsolateScope {
+ public:
+  explicit SwitchIsolateScope(Isolate* new_isolate)
+      : saved_isolate_(Isolate::Current()) {
+    Isolate::SetCurrent(new_isolate);
+    if (new_isolate != NULL) {
+      // Don't allow dart code to execute.
+      new_isolate->SetStackLimit(~static_cast<uword>(0));
+    }
+  }
+
+  ~SwitchIsolateScope() {
+    Isolate::SetCurrent(saved_isolate_);

[siva, 2012/04/18 22:05:00]

Shouldn't we be restoring the stack limit of new_isolate (isolate we are going
to switch out of) to what it was before you set it to 0.

[turnidge, 2012/04/19 19:46:55]

Done.

+  }
+
+ private:
+  Isolate* saved_isolate_;
+
+  DISALLOW_COPY_AND_ASSIGN(SwitchIsolateScope);
+};
+
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_