Make Dom events run through zone tasks.

tools/dom/src/EventStreamProvider.dart

 // Copyright (c) 2013, 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;
 
 /**
  * A factory to expose DOM events as Streams.
  */
 class EventStreamProvider<T extends Event> {
@@ skipping 101 matching lines @@
    *
    * ## Other resources
    *
    * * [Event Capture](http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-flow-capture)
    *   from the W3C DOM Events specification.
    */
   StreamSubscription<T> capture(void onData(T event));
 }
 
 /**
+ * Task specification for Dom Events.

[Lasse Reichstein Nielsen, 2016/06/07 12:21:44]

Dom -> DOM

[floitsch, 2016/06/10 15:43:58]

Done.

+ */

[Lasse Reichstein Nielsen, 2016/06/07 12:21:44]

I noticed you used /// below. Feel free to use it here too.

[floitsch, 2016/06/10 15:43:58]

done.

+class EventSubscriptionSpecification<T extends Event>
+    implements TaskSpecification {
+  final String name;

[Lasse Reichstein Nielsen, 2016/06/07 12:21:44]

Document the name. What is it? What values will it assume?

[floitsch, 2016/06/10 15:43:58]

Should inherit the documentation from `TaskSpecification`.
I added a @override.

+  final bool isOneShot;

[Lasse Reichstein Nielsen, 2016/06/07 12:21:44]

Document:
/// A one-shot event task is guaranteed to run at most once.

[floitsch, 2016/06/10 15:43:58]

ditto.

+
+  final EventTarget target;
+  final String eventType;

[Lasse Reichstein Nielsen, 2016/06/07 12:21:44]

I assume this is the eventType of the event, so "click" for a click event?

[floitsch, 2016/06/10 15:43:58]

yes.
added a bit of documentation (not a lot, though).

+  // TODO(floitsch): the first generic argument should be 'void'.
+  final ZoneUnaryCallback<dynamic, T> onData;
+  final bool useCapture;
+
+  EventSubscriptionSpecification({this.name, this.isOneShot, this.target,
+      this.eventType, void this.onData(T event), this.useCapture});
+
+  /// Returns a copy of this instance, with every non-null argument replaced
+  /// by the given value.
+  EventSubscriptionSpecification<T> replace(
+      {String name, bool isOneShot, EventTarget target,
+       String eventType, void onData(T event), bool useCapture}) {
+    return new EventSubscriptionSpecification<T>(
+        name: name ?? this.name,
+        isOneShot: isOneShot ?? this.isOneShot,
+        target: target ?? this.target,
+        eventType: eventType ?? this.eventType,
+        onData: onData ?? this.onData,
+        useCapture: useCapture ?? this.useCapture);
+  }
+}
+
+/**
  * Adapter for exposing DOM events as Dart streams.
  */
 class _EventStream<T extends Event> extends Stream<T> {
   final EventTarget _target;
   final String _eventType;
   final bool _useCapture;
+  /// The name that is used in the task specification.
+  final String _name;
+  /// Whether the stream can trigger multiple times.
+  final bool _isOneShot;
 
-  _EventStream(this._target, this._eventType, this._useCapture);
+  _EventStream(this._target, String eventType, this._useCapture,
+      {String name, bool isOneShot: false})
+      : _eventType = eventType,
+        _isOneShot = isOneShot,
+        _name = name ?? "dart.html.event.$eventType";

[Lasse Reichstein Nielsen, 2016/06/07 12:21:44]

That looks potentially expensive if you have many event streams. Would it make
sense to cache the name?

[floitsch, 2016/06/10 15:43:58]

I think the EventStreamProvider (which is a `const` class for all the existing
events) should use the 'name' constructor for the important ones.
Currently the event-providers are generated as follows:

static const EventStreamProvider<Event> checkingEvent = const
EventStreamProvider<Event>('checking');

For the important ones we should just set the name there. (Probably also clean
the names a bit).

 
   // DOM events are inherently multi-subscribers.
   Stream<T> asBroadcastStream({void onListen(StreamSubscription<T> subscription),
                                void onCancel(StreamSubscription<T> subscription)})
       => this;
   bool get isBroadcast => true;
 
   StreamSubscription<T> listen(void onData(T event),
       { Function onError,
         void onDone(),
         bool cancelOnError}) {
 
-    return new _EventStreamSubscription<T>(
-        this._target, this._eventType, onData, this._useCapture);
+    if (identical(Zone.current, Zone.ROOT)) {
+      return new _EventStreamSubscription<T>(
+          this._target, this._eventType, onData, this._useCapture,
+          Zone.current);
+    }
+
+    var specification = new EventSubscriptionSpecification<T>(
+        name: this._name, isOneShot: this._isOneShot,
+        target: this._target, eventType: this._eventType,
+        onData: onData, useCapture: this._useCapture);
+    // We need to wrap the _createStreamSubscription call, since a tear-off
+    // would not bind the generic type 'T'.
+    return Zone.current.createTask((spec, Zone zone) {
+      return _createStreamSubscription/*<T>*/(spec, zone);
+    }, specification);
   }
 }
 
 bool _matchesWithAncestors(Event event, String selector) {
   var target = event.target;
   return target is Element ? target.matchesWithAncestors(selector) : false;
 }
 
 /**
  * Adapter for exposing DOM Element events as streams, while also allowing
  * event delegation.
  */
 class _ElementEventStreamImpl<T extends Event> extends _EventStream<T>
     implements ElementStream<T> {
-  _ElementEventStreamImpl(target, eventType, useCapture) :
-      super(target, eventType, useCapture);
+  _ElementEventStreamImpl(target, eventType, useCapture,
+      {String name, bool isOneShot: false}) :
+      super(target, eventType, useCapture, name: name, isOneShot: isOneShot);
 
   Stream<T> matches(String selector) => this.where(
       (event) => _matchesWithAncestors(event, selector)).map((e) {
         e._selector = selector;
         return e;
       });
 
-  StreamSubscription<T> capture(void onData(T event)) =>
-    new _EventStreamSubscription<T>(
-        this._target, this._eventType, onData, true);
+  StreamSubscription<T> capture(void onData(T event)) {
+
+    if (identical(Zone.current, Zone.ROOT)) {
+      return new _EventStreamSubscription<T>(
+          this._target, this._eventType, onData, true, Zone.current);
+    }
+
+    var specification = new EventSubscriptionSpecification<T>(
+        name: this._name, isOneShot: this._isOneShot,
+        target: this._target, eventType: this._eventType,
+        onData: onData, useCapture: true);
+    // We need to wrap the _createStreamSubscription call, since a tear-off
+    // would not bind the generic type 'T'.
+    return Zone.current.createTask((spec, Zone zone) {
+      return _createStreamSubscription/*<T>*/(spec, zone);
+    }, specification);
+  }

[Lasse Reichstein Nielsen, 2016/06/07 12:21:44]

This function is almost identical to listen above.
Maybe extract it into a helper function in the superclass that only takes onData
and useCapture as parameters? (I think that's the only difference between the
two functions).

[floitsch, 2016/06/10 15:43:58]

Done.

 }
 
 /**
  * Adapter for exposing events on a collection of DOM Elements as streams,
  * while also allowing event delegation.
  */
 class _ElementListEventStreamImpl<T extends Event> extends Stream<T>
     implements ElementStream<T> {
   final Iterable<Element> _targetList;
   final bool _useCapture;
@@ skipping 28 matching lines @@
     }
     return pool.stream.listen(onData);
   }
 
   Stream<T> asBroadcastStream({void onListen(StreamSubscription<T> subscription),
                                void onCancel(StreamSubscription<T> subscription)})
       => this;
   bool get isBroadcast => true;
 }
 
