Re-enable printing and timers in Dartium isolates

tools/dom/src/native_DOMImplementation.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.
 
 part of html;
 
 class _Property {
   _Property(this.name) :
       _hasValue = false,
       writable = false,
@@ skipping 171 matching lines @@
   static Element getAndValidateNativeType(Type type, String tagName) {
     var element = new Element.tag(tagName);
     if (!isTypeSubclassOf(type, element.runtimeType)) {
       return null;
     }
     return element;
   }
 
   static window() => _blink.Blink_Utils.window();
   static forwardingPrint(String message) => _blink.Blink_Utils.forwardingPrint(message);
+  static void spawnDomFunction(Function f, int replyTo)
+      native "Utils_spawnDomFunction";

[vsm, 2015/02/24 20:29:02]

Actually, we've moved all native methods to the _blink library.  See spawnDomUri
right below.  It'd be more consistent to thread this through in a similar way.

[Alan Knight, 2015/02/26 15:52:19]

Done.

+
   // TODO(vsm): Make this API compatible with spawnUri.  It should also
   // return a Future<Isolate>.
   static spawnDomUri(String uri) => _blink.Blink_Utils.spawnDomUri(uri);
 
   // The following methods were added for debugger integration to make working
   // with the Dart C mirrors API simpler.
   // TODO(jacobr): consider moving them to a separate library.
   // If Dart supported dynamic code injection, we would only inject this code
   // when the debugger is invoked.
 
@@ skipping 298 matching lines @@
    * in user libraries as side effect free.
    */
   static bool _isSideEffectFreeGetter(MethodMirror methodMirror,
       LibraryMirror libraryMirror) {
     // This matches JavaScript behavior. We should consider displaying
     // getters for all dart platform libraries rather than just the DOM
     // libraries.
     return libraryMirror.uri.scheme == 'dart' &&
         SIDE_EFFECT_FREE_LIBRARIES.contains(libraryMirror.uri.toString());
   }
-  
+
   /**
    * Whether we should treat a property as a field for the purposes of the
    * debugger.
    */
   static bool treatPropertyAsField(MethodMirror methodMirror,
       LibraryMirror libraryMirror) {
     return (methodMirror.isGetter || methodMirror.isSetter) &&
           (methodMirror.isSynthetic ||
               _isSideEffectFreeGetter(methodMirror,libraryMirror));
   }
@@ skipping 197 matching lines @@
                   property.getter,
                   property.value,
                   property.hasValue,
                   property.writable,
                   property.isMethod,
                   property.isOwn,
                   property.wasThrown]);
     }
     return ret;
   }
