Add "checked" parameter to Isolate.spawnUri.

sdk/lib/isolate/isolate.dart

 // 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.
 
 /**
  * Concurrent programming using _isolates_:
  * independent workers that are similar to threads
  * but don't share memory,
  * communicating only via messages.
  */
@@ skipping 130 matching lines @@
    * Usually the initial [message] contains a [SendPort] so
    * that the spawner and spawnee can communicate with each other.
    *
    * If the [paused] parameter is set to `true`,
    * the isolate will start up in a paused state,
    * as if by an initial call of `isolate.pause(isolate.pauseCapability)`.
    * This allows setting up error or exit listeners on the isolate
    * before it starts running.
    * To resume the isolate, call `isolate.resume(isolate.pauseCapability)`.
    *
-   * WARNING: The `pause` parameter is not implemented on all platforms yet.
-   *
    * Returns a future that will complete with an [Isolate] instance if the
    * spawning succeeded. It will complete with an error otherwise.
    */
   external static Future<Isolate> spawn(void entryPoint(message), var message,
                                         { bool paused: false });
 
   /**
    * Creates and spawns an isolate that runs the code from the library with
    * the specified URI.
    *
    * The isolate starts executing the top-level `main` function of the library
    * with the given URI.
    *
    * The target `main` must be a subtype of one of these three signatures:
    *
    * * `main()`
    * * `main(args)`
    * * `main(args, message)`
    *
    * When present, the parameter `args` is set to the provided [args] list.
    * When present, the parameter `message` is set to the initial [message].
    *
+   * If the [paused] parameter is set to `true`,
+   * the isolate will start up in a paused state,
+   * as if by an initial call of `isolate.pause(isolate.pauseCapability)`.
+   * This allows setting up error or exit listeners on the isolate
+   * before it starts running.
+   * To resume the isolate, call `isolate.resume(isolate.pauseCapability)`.
+   *
+   * If the [checked] parameter is set to `true` or `false`,
+   * the new isolate will run code in checked mode,
+   * respectively in production mode, if possible.
+   * If the parameter is omitted, the new isolate will inherit the
+   * value from the current isolate.
+   *
+   * It may not always be possible to honor the `checked` parameter.
+   * If the isolate code was pre-compiled, it may not be possible to change
+   * the checked mode setting dynamically.
+   * In that case, the `checked` parameter is ignored.
+   *
+   * WARNING: The [checked] parameter is not implemented on all platforms yet.
+   *
    * If the [packageRoot] parameter is provided, it is used to find the location
    * of packages imports in the spawned isolate.
    * The `packageRoot` URI must be a "file" or "http"/"https" URI that specifies
    * a directory. If it doesn't end in a slash, one will be added before
    * using the URI, and any query or fragment parts are ignored.
    * Package imports (like "package:foo/bar.dart") in the new isolate are
    * resolved against this location, as by
    * `packageRoot.resolve("foo/bar.dart")`.
    * This includes the main entry [uri] if it happens to be a package-URL.
    * If [packageRoot] is omitted, it defaults to the same URI that
    * the current isolate is using.
    *
    * WARNING: The [packageRoot] parameter is not implemented on all
    * platforms yet.
    *
-   * If the [paused] parameter is set to `true`,
-   * the isolate will start up in a paused state,
-   * as if by an initial call of `isolate.pause(isolate.pauseCapability)`.
-   * This allows setting up error or exit listeners on the isolate
-   * before it starts running.
-   * To resume the isolate, call `isolate.resume(isolate.pauseCapability)`.
-   *
-   * WARNING: The `pause` parameter is not implemented on all platforms yet.
-   *
    * Returns a future that will complete with an [Isolate] instance if the
    * spawning succeeded. It will complete with an error otherwise.
    */
   external static Future<Isolate> spawnUri(
       Uri uri,
       List<String> args,
       var message,
       {bool paused: false,
+       bool checked,
        Uri packageRoot});
 
   /**
    * Requests the isolate to pause.
    *
    * The isolate should stop handling events by pausing its event queue.
    * The request will eventually make the isolate stop doing anything.
    * It will be handled before any other messages that are later sent to the
    * isolate from the current isolate, but no other guarantees are provided.
    *
@@ skipping 363 matching lines @@
  * as the original error, but has no other features of the original error.
  */
 class RemoteError implements Error {
   final String _description;
   final StackTrace stackTrace;
   RemoteError(String description, String stackDescription)
       : _description = description,
         stackTrace = new StackTrace.fromString(stackDescription);
   String toString() => _description;
 }