frog isolate fixes: minor changes to the isolate library + architecture.py

frog/lib/isolate.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.
 
 /**
  * A native object that is shared across isolates. This object is visible to all
  * isolates running on the same worker (either UI or background web worker).
  *
  * This is code that is intended to 'escape' the isolate boundaries in order to
  * implement the semantics of friendly isolates in JavaScript. Without this we
@@ skipping 148 matching lines @@
   } else {
     // Nothing more to do.
     return message;
   }
 }
 
 /** Default worker. */
 class MainWorker {
   int id = 0;
   void postMessage(msg) native "return \$globalThis.postMessage(msg);";
-  void onmessage(f) native "\$globalThis.onmessage = f;";
+  void set onmessage(f) native "\$globalThis.onmessage = f;";
   void terminate() {}
 }
 
+class _Worker native "*Worker" {

[Jennifer Messerly, 2011/12/22 19:49:44]

I'd add a comment here that this type is defined in dart:dom, but we don't want
to depend on that from corelib, and instead we'll do a runtime tests to see if
Worker is present.

+  get id() native "return this.id;";
+  void set id(i) native "this.id = i;";
+  void set onmessage(f) native "this.onmessage = f;";
+  void postMessage(msg) native "return this.postMessage(msg);";
+}
+
 /** Context information tracked for each isolate. */
 class IsolateContext {
   /** Current isolate id. */
   int id;
 
   /** Registry of receive ports currently active on this isolate. */
   Map<int, ReceivePort> ports;
 
   /** Holds isolate globals (statics and top-level properties). */
   var isolateStatics; // native object containing all globals of an isolate.
@@ skipping 13 matching lines @@
    */
   void eval(Function code) {
     var old = _globalState.currentContext;
     _globalState.currentContext = this;
     this._setGlobals();
     var result = null;
     try {
       result = code();
     } finally {
       _globalState.currentContext = old;
-      old._setGlobals();
+      if (old != null) old._setGlobals();
     }
     return result;
   }
 
   void _setGlobals() native @'$globals = this.isolateStatics;';
 
   /** Lookup a port registered for this isolate. */
   ReceivePort lookup(int id) => ports[id];
 
   /** Register a port on this isolate. */
@@ skipping 68 matching lines @@
   /**
    * Call [_runHelper] but ensure that worker exceptions are propragated. Note
    * this is called from JavaScript (see $wrap_call in corejs.dart).
    */
   void run() {
     if (!_globalState.isWorker) {
       _runHelper();
     } else {
       try {
         _runHelper();
-      } catch(e) {
-        // TODO(floitsch): try to send stack-trace to the other side.
+      } catch(var e, var trace) {

[Jennifer Messerly, 2011/12/22 19:49:44]

Is trace actually working? if so ... that's cool :)
I wonder if we'll want to send the two objects separately.

         _globalState.mainWorker.postMessage(_serializeMessage(
-            {'command': 'error', 'msg': "" + e }));
+            {'command': 'error', 'msg': '$e\n$trace' }));
       }
     }
   }
 }
 
 /** An event in the top-level event queue. */
 class IsolateEvent {
   IsolateContext isolate;
   Function fn;
   String message;
@@ skipping 174 matching lines @@
     if (!src) {
       // TODO()
       src = "FIXME:5407062" + "_" + Math.random().toString();
       if (script) script.src = src;
     }
     IsolateNatives._thisScriptCache = src;
     return src;
   """;
 
   /** Starts a new worker with the given URL. */
-  static _newWorker(url) native "return new Worker(url)";
+  static _Worker _newWorker(url) native "return new Worker(url);";

[Jennifer Messerly, 2011/12/22 19:49:44]

we aren't very consistent about it, but personally I've been trying to omit the
semicolons ... saves a few bytes :). (although any decent minifier should do
that).

 
   /**
    * Spawns an isolate in a worker. [factoryName] is the Javascript constructor
    * name for the isolate entry point class.
    */
   static void _spawnWorker(factoryName, serializedReplyPort) {
-    var worker = _newWorker(_thisScript);
-    // TODO(sigmund): make this work.
-    worker.onmessage = function(e) {
-      _processWorkerMessage(worker, e);
-    };
+    final worker = _newWorker(_thisScript);

[Jennifer Messerly, 2011/12/22 19:49:44]

Are you using "final" to avoid dynamic dispatch? If so -- I'd put in an explicit
_Worker type, and add a comment that something is wrong in the dispatch.

unless you were just trying to make the code more clear in which case, I like
using "final" :)

+    worker.onmessage = (e) { _processWorkerMessage(worker, e); };
     var workerId = _globalState.nextWorkerId++;
     // We also store the id on the worker itself so that we can unregister it.
     worker.id = workerId;
     _globalState.workers[workerId] = worker;
     worker.postMessage(_serializeMessage({
       'command': 'start',
       'id': workerId,
       'replyTo': serializedReplyPort,
       'factoryName': factoryName }));
   }
@@ skipping 141 matching lines @@
       worker.postMessage(_serializeMessage({
           'command': 'message',
           'workerId': workerId,
           'isolateId': isolateId,
           'portId': receivePortId,
           'msg': message,
           'replyTo': replyTo }));
     }
   }
 }