Remove old isolate API and update all code in the repository to use

lib/isolate/dart2js/isolateimpl.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.
 
 /**
  * Concepts used here:
  *
  * "manager" - A manager contains one or more isolates, schedules their
  * execution, and performs other plumbing on their behalf.  The isolate
  * present at the creation of the manager is designated as its "root isolate".
@@ skipping 34 matching lines @@
   }
   return _lazyPort;
 }
 
 SendPort _spawnFunction(void topLevelFunction()) {
   final name = _IsolateNatives._getJSFunctionName(topLevelFunction);
   if (name == null) {
     throw new UnsupportedOperationException(
         "only top-level functions can be spawned.");
   }
-  return _IsolateNatives._spawn2(name, null, false);
+  return _IsolateNatives._spawn(name, null, false);
 }
 
 SendPort _spawnUri(String uri) {
-  return _IsolateNatives._spawn2(null, uri, false);
+  return _IsolateNatives._spawn(null, uri, false);
 }
 
 /** State associated with the current manager. See [globalState]. */
 // TODO(sigmund): split in multiple classes: global, thread, main-worker states?
 class _Manager {
 
   /** Next available isolate id within this [_Manager]. */
   int nextIsolateId = 0;
 
   /** id assigned to this [_Manager]. */
@@ skipping 282 matching lines @@
   void set onmessage(f) native "this.onmessage = f;";
   void postMessage(msg) native "return this.postMessage(msg);";
   // terminate() is implemented by Worker.
   abstract void terminate();
 }
 
 final String _SPAWNED_SIGNAL = "spawned";
 
 class _IsolateNatives {
 
-  /** JavaScript-specific implementation to spawn an isolate. */
-  static Future<SendPort> spawn(Isolate isolate, bool isLight) {
-    Completer<SendPort> completer = new Completer<SendPort>();
-    ReceivePort port = new ReceivePort();
-    port.receive((msg, SendPort replyPort) {
-      port.close();
-      assert(msg == _SPAWNED_SIGNAL);
-      completer.complete(replyPort);
-    });
-
-    // TODO(floitsch): throw exception if isolate's class doesn't have a
-    // default constructor.
-    if (_globalState.useWorkers && !isLight) {
-      _startWorker(isolate, port.toSendPort());
-    } else {
-      _startNonWorker(isolate, port.toSendPort());
-    }
-
-    return completer.future;
-  }
-
-  static SendPort _startWorker(Isolate runnable, SendPort replyPort) {
-    var factoryName = _getJSConstructorName(runnable);
-    if (_globalState.isWorker) {
-      _globalState.mainManager.postMessage(_serializeMessage({
-          'command': 'spawn-worker',
-          'factoryName': factoryName,
-          'replyPort': _serializeMessage(replyPort)}));
-    } else {
-      _spawnWorker(factoryName, _serializeMessage(replyPort));
-    }
-  }
-
   /**
    * The src url for the script tag that loaded this code. Used to create
    * JavaScript workers.
    */
   static String get _thisScript() native @"return $thisScriptUrl";
 
   /** Starts a new worker with the given URL. */
   static _WorkerStub _newWorker(url) native "return new Worker(url);";
 
   /**
-   * Spawns an isolate in a worker. [factoryName] is the Javascript constructor
-   * name for the isolate entry point class.
-   */
-  static void _spawnWorker(factoryName, serializedReplyPort) {
-    final worker = _newWorker(_thisScript);
-    worker.onmessage = (e) { _processWorkerMessage(worker, e); };
-    var workerId = _globalState.nextManagerId++;
-    // We also store the id on the worker itself so that we can unregister it.
-    worker.id = workerId;
-    _globalState.managers[workerId] = worker;
-    worker.postMessage(_serializeMessage({
-      'command': 'start',
-      'id': workerId,
-      'replyTo': serializedReplyPort,
-      'factoryName': factoryName }));
-  }
-
-  /**
    * Assume that [e] is a browser message event and extract its message data.
    * We don't import the dom explicitly so, when workers are disabled, this
    * library can also run on top of nodejs.
    */
   static _getEventData(e) native "return e.data";
 
   /**
    * Process messages on a worker, either to control the worker instance or to
    * pass messages along to the isolate running in the worker.
    */
   static void _processWorkerMessage(sender, e) {
     var msg = _deserializeMessage(_getEventData(e));
     switch (msg['command']) {
-      // TODO(sigmund): delete after we migrate to the new API
       case 'start':
         _globalState.currentManagerId = msg['id'];
-        var runnerObject =
-            _allocate(_getJSConstructorFromName(msg['factoryName']));
-        var serializedReplyTo = msg['replyTo'];
-        _globalState.topEventLoop.enqueue(new _IsolateContext(), function() {
-          var replyTo = _deserializeMessage(serializedReplyTo);
-          _startIsolate(runnerObject, replyTo);
-        }, 'worker-start');
-        _globalState.topEventLoop.run();
-        break;
-      case 'start2':
-        _globalState.currentManagerId = msg['id'];
         Function entryPoint = _getJSFunctionFromName(msg['functionName']);
         var replyTo = _deserializeMessage(msg['replyTo']);
         _globalState.topEventLoop.enqueue(new _IsolateContext(), function() {
-          _startIsolate2(entryPoint, replyTo);
+          _startIsolate(entryPoint, replyTo);
         }, 'worker-start');
         _globalState.topEventLoop.run();
         break;
-      // TODO(sigmund): delete after we migrate to the new API
       case 'spawn-worker':
-        _spawnWorker(msg['factoryName'], msg['replyPort']);
-        break;
-      case 'spawn-worker2':
-        _spawnWorker2(msg['functionName'], msg['uri'], msg['replyPort']);
+        _spawnWorker(msg['functionName'], msg['uri'], msg['replyPort']);
         break;
       case 'message':
         msg['port'].send(msg['msg'], msg['replyTo']);
         _globalState.topEventLoop.run();
         break;
       case 'close':
         _log("Closing Worker");
         _globalState.managers.remove(sender.id);
         sender.terminate();
         _globalState.topEventLoop.run();
@@ skipping 23 matching lines @@
       try {
         _consoleLog(msg);
       } catch(var e, var trace) {
         throw new Exception(trace);
       }
     }
   }
 
   static void _consoleLog(msg) native "\$globalThis.console.log(msg);";
 
-
   /**
    * Extract the constructor of runnable, so it can be allocated in another
    * isolate.
    */
   static Dynamic _getJSConstructor(Isolate runnable) native """
     return runnable.constructor;
   """;
 
   /** Extract the constructor name of a runnable */
   // TODO(sigmund): find a browser-generic way to support this.
@@ skipping 14 matching lines @@
    * Get a string name for the function, if possible.  The result for
    * anonymous functions is browser-dependent -- it may be "" or "anonymous"
    * but you should probably not count on this.
    */
   static String _getJSFunctionName(Function f)
     native @"return f.$name || (void 0);";
 
   /** Create a new JavaScript object instance given its constructor. */
   static Dynamic _allocate(var ctor) native "return new ctor();";
 
-  /** Starts a non-worker isolate. */
-  static SendPort _startNonWorker(Isolate runnable, SendPort replyTo) {
-    // Spawn a new isolate and create the receive port in it.
-    final spawned = new _IsolateContext();
-
-    // Instead of just running the provided runnable, we create a
-    // new cloned instance of it with a fresh state in the spawned
-    // isolate. This way, we do not get cross-isolate references
-    // through the runnable.
-    final ctor = _getJSConstructor(runnable);
-    _globalState.topEventLoop.enqueue(spawned, function() {
-      _startIsolate(_allocate(ctor), replyTo);
-    }, 'nonworker start');
-  }
-
-  /** Given a ready-to-start runnable, start running it. */
-  static void _startIsolate(Isolate isolate, SendPort replyTo) {
-    _fillStatics(_globalState.currentContext);
-    ReceivePort port = new ReceivePort();
-    replyTo.send(_SPAWNED_SIGNAL, port.toSendPort());
-    isolate._run(port);
-  }
-
   // TODO(sigmund): clean up above, after we make the new API the default:
 
-  static _spawn2(String functionName, String uri, bool isLight) {
+  static _spawn(String functionName, String uri, bool isLight) {
     Completer<SendPort> completer = new Completer<SendPort>();
     ReceivePort port = new ReceivePort();
     port.receive((msg, SendPort replyPort) {
       port.close();
       assert(msg == _SPAWNED_SIGNAL);
       completer.complete(replyPort);
     });
 
     SendPort signalReply = port.toSendPort();
 
     if (_globalState.useWorkers && !isLight) {
-      _startWorker2(functionName, uri, signalReply);
+      _startWorker(functionName, uri, signalReply);
     } else {
-      _startNonWorker2(functionName, uri, signalReply);
+      _startNonWorker(functionName, uri, signalReply);
     }
     return new _BufferingSendPort(
         _globalState.currentContext.id, completer.future);
   }
 
-  static SendPort _startWorker2(
+  static SendPort _startWorker(
       String functionName, String uri, SendPort replyPort) {
     if (_globalState.isWorker) {
       _globalState.mainManager.postMessage(_serializeMessage({
-          'command': 'spawn-worker2',
+          'command': 'spawn-worker',
           'functionName': functionName,
           'uri': uri,
           'replyPort': replyPort}));
     } else {
-      _spawnWorker2(functionName, uri, replyPort);
+      _spawnWorker(functionName, uri, replyPort);
     }
   }
 
-  static SendPort _startNonWorker2(
+  static SendPort _startNonWorker(
       String functionName, String uri, SendPort replyPort) {
     // TODO(eub): support IE9 using an iframe -- Dart issue 1702.
     if (uri != null) throw new UnsupportedOperationException(
             "Currently spawnUri is not supported without web workers.");
     _globalState.topEventLoop.enqueue(new _IsolateContext(), function() {
       final func = _getJSFunctionFromName(functionName);
-      _startIsolate2(func, replyPort);
+      _startIsolate(func, replyPort);
     }, 'nonworker start');
   }
 
-  static void _startIsolate2(Function topLevel, SendPort replyTo) {
+  static void _startIsolate(Function topLevel, SendPort replyTo) {
     _fillStatics(_globalState.currentContext);
     _lazyPort = new ReceivePort();
     replyTo.send(_SPAWNED_SIGNAL, port.toSendPort());
     topLevel();
   }
 
   /**
    * Spawns an isolate in a worker. [factoryName] is the Javascript constructor
    * name for the isolate entry point class.
    */
-  static void _spawnWorker2(functionName, uri, replyPort) {
+  static void _spawnWorker(functionName, uri, replyPort) {
     if (functionName == null) functionName = 'main';
     if (uri == null) uri = _thisScript;
     if (!(new Uri.fromString(uri).isAbsolute())) {
       // The constructor of dom workers requires an absolute URL. If we use a
       // relative path we will get a DOM exception.
       String prefix = _thisScript.substring(0, _thisScript.lastIndexOf('/'));
       uri = "$prefix/$uri";
     }
     final worker = _newWorker(uri);
     worker.onmessage = (e) { _processWorkerMessage(worker, e); };
     var workerId = _globalState.nextManagerId++;
     // We also store the id on the worker itself so that we can unregister it.
     worker.id = workerId;
     _globalState.managers[workerId] = worker;
     worker.postMessage(_serializeMessage({
-      'command': 'start2',
+      'command': 'start',
       'id': workerId,
       // Note: we serialize replyPort twice because the child worker needs to
       // first deserialize the worker id, before it can correctly deserialize
       // the port (port deserialization is sensitive to what is the current
       // workerId).
       'replyTo': _serializeMessage(replyPort),
       'functionName': functionName }));
   }
 }