-// We would like this to just be EventListener<T> but that typdef cannot
+StreamSubscription/*<T>*/ _createStreamSubscription/*<T>*/(
+    EventSubscriptionSpecification/*<T>*/ spec, Zone zone) {
+  return new _EventStreamSubscription/*<T>*/(spec.target, spec.eventType,
+      spec.onData, spec.useCapture, zone);
+}
+
+// We would like this to just be EventListener<T> but that typedef cannot
 // use generics until dartbug/26276 is fixed.
 typedef _EventListener<T extends Event>(T event);
 
 class _EventStreamSubscription<T extends Event> extends StreamSubscription<T> {
   int _pauseCount = 0;
   EventTarget _target;
   final String _eventType;
   EventListener _onData;
+  EventListener _domCallback;
   final bool _useCapture;
+  final Zone _zone;
 
   // TODO(jacobr): for full strong mode correctness we should write
-  // _onData = onData == null ? null : _wrapZone/*<Event, dynamic>*/((e) => onData(e as T))
+  // _onData = onData == null ? null : _wrapZone/*<dynamic, Event>*/((e) => onData(e as T))
   // but that breaks 114 co19 tests as well as multiple html tests as it is reasonable
   // to pass the wrong type of event object to an event listener as part of a
   // test.
   _EventStreamSubscription(this._target, this._eventType, void onData(T event),
-      this._useCapture) : _onData = _wrapZone/*<Event, dynamic>*/(onData) {
+      this._useCapture, Zone zone)
+      : _zone = zone,
+        _onData = _registerZone/*<dynamic, Event>*/(zone, onData) {
     _tryResume();
   }
 
   Future cancel() {
     if (_canceled) return null;
 
     _unlisten();
     // Clear out the target to indicate this is complete.
     _target = null;
     _onData = null;
     return null;
   }
 
   bool get _canceled => _target == null;
 
   void onData(void handleData(T event)) {
     if (_canceled) {
       throw new StateError("Subscription has been canceled.");
     }
     // Remove current event listener.
     _unlisten();
-    _onData = _wrapZone/*<Event, dynamic>*/(handleData);
+    _onData = _registerZone/*<dynamic, Event>*/(_zone, handleData);
     _tryResume();
   }
 
   /// Has no effect.
   void onError(Function handleError) {}
 
   /// Has no effect.
   void onDone(void handleDone()) {}
 
   void pause([Future resumeSignal]) {
     if (_canceled) return;
     ++_pauseCount;
     _unlisten();
 
     if (resumeSignal != null) {
       resumeSignal.whenComplete(resume);
     }
   }
 
   bool get isPaused => _pauseCount > 0;
 
   void resume() {
     if (_canceled || !isPaused) return;
     --_pauseCount;
     _tryResume();
   }
 
   void _tryResume() {
-    if (_onData != null && !isPaused) {
-      _target.addEventListener(_eventType, _onData, _useCapture);
+    if (_onData == null || isPaused) return;
+    if (identical(_zone, Zone.ROOT)) {
+      _domCallback = _onData;
+    } else {
+      _domCallback = (event) {
+        _zone.runTask(_runEventNotification, this, event);
+      };
     }
+    _target.addEventListener(_eventType, _domCallback, _useCapture);
+  }
+
+  static void _runEventNotification/*<T>*/(
+      _EventStreamSubscription/*<T>*/ subscription, /*=T*/ event) {
+    subscription._onData(event);
   }
 
   void _unlisten() {
     if (_onData != null) {
-      _target.removeEventListener(_eventType, _onData, _useCapture);
+      _target.removeEventListener(_eventType, _domCallback, _useCapture);
     }
   }
 
   Future/*<E>*/ asFuture/*<E>*/([var/*=E*/ futureValue]) {
     // We just need a future that will never succeed or fail.
     var completer = new Completer/*<E>*/();
     return completer.future;
   }
 }
 
@@ skipping 133 matching lines @@
     return new _ElementListEventStreamImpl<T>(e, _eventTypeGetter(e), useCapture);
   }
 
   String getEventType(EventTarget target) {
     return _eventTypeGetter(target);
   }
 
   String get _eventType =>
       throw new UnsupportedError('Access type through getEventType method.');
 }