Update dom streams with new signatures.

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;
 
 /**
  * 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;
 
   _EventStream(this._target, this._eventType, this._useCapture);
 
   // DOM events are inherently multi-subscribers.
   Stream<T> asBroadcastStream({void onListen(StreamSubscription subscription),
                                void onCancel(StreamSubscription subscription)})
       => this;
   bool get isBroadcast => true;
 
   StreamSubscription<T> listen(void onData(T event),
-      { void onError(error),
+      { Function onError,
         void onDone(),
         bool cancelOnError}) {
 
     return new _EventStreamSubscription<T>(
         this._target, this._eventType, onData, this._useCapture);
   }
 }
 
 /** A specialized Stream available to [Element]s to enable event delegation. */
 abstract class ElementStream<T extends Event> implements Stream<T> {
@@ skipping 42 matching lines @@
   }
 
   Stream<T> matches(String selector) => this.where(
       (event) => event.target.matchesWithAncestors(selector)).map((e) {
         e._selector = selector;
         return e;
       });
 
   // Delegate all regular Stream behavor to our wrapped Stream.
   StreamSubscription<T> listen(void onData(T event),
-      { void onError(error),
+      { Function onError,
         void onDone(),
         bool cancelOnError}) =>
       _stream.listen(onData, onError: onError, onDone: onDone,
           cancelOnError: cancelOnError);
   Stream<T> asBroadcastStream({void onListen(StreamSubscription subscription),
                                void onCancel(StreamSubscription subscription)})
       => _stream;
   bool get isBroadcast => true;
 }
 
@@ skipping 15 matching lines @@
   /** The type of event this stream is providing (e.g. "keydown"). */
   String _type;
 
   _CustomEventStreamImpl(String type) {
     _type = type;
     _streamController = new StreamController.broadcast(sync: true);
   }
 
   // Delegate all regular Stream behavior to our wrapped Stream.
   StreamSubscription<T> listen(void onData(T event),
-      { void onError(error),
+      { Function onError,
         void onDone(),
         bool cancelOnError}) {
     return _streamController.stream.listen(onData, onError: onError,
         onDone: onDone, cancelOnError: cancelOnError);
   }
 
   Stream<T> asBroadcastStream({void onListen(StreamSubscription subscription),
                                void onCancel(StreamSubscription subscription)})
       => _streamController.stream;
 
@@ skipping 108 matching lines @@
       throw new StateError("Subscription has been canceled.");
     }
     // Remove current event listener.
     _unlisten();
 
     _onData = _wrapZone(handleData);
     _tryResume();
   }
 
   /// Has no effect.
-  void onError(void handleError(error)) {}
+  void onError(Function handleError) {}
 
   /// Has no effect.
   void onDone(void handleDone()) {}
 
   void pause([Future resumeSignal]) {
     if (_canceled) return;
     ++_pauseCount;
     _unlisten();
 
     if (resumeSignal != null) {
@@ skipping 125 matching lines @@
 
   ElementStream<T> _forElementList(ElementList e,
       {bool useCapture: false}) {
     return new _ElementListEventStreamImpl(e, _eventTypeGetter(e), useCapture);
   }
 
   String getEventType(EventTarget target) {
     return _eventTypeGetter(target);
   }
 }