Add Event delegation to Elements and groups of elements.

sdk/lib/html/dartium/html_dartium.dart

Index: sdk/lib/html/dartium/html_dartium.dart
diff --git a/sdk/lib/html/dartium/html_dartium.dart b/sdk/lib/html/dartium/html_dartium.dart
index 555a0d096add4228a1103dd1d6107c04a630c765..c7068f954731da5f11c143b4a0479b4dbe430791 100644
--- a/sdk/lib/html/dartium/html_dartium.dart
+++ b/sdk/lib/html/dartium/html_dartium.dart
@@ -790,51 +790,51 @@ class BodyElement extends _HTMLElement {
 
   @DomName('HTMLBodyElement.onblur')
   @DocsEditable()
-  Stream<Event> get onBlur => blurEvent.forTarget(this);
+  ElementStream<Event> get onBlur => blurEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onerror')
   @DocsEditable()
-  Stream<Event> get onError => errorEvent.forTarget(this);
+  ElementStream<Event> get onError => errorEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onfocus')
   @DocsEditable()
-  Stream<Event> get onFocus => focusEvent.forTarget(this);
+  ElementStream<Event> get onFocus => focusEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onhashchange')
   @DocsEditable()
-  Stream<Event> get onHashChange => hashChangeEvent.forTarget(this);
+  ElementStream<Event> get onHashChange => hashChangeEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onload')
   @DocsEditable()
-  Stream<Event> get onLoad => loadEvent.forTarget(this);
+  ElementStream<Event> get onLoad => loadEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onmessage')
   @DocsEditable()
-  Stream<MessageEvent> get onMessage => messageEvent.forTarget(this);
+  ElementStream<MessageEvent> get onMessage => messageEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onoffline')
   @DocsEditable()
-  Stream<Event> get onOffline => offlineEvent.forTarget(this);
+  ElementStream<Event> get onOffline => offlineEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.ononline')
   @DocsEditable()
-  Stream<Event> get onOnline => onlineEvent.forTarget(this);
+  ElementStream<Event> get onOnline => onlineEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onpopstate')
   @DocsEditable()
-  Stream<PopStateEvent> get onPopState => popStateEvent.forTarget(this);
+  ElementStream<PopStateEvent> get onPopState => popStateEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onresize')
   @DocsEditable()
-  Stream<Event> get onResize => resizeEvent.forTarget(this);
+  ElementStream<Event> get onResize => resizeEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onstorage')
   @DocsEditable()
-  Stream<StorageEvent> get onStorage => storageEvent.forTarget(this);
+  ElementStream<StorageEvent> get onStorage => storageEvent.forElementTarget(this);
 
   @DomName('HTMLBodyElement.onunload')
   @DocsEditable()
-  Stream<Event> get onUnload => unloadEvent.forTarget(this);
+  ElementStream<Event> get onUnload => unloadEvent.forElementTarget(this);
 
 }
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
@@ -1099,11 +1099,11 @@ class CanvasElement extends _HTMLElement implements CanvasImageSource {
 
   @DomName('HTMLCanvasElement.onwebglcontextlost')
   @DocsEditable()
-  Stream<gl.ContextEvent> get onWebGlContextLost => webGlContextLostEvent.forTarget(this);
+  ElementStream<gl.ContextEvent> get onWebGlContextLost => webGlContextLostEvent.forElementTarget(this);
 
   @DomName('HTMLCanvasElement.onwebglcontextrestored')
   @DocsEditable()
-  Stream<gl.ContextEvent> get onWebGlContextRestored => webGlContextRestoredEvent.forTarget(this);
+  ElementStream<gl.ContextEvent> get onWebGlContextRestored => webGlContextRestoredEvent.forElementTarget(this);
 
   /** An API for drawing on this canvas. */
   CanvasRenderingContext2D get context2D => getContext('2d');
@@ -8570,6 +8570,107 @@ abstract class ElementList<T extends Element> extends ListBase<T> {
    */
   @Experimental()
   CssRect get marginEdge;
+
+  @DomName('Element.onabort')
+  ElementStream<Event> get onAbort;
+  @DomName('Element.onbeforecopy')
+  ElementStream<Event> get onBeforeCopy;
+  @DomName('Element.onbeforecut')
+  ElementStream<Event> get onBeforeCut;
+  @DomName('Element.onbeforepaste')
+  ElementStream<Event> get onBeforePaste;
+  @DomName('Element.onblur')
+  ElementStream<Event> get onBlur;
+  @DomName('Element.onchange')
+  ElementStream<Event> get onChange;
+  @DomName('Element.onclick')
+  ElementStream<MouseEvent> get onClick;
+  @DomName('Element.oncontextmenu')
+  ElementStream<MouseEvent> get onContextMenu;
+  @DomName('Element.oncopy')
+  ElementStream<Event> get onCopy;
+  @DomName('Element.oncut')
+  ElementStream<Event> get onCut;
+  @DomName('Element.ondblclick')
+  ElementStream<Event> get onDoubleClick;
+  @DomName('Element.ondrag')
+  ElementStream<MouseEvent> get onDrag;
+  @DomName('Element.ondragend')
+  ElementStream<MouseEvent> get onDragEnd;
+  @DomName('Element.ondragenter')
+  ElementStream<MouseEvent> get onDragEnter;
+  @DomName('Element.ondragleave')
+  ElementStream<MouseEvent> get onDragLeave;
+  @DomName('Element.ondragover')
+  ElementStream<MouseEvent> get onDragOver;
+  @DomName('Element.ondragstart')
+  ElementStream<MouseEvent> get onDragStart;
+  @DomName('Element.ondrop')
+  ElementStream<MouseEvent> get onDrop;
+  @DomName('Element.onerror')
+  ElementStream<Event> get onError;
+  @DomName('Element.onfocus')
+  ElementStream<Event> get onFocus;
+  @DomName('Element.oninput')
+  ElementStream<Event> get onInput;
+  @DomName('Element.oninvalid')
+  ElementStream<Event> get onInvalid;
+  @DomName('Element.onkeydown')
+  ElementStream<KeyboardEvent> get onKeyDown;
+  @DomName('Element.onkeypress')
+  ElementStream<KeyboardEvent> get onKeyPress;
+  @DomName('Element.onkeyup')
+  ElementStream<KeyboardEvent> get onKeyUp;
+  @DomName('Element.onload')
+  ElementStream<Event> get onLoad;
+  @DomName('Element.onmousedown')
+  ElementStream<MouseEvent> get onMouseDown;
+  @DomName('Element.onmousemove')
+  ElementStream<MouseEvent> get onMouseMove;
+  @DomName('Element.onmouseout')
+  ElementStream<MouseEvent> get onMouseOut;
+  @DomName('Element.onmouseover')
+  ElementStream<MouseEvent> get onMouseOver;
+  @DomName('Element.onmouseup')
+  ElementStream<MouseEvent> get onMouseUp;
+  @DomName('Element.onmousewheel')
+  ElementStream<WheelEvent> get onMouseWheel;
+  @DomName('Element.onpaste')
+  ElementStream<Event> get onPaste;
+  @DomName('Element.onreset')
+  ElementStream<Event> get onReset;
+  @DomName('Element.onscroll')
+  ElementStream<Event> get onScroll;
+  @DomName('Element.onsearch')
+  ElementStream<Event> get onSearch;
+  @DomName('Element.onselect')
+  ElementStream<Event> get onSelect;
+  @DomName('Element.onselectstart')
+  ElementStream<Event> get onSelectStart;
+  @DomName('Element.onsubmit')
+  ElementStream<Event> get onSubmit;
+  @DomName('Element.ontouchcancel')
+  ElementStream<TouchEvent> get onTouchCancel;
+  @DomName('Element.ontouchend')
+  ElementStream<TouchEvent> get onTouchEnd;
+  @DomName('Element.ontouchenter')
+  ElementStream<TouchEvent> get onTouchEnter;
+  @DomName('Element.ontouchleave')
+  ElementStream<TouchEvent> get onTouchLeave;
+  @DomName('Element.ontouchmove')
+  ElementStream<TouchEvent> get onTouchMove;
+  @DomName('Element.ontouchl')
+  ElementStream<TouchEvent> get onTouchStart;
+  @DomName('Element.ontransitionend')
+  @SupportedBrowser(SupportedBrowser.CHROME)
+  @SupportedBrowser(SupportedBrowser.FIREFOX)
+  @SupportedBrowser(SupportedBrowser.IE, '10')
+  @SupportedBrowser(SupportedBrowser.SAFARI)
+  ElementStream<TransitionEvent> get onTransitionEnd;
+  @DomName('Element.onwebkitfullscreenchange')
+  ElementStream<Event> get onFullscreenChange;
+  @DomName('Element.onwebkitfullscreenerror')
+  ElementStream<Event> get onFullscreenError;
 }
 
 // TODO(jacobr): this is an inefficient implementation but it is hard to see
@@ -8623,6 +8724,103 @@ class _FrozenElementList<T extends Element> extends ListBase<T> implements Eleme
   CssRect get borderEdge => _elementList.first.borderEdge;
 
   CssRect get marginEdge => _elementList.first.marginEdge;
+
+  ElementStream<Event> get onAbort => 
+      Element.abortEvent._forElementTargetList(this);
+  ElementStream<Event> get onBeforeCopy => 
+      Element.beforeCopyEvent._forElementTargetList(this);
+  ElementStream<Event> get onBeforeCut => 
+      Element.beforeCutEvent._forElementTargetList(this);
+  ElementStream<Event> get onBeforePaste => 
+      Element.beforePasteEvent._forElementTargetList(this);
+  ElementStream<Event> get onBlur => 
+      Element.blurEvent._forElementTargetList(this);
+  ElementStream<Event> get onChange => 
+      Element.changeEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onClick => 
+      Element.clickEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onContextMenu => 
+      Element.contextMenuEvent._forElementTargetList(this);
+  ElementStream<Event> get onCopy => 
+      Element.copyEvent._forElementTargetList(this);
+  ElementStream<Event> get onCut => 
+      Element.cutEvent._forElementTargetList(this);
+  ElementStream<Event> get onDoubleClick => 
+      Element.doubleClickEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onDrag => 
+      Element.dragEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onDragEnd => 
+      Element.dragEndEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onDragEnter => 
+      Element.dragEnterEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onDragLeave => 
+      Element.dragLeaveEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onDragOver => 
+      Element.dragOverEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onDragStart => 
+      Element.dragStartEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onDrop => 
+      Element.dropEvent._forElementTargetList(this);
+  ElementStream<Event> get onError => 
+      Element.errorEvent._forElementTargetList(this);
+  ElementStream<Event> get onFocus => 
+      Element.focusEvent._forElementTargetList(this);
+  ElementStream<Event> get onInput => 
+      Element.inputEvent._forElementTargetList(this);
+  ElementStream<Event> get onInvalid => 
+      Element.invalidEvent._forElementTargetList(this);
+  ElementStream<KeyboardEvent> get onKeyDown => 
+      Element.keyDownEvent._forElementTargetList(this);
+  ElementStream<KeyboardEvent> get onKeyPress => 
+      Element.keyPressEvent._forElementTargetList(this);
+  ElementStream<KeyboardEvent> get onKeyUp => 
+      Element.keyUpEvent._forElementTargetList(this);
+  ElementStream<Event> get onLoad => 
+      Element.loadEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onMouseDown => 
+      Element.mouseDownEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onMouseMove => 
+      Element.mouseMoveEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onMouseOut => 
+      Element.mouseOutEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onMouseOver => 
+      Element.mouseOverEvent._forElementTargetList(this);
+  ElementStream<MouseEvent> get onMouseUp => 
+      Element.mouseUpEvent._forElementTargetList(this);
+  ElementStream<WheelEvent> get onMouseWheel =>
+      Element.mouseWheelEvent._forElementTargetList(this);
+  ElementStream<Event> get onPaste => 
+      Element.pasteEvent._forElementTargetList(this);
+  ElementStream<Event> get onReset => 
+      Element.resetEvent._forElementTargetList(this);
+  ElementStream<Event> get onScroll => 
+      Element.scrollEvent._forElementTargetList(this);
+  ElementStream<Event> get onSearch => 
+      Element.searchEvent._forElementTargetList(this);
+  ElementStream<Event> get onSelect => 
+      Element.selectEvent._forElementTargetList(this);
+  ElementStream<Event> get onSelectStart =>
+      Element.selectStartEvent._forElementTargetList(this);
+  ElementStream<Event> get onSubmit =>
+      Element.submitEvent._forElementTargetList(this);
+  ElementStream<TouchEvent> get onTouchCancel =>
+      Element.touchCancelEvent._forElementTargetList(this);
+  ElementStream<TouchEvent> get onTouchEnd =>
+      Element.touchEndEvent._forElementTargetList(this);
+  ElementStream<TouchEvent> get onTouchEnter =>
+      Element.touchEnterEvent._forElementTargetList(this);
+  ElementStream<TouchEvent> get onTouchLeave =>
+      Element.touchLeaveEvent._forElementTargetList(this);
+  ElementStream<TouchEvent> get onTouchMove =>
+      Element.touchMoveEvent._forElementTargetList(this);
+  ElementStream<TouchEvent> get onTouchStart =>
+      Element.touchStartEvent._forElementTargetList(this);
+  ElementStream<TransitionEvent> get onTransitionEnd =>
+      Element.transitionEndEvent._forElementTargetList(this);
+  ElementStream<Event> get onFullscreenChange =>
+      Element.fullscreenChangeEvent._forElementTargetList(this);
+  ElementStream<Event> get onFullscreenError =>
+      Element.fullscreenErrorEvent._forElementTargetList(this);
 }
 
 /**
@@ -9879,200 +10077,200 @@ abstract class Element extends Node implements ParentNode, ChildNode {
 
   @DomName('Element.onabort')
   @DocsEditable()
-  Stream<Event> get onAbort => abortEvent.forTarget(this);
+  ElementStream<Event> get onAbort => abortEvent.forElementTarget(this);
 
   @DomName('Element.onbeforecopy')
   @DocsEditable()
-  Stream<Event> get onBeforeCopy => beforeCopyEvent.forTarget(this);
+  ElementStream<Event> get onBeforeCopy => beforeCopyEvent.forElementTarget(this);
 
   @DomName('Element.onbeforecut')
   @DocsEditable()
-  Stream<Event> get onBeforeCut => beforeCutEvent.forTarget(this);
+  ElementStream<Event> get onBeforeCut => beforeCutEvent.forElementTarget(this);
 
   @DomName('Element.onbeforepaste')
   @DocsEditable()
-  Stream<Event> get onBeforePaste => beforePasteEvent.forTarget(this);
+  ElementStream<Event> get onBeforePaste => beforePasteEvent.forElementTarget(this);
 
   @DomName('Element.onblur')
   @DocsEditable()
-  Stream<Event> get onBlur => blurEvent.forTarget(this);
+  ElementStream<Event> get onBlur => blurEvent.forElementTarget(this);
 
   @DomName('Element.onchange')
   @DocsEditable()
-  Stream<Event> get onChange => changeEvent.forTarget(this);
+  ElementStream<Event> get onChange => changeEvent.forElementTarget(this);
 
   @DomName('Element.onclick')
   @DocsEditable()
-  Stream<MouseEvent> get onClick => clickEvent.forTarget(this);
+  ElementStream<MouseEvent> get onClick => clickEvent.forElementTarget(this);
 
   @DomName('Element.oncontextmenu')
   @DocsEditable()
-  Stream<MouseEvent> get onContextMenu => contextMenuEvent.forTarget(this);
+  ElementStream<MouseEvent> get onContextMenu => contextMenuEvent.forElementTarget(this);
 
   @DomName('Element.oncopy')
   @DocsEditable()
-  Stream<Event> get onCopy => copyEvent.forTarget(this);
+  ElementStream<Event> get onCopy => copyEvent.forElementTarget(this);
 
   @DomName('Element.oncut')
   @DocsEditable()
-  Stream<Event> get onCut => cutEvent.forTarget(this);
+  ElementStream<Event> get onCut => cutEvent.forElementTarget(this);
 
   @DomName('Element.ondblclick')
   @DocsEditable()
-  Stream<Event> get onDoubleClick => doubleClickEvent.forTarget(this);
+  ElementStream<Event> get onDoubleClick => doubleClickEvent.forElementTarget(this);
 
   @DomName('Element.ondrag')
   @DocsEditable()
-  Stream<MouseEvent> get onDrag => dragEvent.forTarget(this);
+  ElementStream<MouseEvent> get onDrag => dragEvent.forElementTarget(this);
 
   @DomName('Element.ondragend')
   @DocsEditable()
-  Stream<MouseEvent> get onDragEnd => dragEndEvent.forTarget(this);
+  ElementStream<MouseEvent> get onDragEnd => dragEndEvent.forElementTarget(this);
 
   @DomName('Element.ondragenter')
   @DocsEditable()
-  Stream<MouseEvent> get onDragEnter => dragEnterEvent.forTarget(this);
+  ElementStream<MouseEvent> get onDragEnter => dragEnterEvent.forElementTarget(this);
 
   @DomName('Element.ondragleave')
   @DocsEditable()
-  Stream<MouseEvent> get onDragLeave => dragLeaveEvent.forTarget(this);
+  ElementStream<MouseEvent> get onDragLeave => dragLeaveEvent.forElementTarget(this);
 
   @DomName('Element.ondragover')
   @DocsEditable()
-  Stream<MouseEvent> get onDragOver => dragOverEvent.forTarget(this);
+  ElementStream<MouseEvent> get onDragOver => dragOverEvent.forElementTarget(this);
 
   @DomName('Element.ondragstart')
   @DocsEditable()
-  Stream<MouseEvent> get onDragStart => dragStartEvent.forTarget(this);
+  ElementStream<MouseEvent> get onDragStart => dragStartEvent.forElementTarget(this);
 
   @DomName('Element.ondrop')
   @DocsEditable()
-  Stream<MouseEvent> get onDrop => dropEvent.forTarget(this);
+  ElementStream<MouseEvent> get onDrop => dropEvent.forElementTarget(this);
 
   @DomName('Element.onerror')
   @DocsEditable()
-  Stream<Event> get onError => errorEvent.forTarget(this);
+  ElementStream<Event> get onError => errorEvent.forElementTarget(this);
 
   @DomName('Element.onfocus')
   @DocsEditable()
-  Stream<Event> get onFocus => focusEvent.forTarget(this);
+  ElementStream<Event> get onFocus => focusEvent.forElementTarget(this);
 
   @DomName('Element.oninput')
   @DocsEditable()
-  Stream<Event> get onInput => inputEvent.forTarget(this);
+  ElementStream<Event> get onInput => inputEvent.forElementTarget(this);
 
   @DomName('Element.oninvalid')
   @DocsEditable()
-  Stream<Event> get onInvalid => invalidEvent.forTarget(this);
+  ElementStream<Event> get onInvalid => invalidEvent.forElementTarget(this);
 
   @DomName('Element.onkeydown')
   @DocsEditable()
-  Stream<KeyboardEvent> get onKeyDown => keyDownEvent.forTarget(this);
+  ElementStream<KeyboardEvent> get onKeyDown => keyDownEvent.forElementTarget(this);
 
   @DomName('Element.onkeypress')
   @DocsEditable()
-  Stream<KeyboardEvent> get onKeyPress => keyPressEvent.forTarget(this);
+  ElementStream<KeyboardEvent> get onKeyPress => keyPressEvent.forElementTarget(this);
 
   @DomName('Element.onkeyup')
   @DocsEditable()
-  Stream<KeyboardEvent> get onKeyUp => keyUpEvent.forTarget(this);
+  ElementStream<KeyboardEvent> get onKeyUp => keyUpEvent.forElementTarget(this);
 
   @DomName('Element.onload')
   @DocsEditable()
-  Stream<Event> get onLoad => loadEvent.forTarget(this);
+  ElementStream<Event> get onLoad => loadEvent.forElementTarget(this);
 
   @DomName('Element.onmousedown')
   @DocsEditable()
-  Stream<MouseEvent> get onMouseDown => mouseDownEvent.forTarget(this);
+  ElementStream<MouseEvent> get onMouseDown => mouseDownEvent.forElementTarget(this);
 
   @DomName('Element.onmousemove')
   @DocsEditable()
-  Stream<MouseEvent> get onMouseMove => mouseMoveEvent.forTarget(this);
+  ElementStream<MouseEvent> get onMouseMove => mouseMoveEvent.forElementTarget(this);
 
   @DomName('Element.onmouseout')
   @DocsEditable()
-  Stream<MouseEvent> get onMouseOut => mouseOutEvent.forTarget(this);
+  ElementStream<MouseEvent> get onMouseOut => mouseOutEvent.forElementTarget(this);
 
   @DomName('Element.onmouseover')
   @DocsEditable()
-  Stream<MouseEvent> get onMouseOver => mouseOverEvent.forTarget(this);
+  ElementStream<MouseEvent> get onMouseOver => mouseOverEvent.forElementTarget(this);
 
   @DomName('Element.onmouseup')
   @DocsEditable()
-  Stream<MouseEvent> get onMouseUp => mouseUpEvent.forTarget(this);
+  ElementStream<MouseEvent> get onMouseUp => mouseUpEvent.forElementTarget(this);
 
   @DomName('Element.onmousewheel')
   @DocsEditable()
   // http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
   @Experimental() // non-standard
-  Stream<WheelEvent> get onMouseWheel => mouseWheelEvent.forTarget(this);
+  ElementStream<WheelEvent> get onMouseWheel => mouseWheelEvent.forElementTarget(this);
 
   @DomName('Element.onpaste')
   @DocsEditable()
-  Stream<Event> get onPaste => pasteEvent.forTarget(this);
+  ElementStream<Event> get onPaste => pasteEvent.forElementTarget(this);
 
   @DomName('Element.onreset')
   @DocsEditable()
-  Stream<Event> get onReset => resetEvent.forTarget(this);
+  ElementStream<Event> get onReset => resetEvent.forElementTarget(this);
 
   @DomName('Element.onscroll')
   @DocsEditable()
-  Stream<Event> get onScroll => scrollEvent.forTarget(this);
+  ElementStream<Event> get onScroll => scrollEvent.forElementTarget(this);
 
   @DomName('Element.onsearch')
   @DocsEditable()
   // http://www.w3.org/TR/html-markup/input.search.html
   @Experimental()
-  Stream<Event> get onSearch => searchEvent.forTarget(this);
+  ElementStream<Event> get onSearch => searchEvent.forElementTarget(this);
 
   @DomName('Element.onselect')
   @DocsEditable()
-  Stream<Event> get onSelect => selectEvent.forTarget(this);
+  ElementStream<Event> get onSelect => selectEvent.forElementTarget(this);
 
   @DomName('Element.onselectstart')
   @DocsEditable()
   @Experimental() // nonstandard
-  Stream<Event> get onSelectStart => selectStartEvent.forTarget(this);
+  ElementStream<Event> get onSelectStart => selectStartEvent.forElementTarget(this);
 
   @DomName('Element.onsubmit')
   @DocsEditable()
-  Stream<Event> get onSubmit => submitEvent.forTarget(this);
+  ElementStream<Event> get onSubmit => submitEvent.forElementTarget(this);
 
   @DomName('Element.ontouchcancel')
   @DocsEditable()
   // http://www.w3.org/TR/touch-events/, http://www.chromestatus.com/features
   @Experimental()
-  Stream<TouchEvent> get onTouchCancel => touchCancelEvent.forTarget(this);
+  ElementStream<TouchEvent> get onTouchCancel => touchCancelEvent.forElementTarget(this);
 
   @DomName('Element.ontouchend')
   @DocsEditable()
   // http://www.w3.org/TR/touch-events/, http://www.chromestatus.com/features
   @Experimental()
-  Stream<TouchEvent> get onTouchEnd => touchEndEvent.forTarget(this);
+  ElementStream<TouchEvent> get onTouchEnd => touchEndEvent.forElementTarget(this);
 
   @DomName('Element.ontouchenter')
   @DocsEditable()
   // http://www.w3.org/TR/touch-events/, http://www.chromestatus.com/features
   @Experimental()
-  Stream<TouchEvent> get onTouchEnter => touchEnterEvent.forTarget(this);
+  ElementStream<TouchEvent> get onTouchEnter => touchEnterEvent.forElementTarget(this);
 
   @DomName('Element.ontouchleave')
   @DocsEditable()
   // http://www.w3.org/TR/touch-events/, http://www.chromestatus.com/features
   @Experimental()
-  Stream<TouchEvent> get onTouchLeave => touchLeaveEvent.forTarget(this);
+  ElementStream<TouchEvent> get onTouchLeave => touchLeaveEvent.forElementTarget(this);
 
   @DomName('Element.ontouchmove')
   @DocsEditable()
   // http://www.w3.org/TR/touch-events/, http://www.chromestatus.com/features
   @Experimental()
-  Stream<TouchEvent> get onTouchMove => touchMoveEvent.forTarget(this);
+  ElementStream<TouchEvent> get onTouchMove => touchMoveEvent.forElementTarget(this);
 
   @DomName('Element.ontouchstart')
   @DocsEditable()
   // http://www.w3.org/TR/touch-events/, http://www.chromestatus.com/features
   @Experimental()
-  Stream<TouchEvent> get onTouchStart => touchStartEvent.forTarget(this);
+  ElementStream<TouchEvent> get onTouchStart => touchStartEvent.forElementTarget(this);
 
   @DomName('Element.ontransitionend')
   @DocsEditable()
@@ -10080,19 +10278,19 @@ abstract class Element extends Node implements ParentNode, ChildNode {
   @SupportedBrowser(SupportedBrowser.FIREFOX)
   @SupportedBrowser(SupportedBrowser.IE, '10')
   @SupportedBrowser(SupportedBrowser.SAFARI)
-  Stream<TransitionEvent> get onTransitionEnd => transitionEndEvent.forTarget(this);
+  ElementStream<TransitionEvent> get onTransitionEnd => transitionEndEvent.forElementTarget(this);
 
   @DomName('Element.onwebkitfullscreenchange')
   @DocsEditable()
   // https://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html
   @Experimental()
-  Stream<Event> get onFullscreenChange => fullscreenChangeEvent.forTarget(this);
+  ElementStream<Event> get onFullscreenChange => fullscreenChangeEvent.forElementTarget(this);
 
   @DomName('Element.onwebkitfullscreenerror')
   @DocsEditable()
   // https://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html
   @Experimental()
-  Stream<Event> get onFullscreenError => fullscreenErrorEvent.forTarget(this);
+  ElementStream<Event> get onFullscreenError => fullscreenErrorEvent.forElementTarget(this);
 
 }
 
@@ -11873,13 +12071,13 @@ class FormElement extends _HTMLElement {
   @DocsEditable()
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#autofilling-form-controls:-the-autocomplete-attribute
   @Experimental()
-  Stream<Event> get onAutocomplete => autocompleteEvent.forTarget(this);
+  ElementStream<Event> get onAutocomplete => autocompleteEvent.forElementTarget(this);
 
   @DomName('HTMLFormElement.onautocompleteerror')
   @DocsEditable()
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#autofilling-form-controls:-the-autocomplete-attribute
   @Experimental()
-  Stream<AutocompleteErrorEvent> get onAutocompleteError => autocompleteErrorEvent.forTarget(this);
+  ElementStream<AutocompleteErrorEvent> get onAutocompleteError => autocompleteErrorEvent.forElementTarget(this);
 
 }
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
@@ -13985,7 +14183,7 @@ class InputElement extends _HTMLElement implements
   @DocsEditable()
   // http://lists.w3.org/Archives/Public/public-xg-htmlspeech/2011Feb/att-0020/api-draft.html#extending_html_elements
   @Experimental()
-  Stream<Event> get onSpeechChange => speechChangeEvent.forTarget(this);
+  ElementStream<Event> get onSpeechChange => speechChangeEvent.forElementTarget(this);
 
 }
 
@@ -15668,113 +15866,113 @@ class MediaElement extends _HTMLElement {
 
   @DomName('HTMLMediaElement.oncanplay')
   @DocsEditable()
-  Stream<Event> get onCanPlay => canPlayEvent.forTarget(this);
+  ElementStream<Event> get onCanPlay => canPlayEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.oncanplaythrough')
   @DocsEditable()
-  Stream<Event> get onCanPlayThrough => canPlayThroughEvent.forTarget(this);
+  ElementStream<Event> get onCanPlayThrough => canPlayThroughEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.ondurationchange')
   @DocsEditable()
-  Stream<Event> get onDurationChange => durationChangeEvent.forTarget(this);
+  ElementStream<Event> get onDurationChange => durationChangeEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onemptied')
   @DocsEditable()
-  Stream<Event> get onEmptied => emptiedEvent.forTarget(this);
+  ElementStream<Event> get onEmptied => emptiedEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onended')
   @DocsEditable()
-  Stream<Event> get onEnded => endedEvent.forTarget(this);
+  ElementStream<Event> get onEnded => endedEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onloadeddata')
   @DocsEditable()
-  Stream<Event> get onLoadedData => loadedDataEvent.forTarget(this);
+  ElementStream<Event> get onLoadedData => loadedDataEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onloadedmetadata')
   @DocsEditable()
-  Stream<Event> get onLoadedMetadata => loadedMetadataEvent.forTarget(this);
+  ElementStream<Event> get onLoadedMetadata => loadedMetadataEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onloadstart')
   @DocsEditable()
-  Stream<Event> get onLoadStart => loadStartEvent.forTarget(this);
+  ElementStream<Event> get onLoadStart => loadStartEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onpause')
   @DocsEditable()
-  Stream<Event> get onPause => pauseEvent.forTarget(this);
+  ElementStream<Event> get onPause => pauseEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onplay')
   @DocsEditable()
-  Stream<Event> get onPlay => playEvent.forTarget(this);
+  ElementStream<Event> get onPlay => playEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onplaying')
   @DocsEditable()
-  Stream<Event> get onPlaying => playingEvent.forTarget(this);
+  ElementStream<Event> get onPlaying => playingEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onprogress')
   @DocsEditable()
-  Stream<Event> get onProgress => progressEvent.forTarget(this);
+  ElementStream<Event> get onProgress => progressEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onratechange')
   @DocsEditable()
-  Stream<Event> get onRateChange => rateChangeEvent.forTarget(this);
+  ElementStream<Event> get onRateChange => rateChangeEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onseeked')
   @DocsEditable()
-  Stream<Event> get onSeeked => seekedEvent.forTarget(this);
+  ElementStream<Event> get onSeeked => seekedEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onseeking')
   @DocsEditable()
-  Stream<Event> get onSeeking => seekingEvent.forTarget(this);
+  ElementStream<Event> get onSeeking => seekingEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onshow')
   @DocsEditable()
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#event-media-loadstart
   @Experimental()
-  Stream<Event> get onShow => showEvent.forTarget(this);
+  ElementStream<Event> get onShow => showEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onstalled')
   @DocsEditable()
-  Stream<Event> get onStalled => stalledEvent.forTarget(this);
+  ElementStream<Event> get onStalled => stalledEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onsuspend')
   @DocsEditable()
-  Stream<Event> get onSuspend => suspendEvent.forTarget(this);
+  ElementStream<Event> get onSuspend => suspendEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.ontimeupdate')
   @DocsEditable()
-  Stream<Event> get onTimeUpdate => timeUpdateEvent.forTarget(this);
+  ElementStream<Event> get onTimeUpdate => timeUpdateEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onvolumechange')
   @DocsEditable()
-  Stream<Event> get onVolumeChange => volumeChangeEvent.forTarget(this);
+  ElementStream<Event> get onVolumeChange => volumeChangeEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onwaiting')
   @DocsEditable()
-  Stream<Event> get onWaiting => waitingEvent.forTarget(this);
+  ElementStream<Event> get onWaiting => waitingEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onwebkitkeyadded')
   @DocsEditable()
   // https://dvcs.w3.org/hg/html-media/raw-file/eme-v0.1/encrypted-media/encrypted-media.html#dom-keyadded
   @Experimental()
-  Stream<MediaKeyEvent> get onKeyAdded => keyAddedEvent.forTarget(this);
+  ElementStream<MediaKeyEvent> get onKeyAdded => keyAddedEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onwebkitkeyerror')
   @DocsEditable()
   // https://dvcs.w3.org/hg/html-media/raw-file/eme-v0.1/encrypted-media/encrypted-media.html#dom-keyadded
   @Experimental()
-  Stream<MediaKeyEvent> get onKeyError => keyErrorEvent.forTarget(this);
+  ElementStream<MediaKeyEvent> get onKeyError => keyErrorEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onwebkitkeymessage')
   @DocsEditable()
   // https://dvcs.w3.org/hg/html-media/raw-file/eme-v0.1/encrypted-media/encrypted-media.html#dom-keyadded
   @Experimental()
-  Stream<MediaKeyEvent> get onKeyMessage => keyMessageEvent.forTarget(this);
+  ElementStream<MediaKeyEvent> get onKeyMessage => keyMessageEvent.forElementTarget(this);
 
   @DomName('HTMLMediaElement.onwebkitneedkey')
   @DocsEditable()
   // https://dvcs.w3.org/hg/html-media/raw-file/eme-v0.1/encrypted-media/encrypted-media.html#dom-keyadded
   @Experimental()
-  Stream<MediaKeyEvent> get onNeedKey => needKeyEvent.forTarget(this);
+  ElementStream<MediaKeyEvent> get onNeedKey => needKeyEvent.forElementTarget(this);
 
 }
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
@@ -29271,6 +29469,106 @@ class _EventStream<T extends Event> extends Stream<T> {
   }
 }
 
+/** A specialized Stream available to [Element]s to enable event delegation. */
+abstract class ElementStream<T extends Event> {
+
+  /**
+   * Return a stream that only fires when the particular event fires for
+   * elements matching the specified CSS selector.
+   *
+   * This is the Dart equivalent to jQuery's
+   * [delegate](http://api.jquery.com/delegate/).
+   */
+  Stream<T> filter(String selector) =>
+      this.where((event) => event.target.matches(selector));
+}
+
+/**
+ * Adapter for exposing DOM Element events as streams, while also allowing
+ * event delegation.
+ */
+class _ElementEventStreamImpl<T extends Event> extends _EventStream<T> with
+    ElementStream<T> {
+  _ElementEventStreamImpl(target, eventType, useCapture) :
+      super(target, eventType, useCapture);
+}
+
+/**
+ * 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> with
+    ElementStream<T> {
+
+  StreamController _controller;
+
+  _ElementListEventStreamImpl(targetList, eventType, useCapture) {
+    _controller = new StreamController(sync: true);
+    for (Element target in targetList) {
+      var stream = new _EventStream(target, eventType, useCapture);
+      stream.listen((event) {
+        _controller.add(event);
+        return event;
+      });
+    }
+  }
+
+  // Delegate all regular Stream behavor to our wrapped Stream.
+  StreamSubscription<T> listen(void onData(T event),
+      { void onError(error),
+        void onDone(),
+        bool cancelOnError}) =>
+      _controller.stream.listen(onData, onError: onError, onDone: onDone,
+          cancelOnError: cancelOnError);
+  Stream<T> asBroadcastStream({void onListen(StreamSubscription subscription),
+                               void onCancel(StreamSubscription subscription)})
+      => _controller.stream;
+  bool get isBroadcast => true;
+  Stream<T> where(bool test(T event)) => _controller.stream.where(test);
+  Stream map(convert(T event)) => _controller.stream.map(convert);
+  Stream<T> handleError(void handle( error), { bool test(error) }) =>
+      _controller.stream.handleError(handle, test: test);
+  Stream expand(Iterable convert(T value)) =>
+      _controller.stream.expand(convert);
+  Future pipe(StreamConsumer<T> streamConsumer) =>
+      _controller.stream.pipe(streamConsumer);
+  Stream transform(StreamTransformer<T, dynamic> streamTransformer) =>
+      _controller.stream.transform(streamTransformer);
+  Future<T> reduce(T combine(T previous, T element)) =>
+      _controller.stream.reduce(combine);
+  Future fold(var initialValue, combine(var previous, T element)) =>
+      _controller.stream.fold(initialValue, combine);
+  Future<String> join([String separator = ""]) =>
+      _controller.stream.join(separator);
+  Future<bool> contains(Object needle) => _controller.stream.contains(needle);
+  Future forEach(void action(T element)) => _controller.stream.forEach(action);
+  Future<bool> every(bool test(T element)) => _controller.stream.every(test);
+  Future<bool> any(bool test(T element)) => _controller.stream.any(test);
+  Future<int> get length => _controller.stream.length;
+  Future<bool> get isEmpty => _controller.stream.isEmpty;
+  Future<List<T>> toList() => _controller.stream.toList();
+  Future<Set<T>> toSet() => _controller.stream.toSet();
+  Future drain([var futureValue]) => _controller.stream.drain(futureValue);
+  Stream<T> take(int count) => _controller.stream.take(count);
+  Stream<T> takeWhile(bool test(T element)) =>
+      _controller.stream.takeWhile(test);
+  Stream<T> skip(int count) => _controller.stream.skip(count);
+  Stream<T> skipWhile(bool test(T element)) =>
+      _controller.stream.skipWhile(test);
+  Stream<T> distinct([bool equals(T previous, T next)]) =>
+      _controller.stream.distinct(equals);
+  Future<T> get first => _controller.stream.first;
+  Future<T> get last => _controller.stream.last;
+  Future<T> get single => _controller.stream.single;
+  Future<dynamic> firstWhere(bool test(T element), {Object defaultValue()}) =>
+      _controller.stream.firstWhere(test, defaultValue: defaultValue);
+  Future<dynamic> lastWhere(bool test(T element), {Object defaultValue()}) =>
+      _controller.stream.lastWhere(test, defaultValue: defaultValue);
+  Future<T> singleWhere(bool test(T element)) =>
+      _controller.stream.singleWhere(test);
+  Future<T> elementAt(int index) => _controller.stream.elementAt(index);
+}
+
 class _EventStreamSubscription<T extends Event> extends StreamSubscription<T> {
   int _pauseCount = 0;
   EventTarget _target;
@@ -29348,7 +29646,6 @@ class _EventStreamSubscription<T extends Event> extends StreamSubscription<T> {
   }
 }
 
-
 /**
  * A factory to expose DOM events as Streams.
  */
