Remove experimental warning from Isolate methods.

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 191 matching lines @@
   external static Future<Isolate> spawnUri(
       Uri uri,
       List<String> args,
       var message,
       {bool paused: false,
        Uri packageRoot});
 
   /**
    * Requests the isolate to pause.
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * 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.
    *
    * The event loop may be paused before previously sent, but not yet exeuted,
    * messages have been reached.
    *
    * If [resumeCapability] is provided, it is used to identity the pause,
    * and must be used again to end the pause using [resume].
@@ skipping 12 matching lines @@
     _pause(resumeCapability);
     return resumeCapability;
   }
 
   /** Internal implementation of [pause]. */
   external void _pause(Capability resumeCapability);
 
   /**
    * Resumes a paused isolate.
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * Sends a message to an isolate requesting that it ends a pause
    * that was requested using the [resumeCapability].
    *
    * When all active pause requests have been cancelled, the isolate
    * will continue handling normal messages.
    *
    * The capability must be one returned by a call to [pause] on this
    * isolate, otherwise the resume call does nothing.
    */
   external void resume(Capability resumeCapability);
 
   /**
    * Asks the isolate to send [response] on [responsePort] when it terminates.
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * The isolate will send a `response` message on `responsePort` as the last
    * thing before it terminates. It will run no further code after the message
    * has been sent.
    *
    * Adding the same port more than once will only cause it to receive one
    * message, using the last response value that was added.
    *
    * If the isolate is already dead, no message will be sent.
    * If `response` cannot be sent to the isolate, then the request is ignored.
    * It is recommended to only use simple values that can be sent to all
    * isolates, like `null`, booleans, numbers or strings.
    */
   /* TODO(lrn): Can we do better? Can the system recognize this message and
    * send a reply if the receiving isolate is dead?
    */
   external void addOnExitListener(SendPort responsePort, {Object response});
 
   /**
    * Stop listening on exit messages from the isolate.
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * If a call has previously been made to [addOnExitListener] with the same
    * send-port, this will unregister the port, and it will no longer receive
    * a message when the isolate terminates.
    * A response may still be sent until this operation is fully processed by
    * the isolate.
    */
   external void removeOnExitListener(SendPort responsePort);
 
   /**
    * Set whether uncaught errors will terminate the isolate.
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * If errors are fatal, any uncaught error will terminate the isolate
    * event loop and shut down the isolate.
    *
    * This call requires the [terminateCapability] for the isolate.
    * If the capability is not correct, no change is made.
    */
   external void setErrorsFatal(bool errorsAreFatal);
 
   /**
    * Requests the isolate to shut down.
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * The isolate is requested to terminate itself.
    * The [priority] argument specifies when this must happen.
    *
    * The [priority] must be one of [IMMEDIATE] or [BEFORE_NEXT_EVENT].
    * The shutdown is performed at different times depending on the priority:
    *
    * * `IMMEDIATE`: The the isolate shuts down as soon as possible.
    *     Control messages are handled in order, so all previously sent control
    *     events from this isolate will all have been processed.
    *     The shutdown should happen no later than if sent with
    *     `BEFORE_NEXT_EVENT`.
    *     It may happen earlier if the system has a way to shut down cleanly
    *     at an earlier time, even during the execution of another event.
    * * `BEFORE_NEXT_EVENT`: The shutdown is scheduled for the next time
    *     control returns to the event loop of the receiving isolate,
    *     after the current event, and any already scheduled control events,
    *     are completed.
    */
   external void kill({int priority: BEFORE_NEXT_EVENT});
 
   /**
    * Request that the isolate send [response] on the [responsePort].
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * If the isolate is alive, it will eventually send `response`
    * (defaulting to `null`) on the response port.
    *
    * The [priority] must be one of [IMMEDIATE] or [BEFORE_NEXT_EVENT].
    * The response is sent at different times depending on the ping type:
    *
    * * `IMMEDIATE`: The the isolate responds as soon as it receives the
    *     control message. This is after any previous control message
    *     from the same isolate has been received, but may be during
    *     execution of another event.
    * * `BEFORE_NEXT_EVENT`: The response is scheduled for the next time
    *     control returns to the event loop of the receiving isolate,
    *     after the current event, and any already scheduled control events,
    *     are completed.
    *
    * If `response` cannot be sent to the isolate, then the request is ignored.
    * It is recommended to only use simple values that can be sent to all
    * isolates, like `null`, booleans, numbers or strings.
    */
   external void ping(SendPort responsePort, {Object response,
                                              int priority: IMMEDIATE});
 
   /**
    * Requests that uncaught errors of the isolate are sent back to [port].
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * The errors are sent back as two elements lists.
    * The first element is a `String` representation of the error, usually
    * created by calling `toString` on the error.
    * The second element is a `String` representation of an accompanying
    * stack trace, or `null` if no stack trace was provided.
    * To convert this back to a [StackTrace] object, use [StackTrace.fromString].
    *
    * Listening using the same port more than once does nothing. It will only
    * get each error once.
    */
   external void addErrorListener(SendPort port);
 
   /**
    * Stop listening for uncaught errors through [port].
    *
-   * WARNING: This method is experimental and not handled on every platform yet.
-   *
    * The `port` should be a port that is listening for errors through
    * [addErrorListener]. This call requests that the isolate stops sending
    * errors on the port.
    *
    * If the same port has been passed via `addErrorListener` more than once,
    * only one call to `removeErrorListener` is needed to stop it from receiving
    * errors.
    *
    * Closing the receive port at the end of the send port will not stop the
    * isolate from sending errors, they are just going to be lost.
@@ skipping 207 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;
 }