isolates refactor: this change introduces 'dart:isolate' as a library. This is a

lib/isolate/isolate_api.dart

 // 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.
 
-// Dart core library.
-// TODO(sigmund): move to dart:isolate
-
 /**
  * [SendPort]s are created from [ReceivePort]s. Any message sent through
  * a [SendPort] is delivered to its respective [ReceivePort]. There might be
  * many [SendPort]s for the same [ReceivePort].
  *
  * [SendPort]s can be transmitted to other isolates.
  */
 interface SendPort extends Hashable {
 
   /**
@@ skipping 30 matching lines @@
 
 /**
  * [ReceivePort]s, together with [SendPort]s, are the only means of
  * communication between isolates. [ReceivePort]s have a [:toSendPort:] method
  * which returns a [SendPort]. Any message that is sent through this [SendPort]
  * is delivered to the [ReceivePort] it has been created from. There, they are
  * dispatched to the callback that has been registered on the receive port.
  *
  * A [ReceivePort] may have many [SendPort]s.
  */
-interface ReceivePort default ReceivePortFactory {
+interface ReceivePort default _ReceivePortFactory {
 
   /**
    * Opens a long-lived port for receiving messages. The returned port
    * must be explicitly closed through [ReceivePort.close].
    */
   ReceivePort();
 
   /**
    * Opens a single-shot reply port. Once a message has been received
    * on this port, it is automatically closed -- obviously without
@@ skipping 71 matching lines @@
    * inside the new isolate and stored in the read-only field [port].
    *  A corresponding [SendPort] is sent to the isolate that invoked [spawn].
    * Since spawning an isolate is an asynchronous operation this method returns
    * a [Future] of this [SendPort].
    *
    * A common pattern to instantiate new isolates is to enqueue the instructions
    * using [Future.then].
    * [:myIsolate.spawn().then((SendPort port) { port.send('hi there'); });:]
    */
   Future<SendPort> spawn() {
-    return IsolateNatives.spawn(this, _isLight);
+    return _IsolateNatives.spawn(this, _isLight);
   }
 
   // The private run method is invoked with the receive port. Before
   // main is invoked we store the port in a field so it can be
   // accessed from subclasses of Isolate.
   void _run(ReceivePort port) {
     _port = port;
     main();
   }
 
@@ skipping 12 matching lines @@
   /**
    * When isolates are created, an instance of the template's class is
    * instantiated in the new isolate. After the [port] has been set up, this
    * [main] method is invoked on the instance.
    */
   abstract void main();
 
   final bool _isLight;
   ReceivePort _port;
 }
+
+/**
+ * [Isolate2] provides APIs to spawn, communicate, and stop an isolate. An
+ * isolate can be spawned by simply creating a new instance of [Isolate2]. The
+ * [Isolate2] instance exposes a port to communicate with the isolate and
+ * methods to control its behavior remotely.
+ */
+ // TODO(sigmund): rename to Isolate once we delete the old implementation
+interface Isolate2 default _IsolateFactory {
+
+  /**
+   * Create and spawn an isolate that shares the same code as the current
+   * isolate, but that starts from [topLevelFunction]. The [topLevelFunction]
+   * argument must be a static method closure that takes exactly one
+   * argument of type [ReceivePort]. It is illegal to pass a function closure
+   * that captures values in scope.
+   *
+   * When an child isolate is spawned, a new [ReceivePort] is created for it.
+   * This port is passed to [topLevelFunction]. A [SendPort] derived from
+   * such port is sent to the spawner isolate, which is accessible in
+   * [Isolate2.sendPort] field of this instance.
+   */
+  Isolate2.fromCode(Function topLevelFunction);
+
+  /**
+   * Create and spawn an isolate whose code is available at [uri].
+   * The code in [uri] must have an method called [: isolateMain :], which takes
+   * exactly one argument of type [ReceivePort].
+   * Like with [Isolate2.fromCode], a [ReceivePort] is created in the child
+   * isolate, and a [SendPort] to it is stored in [Isolate2.sendPort].
+   */
+  Isolate2.fromUri(String uri);
+
+  /** Port used to communicate with this isolate. */
+  SendPort sendPort;
+}