@@ -29376,7 +29673,48 @@ class EventStreamProvider<T extends Event> {
    * [addEventListener](http://docs.webplatform.org/wiki/dom/methods/addEventListener)
    */
   Stream<T> forTarget(EventTarget e, {bool useCapture: false}) {
-    return new _EventStream(e, _eventType, useCapture);
+    if (e is Element) {
+      return new _ElementEventStreamImpl(e, _eventType, useCapture);
+    } else {
+      return new _EventStream(e, _eventType, useCapture);
+    }
+  }
+
+  /**
+   * Gets an [ElementEventStream] for this event type, on the specified element.
+   *
+   * This will always return a broadcast stream so multiple listeners can be
+   * used simultaneously.
+   *
+   * This may be used to capture DOM events:
+   *
+   *     Element.keyDownEvent.forElementTarget(element, useCapture: true).listen(...);
+   *
+   * See also:
+   *
+   * [addEventListener](http://docs.webplatform.org/wiki/dom/methods/addEventListener)
+   */
+  ElementStream<T> forElementTarget(Element e, {bool useCapture: false}) {
+    return new _ElementEventStreamImpl(e, _eventType, useCapture);
+  }
+
+  /**
+   * Gets an [ElementEventStream] for this event type, on the list of elements.
+   *
+   * This will always return a broadcast stream so multiple listeners can be
+   * used simultaneously.
+   *
+   * This may be used to capture DOM events:
+   *
+   *     Element.keyDownEvent._forElementTargetList(element, useCapture: true).listen(...);
+   *
+   * See also:
+   *
+   * [addEventListener](http://docs.webplatform.org/wiki/dom/methods/addEventListener)
+   */
+  ElementStream<T> _forElementTargetList(ElementList e,
+      {bool useCapture: false}) {
+    return new _ElementListEventStreamImpl(e, _eventType, useCapture);
   }
 
   /**
@@ -29405,6 +29743,15 @@ class _CustomEventStreamProvider<T extends Event>
     return new _EventStream(e, _eventTypeGetter(e), useCapture);
   }
 
+  ElementStream<T> forElementTarget(Element e, {bool useCapture: false}) {
+    return new _ElementEventStreamImpl(e, _eventTypeGetter(e), useCapture);
+  }
+
+  ElementStream<T> _forElementTargetList(ElementList e,
+      {bool useCapture: false}) {
+    return new _ElementListEventStreamImpl(e, _eventTypeGetter(e), useCapture);
+  }
+
   String getEventType(EventTarget target) {
     return _eventTypeGetter(target);
   }