Make methods on isolate external.

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 125 matching lines @@
    * If an isolate is paused more than once using the same capability,
    * only one resume with that capability is needed to end the pause.
    *
    * If an isolate is paused using more than one capability,
    * they must all be individully ended before the isolate resumes.
    *
    * Returns the capability that must be used to resume end the pause.
    */
   Capability pause([Capability resumeCapability]) {
     if (resumeCapability == null) resumeCapability = new Capability();
-    var message = new List(3)
-        ..[0] = "pause"
-        ..[1] = pauseCapability
-        ..[2] = resumeCapability;
-    controlPort.send(message);
+    _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.
    */
-  void resume(Capability resumeCapability) {
-    var message = new List(2)
-        ..[0] = "resume"
-        ..[1] = resumeCapability;
-    controlPort.send(message);
-  }
+  external void resume(Capability resumeCapability);
 
   /**
    * Asks the isolate to send a message on [responsePort] when it terminates.
    *
    * WARNING: This method is experimental and not handled on every platform yet.
    *
    * The isolate will send a `null` message on [responsePort] as the last
    * thing before it terminates. It will run no further code after the message
    * has been sent.
    *
    * If the isolate is already dead, no message will be sent.
-   * TODO(lrn): Can we do better? Can the system recognize this message and
+   */
+  /* TODO(lrn): Can we do better? Can the system recognize this message and
    * send a reply if the receiving isolate is dead?
    */
-  void addOnExitListener(SendPort responsePort) {
-    // TODO(lrn): Can we have an internal method that checks if the receiving
-    // isolate of a SendPort is still alive?
-    var message = new List(2)
-        ..[0] = "add-ondone"
-        ..[1] = responsePort;
-    controlPort.send(message);
-  }
+  external void addOnExitListener(SendPort responsePort);
 
   /**
    * 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.
    */
-  void removeOnExitListener(SendPort responsePort) {
-    var message = new List(2)
-        ..[0] = "remove-ondone"
-        ..[1] = responsePort;
-    controlPort.send(message);
-  }
+  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.
    */
-  void setErrorsFatal(bool errorsAreFatal) {
-    var message = new List(3)
-        ..[0] = "set-errors-fatal"
-        ..[1] = terminateCapability
-        ..[2] = errorsAreFatal;
-    controlPort.send(message);
-  }
+  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], [BEFORE_NEXT_EVENT] or
@@ skipping 12 matching lines @@
    *     If more than one such event are scheduled, they are executed in
    *     the order their control messages were received.
    * * `AS_EVENT`: The shutdown does not happen until all prevously sent
    *     non-control messages from the current isolate to the receiving isolate
    *     have been processed.
    *     The kill operation effectively puts the shutdown into the normal event
    *     queue after previously sent messages, and it is affected by any control
    *     messages that affect normal events, including `pause`.
    *     This can be used to wait for a another event to be processed.
    */
-  void kill([int priority = BEFORE_NEXT_EVENT]) {
-    controlPort.send(["kill", terminateCapability, priority]);
-  }
+  external void kill([int priority = BEFORE_NEXT_EVENT]);
 
   /**
    * Request that the isolate send a 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 a `null` response on
    * the response port.
    *
    * The [pingType] must be one of [IMMEDIATE], [BEFORE_NEXT_EVENT] or
    * [AS_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.
    * * `BEFORE_NEXT_EVENT`: The response is scheduled for the next time
    *     control returns to the event loop of the receiving isolate.
    *     If more than one such event are scheduled, they are executed in
    *     the order their control messages were received.
    * * `AS_EVENT`: The response is not sent until all prevously sent
    *     non-control messages from the current isolate to the receiving isolate
    *     have been processed.
    *     The ping effectively puts the response into the normal event queue
    *     after previously sent messages, and it is affected by any control
    *     messages that affect normal events, including `pause`.
    *     This can be used to wait for a another event to be processed.
    */
-  void ping(SendPort responsePort, [int pingType = IMMEDIATE]) {
-    var message = new List(3)
-        ..[0] = "ping"
-        ..[1] = responsePort
-        ..[2] = pingType;
-    controlPort.send(message);
-  }
+  external void ping(SendPort responsePort, [int pingType = 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.
    *
    * Listening using the same port more than once does nothing. It will only
    * get each error once.
    */
-  void addErrorListener(SendPort port) {
-    var message = new List(2)
-        ..[0] = "getErrors"
-        ..[1] = port;
-    controlPort.send(message);
-  }
+  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.
    */
-  void removeErrorListener(SendPort port) {
-    var message = new List(2)
-        ..[0] = "stopErrors"
-        ..[1] = port;
-    controlPort.send(message);
-  }
+  external void removeErrorListener(SendPort port);
 
   /**
    * Returns a broadcast stream of uncaught errors from the isolate.
    *
    * Each error is provided as an error event on the stream.
    *
    * The actual error object and stackTraces will not necessarily
    * be the same object types as in the actual isolate, but they will
    * always have the same [Object.toString] result.
    *
@@ skipping 201 matching lines @@
       : _description = description,
         stackTrace = new _RemoteStackTrace(stackDescription);
   String toString() => _description;
 }
 
 class _RemoteStackTrace implements StackTrace {
   String _trace;
   _RemoteStackTrace(this._trace);
   String toString() => _trace;
 }