-  
+
   /**
    * Get a property, returning null if the property does not exist.
    * For private property names, we attempt to resolve the property in the
    * context of each library that the property name could be associated with.
    */
   static getObjectPropertySafe(o, String propertyName) {
     var objectMirror = reflect(o);
     var classMirror = objectMirror.type;
     if (propertyName.startsWith("_")) {
-      var attemptedLibraries = new Set<LibraryMirror>(); 
+      var attemptedLibraries = new Set<LibraryMirror>();
       while (classMirror != null) {
         LibraryMirror library = classMirror.owner;
         if (!attemptedLibraries.contains(library)) {
           try {
             return objectMirror.getField(
                 MirrorSystem.getSymbol(propertyName, library)).reflectee;
           } catch (e) { }
           attemptedLibraries.add(library);
         }
         classMirror = classMirror.superclass;
       }
-      return null;     
+      return null;
     }
     try {
       return objectMirror.getField(
           MirrorSystem.getSymbol(propertyName)).reflectee;
     } catch (e) {
       return null;
     }
   }
 
   /**
    * Helper to wrap the inspect method on InjectedScriptHost to provide the
-   * inspect method required for the 
+   * inspect method required for the
    */
   static List consoleApi(host) {
     return [
         "inspect",
         (o) {
           host.inspect(o, null);
           return o;
         },
         "dir",
         window().console.dir,
@@ skipping 114 matching lines @@
   Iterable<String> get keys => _blink.Blink_DOMStringMap.get_keys(this);
   Iterable<String> get values => Maps.getValues(this);
   int get length => Maps.length(this);
   bool get isEmpty => Maps.isEmpty(this);
   bool get isNotEmpty => Maps.isNotEmpty(this);
   void addAll(Map<String, String> other) {
     other.forEach((key, value) => this[key] = value);
   }
 }
 
+// TODO(vsm): Remove DOM isolate code.  This is only used to support
+// printing and timers in background isolates.  Background isolates
+// should just forward to the main DOM isolate instead of requiring a
+// special DOM isolate.

[vsm, 2015/02/24 20:24:19]

Perhaps update this comment to remove once Workers are supported.  At that
point, the isolate can just call native print / timer code I think.

[Alan Knight, 2015/02/26 15:52:19]

Done.

+
+_makeSendPortFuture(spawnRequest) {
+  final completer = new Completer<SendPort>.sync();
+  final port = new ReceivePort();
+  port.listen((result) {
+    completer.complete(result);
+    port.close();
+  });
+  // TODO: SendPort.hashCode is ugly way to access port id.
+  spawnRequest(port.sendPort.hashCode);
+  return completer.future;
+}
+
+Future<SendPort> _spawnDomFunction(Function f) =>
+    _makeSendPortFuture((portId) { _Utils.spawnDomFunction(f, portId); });
+
+final Future<SendPort> __HELPER_ISOLATE_PORT =
+    _spawnDomFunction(_helperIsolateMain);
+
+// Tricky part.
+// Once __HELPER_ISOLATE_PORT gets resolved, it will still delay in .then
+// and to delay Timer.run is used. However, Timer.run will try to register
+// another Timer and here we got stuck: event cannot be posted as then
+// callback is not executed because it's delayed with timer.
+// Therefore once future is resolved, it's unsafe to call .then on it
+// in Timer code.
+SendPort __SEND_PORT;
+
+_sendToHelperIsolate(msg, SendPort replyTo) {
+  if (__SEND_PORT != null) {
+    __SEND_PORT.send([msg, replyTo]);
+  } else {
+    __HELPER_ISOLATE_PORT.then((port) {
+      __SEND_PORT = port;
+      __SEND_PORT.send([msg, replyTo]);
+    });
+  }
+}
+
+final _TIMER_REGISTRY = new Map<SendPort, Timer>();
+
+const _NEW_TIMER = 'NEW_TIMER';
+const _CANCEL_TIMER = 'CANCEL_TIMER';
+const _TIMER_PING = 'TIMER_PING';
+const _PRINT = 'PRINT';
+
+_helperIsolateMain(originalSendPort) {
+  var port = new ReceivePort();
+  originalSendPort.send(port.sendPort);
+  port.listen((args) {
+    var msg = args.first;
+    var replyTo = args.last;
+    final cmd = msg[0];
+    if (cmd == _NEW_TIMER) {
+      final duration = new Duration(milliseconds: msg[1]);
+      bool periodic = msg[2];
+      ping() { replyTo.send(_TIMER_PING); };
+      _TIMER_REGISTRY[replyTo] = periodic ?
+          new Timer.periodic(duration, (_) { ping(); }) :
+          new Timer(duration, ping);
+    } else if (cmd == _CANCEL_TIMER) {
+      _TIMER_REGISTRY.remove(replyTo).cancel();
+    } else if (cmd == _PRINT) {
+      final message = msg[1];
+      // TODO(antonm): we need somehow identify those isolates.
+      print('[From isolate] $message');
+    }
+  });
+}
+
 final _printClosure = (s) => window.console.log(s);
 final _pureIsolatePrintClosure = (s) {
-  throw new UnimplementedError("Printing from a background isolate "
-                               "is not supported in the browser");
+    _sendToHelperIsolate([_PRINT, s], null);
 };
 
 final _forwardingPrintClosure = _Utils.forwardingPrint;
 
 final _uriBaseClosure = () => Uri.parse(window.location.href);
 
 final _pureIsolateUriBaseClosure = () {
   throw new UnimplementedError("Uri.base on a background isolate "
                                "is not supported in the browser");
 };
@@ skipping 28 matching lines @@
   }
 
   bool get isActive => _state != null;
 }
 
 get _timerFactoryClosure =>
     (int milliSeconds, void callback(Timer timer), bool repeating) {
   return new _Timer(milliSeconds, callback, repeating);
 };
 
+class _PureIsolateTimer implements Timer {
+  bool _isActive = true;
+  final ReceivePort _port = new ReceivePort();
+  SendPort _sendPort; // Effectively final.
+
+  //  static SendPort _SEND_PORT;
+
+  _PureIsolateTimer(int milliSeconds, callback, repeating) {
+    _sendPort = _port.sendPort;
+    _port.listen((msg) {
+      assert(msg == _TIMER_PING);
+      _isActive = repeating;
+      callback(this);
+      if (!repeating) _cancel();
+    });
+
+    _send([_NEW_TIMER, milliSeconds, repeating]);
+  }
+
+  void cancel() {
+    _cancel();
+    _send([_CANCEL_TIMER]);
+  }
+
+  void _cancel() {
+    _isActive = false;
+    _port.close();
+  }
+
+  _send(msg) {
+    _sendToHelperIsolate(msg, _sendPort);
+  }
+
+  bool get isActive => _isActive;
+}
+
 get _pureIsolateTimerFactoryClosure =>
     ((int milliSeconds, void callback(Timer time), bool repeating) =>
-  throw new UnimplementedError("Timers on background isolates "
-                               "are not supported in the browser"));
+  new _PureIsolateTimer(milliSeconds, callback, repeating));
 
 class _ScheduleImmediateHelper {
   MutationObserver _observer;
   final DivElement _div = new DivElement();
   Function _callback;
 
   _ScheduleImmediateHelper() {
     // Run in the root-zone as the DOM callback would otherwise execute in the
     // current zone.
     Zone.ROOT.run(() {
@@ skipping 32 matching lines @@
   throw new UnimplementedError("scheduleMicrotask in background isolates "
                                "are not supported in the browser"));
 
 void _initializeCustomElement(Element e) {
   _Utils.initializeCustomElement(e);
 }
 
 // Class for unsupported native browser 'DOM' objects.
 class _UnsupportedBrowserObject extends NativeFieldWrapperClass2 {
 }