Make new StreamController be async by default.

sdk/lib/html/dart2js/html_dart2js.dart

 /// The Dart HTML library.
 library dart.dom.html;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:_collection-dev' hide Symbol;
 import 'dart:html_common';
 import 'dart:indexed_db';
 import 'dart:isolate';
 import 'dart:json' as json;
@@ skipping 10630 matching lines @@
     }
     if (timeout != null) {
       options['timeout'] = timeout.inMilliseconds;
     }
     if (maximumAge != null) {
       options['maximumAge'] = maximumAge.inMilliseconds;
     }
 
     int watchId;
     var controller;
-    controller = new StreamController<Geoposition>(
+    controller = new StreamController<Geoposition>(sync: true,
       onListen: () {
         assert(watchId == null);
         watchId = $dom_watchPosition(
             (position) {
               controller.add(_ensurePosition(position));
             },
             (error) {
               controller.addError(error);
             },
             options);
@@ skipping 9717 matching lines @@
    * should not be used in your code.
    *
    * This event is fired whenever a template is instantiated via
    * [createInstance].
    */
   // TODO(rafaelw): This is a hack, and is neccesary for the polyfill
   // because custom elements are not upgraded during clone()
   @Experimental
   static Stream<DocumentFragment> get instanceCreated {
     if (_instanceCreated == null) {
-      _instanceCreated = new StreamController<DocumentFragment>();
+      _instanceCreated = new StreamController<DocumentFragment>(sync: true);
     }
     return _instanceCreated.stream;
   }
 
   /**
    * Ensures proper API and content model for template elements.
    *
    * [instanceRef] can be used to set the [Element.ref] property of [template],
    * and use the ref's content will be used as source when createInstance() is
    * invoked.
@@ skipping 2905 matching lines @@
   }
 }
 
 class _BeforeUnloadEventStreamProvider implements
     EventStreamProvider<BeforeUnloadEvent> {
   final String _eventType;
 
   const _BeforeUnloadEventStreamProvider(this._eventType);
 
   Stream<BeforeUnloadEvent> forTarget(EventTarget e, {bool useCapture: false}) {
-    var controller = new StreamController();
+    var controller = new StreamController(sync: true);
     var stream = new _EventStream(e, _eventType, useCapture);
     stream.listen((event) {
       var wrapped = new _BeforeUnloadEvent(event);
       controller.add(wrapped);
       return wrapped.returnValue;
     });
 
     return controller.stream;
   }
 
@@ skipping 2351 matching lines @@
   /** The type of KeyEvent we are tracking (keyup, keydown, keypress). */
   final String _type;
 
   /** The element we are watching for events to happen on. */
   final EventTarget _target;
 
   // The distance to shift from upper case alphabet Roman letters to lower case.
   static final int _ROMAN_ALPHABET_OFFSET = "a".codeUnits[0] - "A".codeUnits[0];
 
   /** Controller to produce KeyEvents for the stream. */
-  final StreamController _controller = new StreamController();
+  final StreamController _controller = new StreamController(sync: true);
 
   static const _EVENT_TYPE = 'KeyEvent';
 
   /**
    * An enumeration of key identifiers currently part of the W3C draft for DOM3
    * and their mappings to keyCodes.
    * http://www.w3.org/TR/DOM-Level-3-Events/keyset.html#KeySet-Set
    */
   static const Map<String, int> _keyIdentifier = const {
     'Up': KeyCode.UP,
@@ skipping 48 matching lines @@
    * KeyboardEvent controller.
    */
   _KeyboardEventHandler(this._type) :
     _target = null, super(_EVENT_TYPE) {
   }
 
   /**
    * Hook up all event listeners under the covers so we can estimate keycodes
    * and charcodes when they are not provided.
    */
-  _KeyboardEventHandler.initializeAllEventListeners(this._type, this._target) : 
+  _KeyboardEventHandler.initializeAllEventListeners(this._type, this._target) :
     super(_EVENT_TYPE) {
     Element.keyDownEvent.forTarget(_target, useCapture: true).listen(
         processKeyDown);
     Element.keyPressEvent.forTarget(_target, useCapture: true).listen(
         processKeyPress);
     Element.keyUpEvent.forTarget(_target, useCapture: true).listen(
         processKeyUp);
   }
 
   /**
@@ skipping 1124 matching lines @@
    * Observes [path] on [object] for changes. This returns an object that can be
    * used to get the changes and get/set the value at this path.
    * See [PathObserver.values] and [PathObserver.value].
    */
   PathObserver(this.object, String path)
     : path = path, _isValid = _isPathValid(path) {
 
     // TODO(jmesserly): if the path is empty, or the object is! Observable, we
     // can optimize the PathObserver to be more lightweight.
 
-    _values = new StreamController.broadcast(onListen: _observe,
+    _values = new StreamController.broadcast(sync: true,
+                                             onListen: _observe,
                                              onCancel: _unobserve);
 
     if (_isValid) {
       var segments = [];
       for (var segment in path.trim().split('.')) {
         if (segment == '') continue;
         var index = int.parse(segment, onError: (_) {});
         segments.add(index != null ? index : new Symbol(segment));
       }
 
@@ skipping 2436 matching lines @@
       _position = nextPosition;
       return true;
     }
     _current = null;
     _position = _array.length;
     return false;
   }
 
   T get current => _current;
 }