Incorporate Pete's comments on KeyboardEventStream.

tools/dom/src/KeyboardEventStream.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;
 
 /**
  * Internal class that does the actual calculations to determine keyCode and
  * charCode for keydown, keypress, and keyup events for all browsers.
  */
@@ skipping 15 matching lines @@
 
   /** The element we are watching for events to happen on. */
   EventTarget _target;
 
   // The distance to shift from upper case alphabet Roman letters to lower case.
   final int _ROMAN_ALPHABET_OFFSET = "a".codeUnits[0] - "A".codeUnits[0];
 
   /** Controller to produce KeyEvents for the stream. */
   StreamController _controller;
 
+  String _eventType = '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 Map<String, int> _keyIdentifier = {
     'Up': KeyCode.UP,
     'Down': KeyCode.DOWN,
     'Left': KeyCode.LEFT,
     'Right': KeyCode.RIGHT,
@@ skipping 15 matching lines @@
     'End': KeyCode.END,
     'PageUp': KeyCode.PAGE_UP,
     'PageDown': KeyCode.PAGE_DOWN,
     'Insert': KeyCode.INSERT
   };
 
   /**
    * Gets the type of the event which this would listen for on the specified
    * event target.
    */
-  String getEventType(EventTarget target) => 'KeyEvent';
+  String getEventType(EventTarget target) => _eventType;
 
   /** Return a stream for KeyEvents for the specified target. */
   Stream<KeyEvent> forTarget(EventTarget e, {bool useCapture: false}) {
-    _initializeAllEventListeners(e);
-    return _controller.stream;
+    var newController = new _KeyboardEventHandler.initializeAllEventListeners(

[Andrei Mouravski, 2013/03/27 00:03:35]

I'd inline this.

+        _type, e);
+    return newController.stream;
   }
 
   /**
+   * Accessor to the stream associated with a particular KeyboardEvent
+   * EventTarget.
+   *
+   * [forTarget] must be called to initialize this stream to listen to a
+   * particular EventTarget.
+   */
+  Stream<KeyEvent> get stream {
+    if(_target != null) {
+      return _controller.stream;
+    } else {
+      throw new StateError("Not initialized. Call forTarget to access a stream "
+          "initialized with a particular EventTarget.");
+    }
+  }
+
+  /**
    * General constructor, performs basic initialization for our improved
    * KeyboardEvent controller.
    */
   _KeyboardEventHandler(String type) {
+    _commonInit(type);
+  }
+
+  void _commonInit(String type) {
     _type = type;
     _controller = new StreamController.broadcast();
     _callbacks = [];
+    _target = null;
   }
 
   /**
    * Hook up all event listeners under the covers so we can estimate keycodes
    * and charcodes when they are not provided.
    */
-  _initializeAllEventListeners(EventTarget target) {
+  _KeyboardEventHandler.initializeAllEventListeners(String type,
+      EventTarget target) {
+    _commonInit(type);
     _target = target;
     _keyDownList = [];
     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 265 matching lines @@
 
 
 /**
  * Records KeyboardEvents that occur on a particular element, and provides a
  * stream of outgoing KeyEvents with cross-browser consistent keyCode and
  * charCode values despite the fact that a multitude of browsers that have
  * varying keyboard default behavior.
  *
  * Example usage:
  *
- *     new KeyboardEventStream.onKeyDown(document.body).listen(
+ *     KeyboardEventStream.onKeyDown(document.body).listen(
  *         keydownHandlerTest);
  *
  * This class is very much a work in progress, and we'd love to get information
  * on how we can make this class work with as many international keyboards as
  * possible. Bugs welcome!
  */
-class KeyboardEventStream extends Stream<KeyEvent> {
+class KeyboardEventStream {
 
   /** Named constructor to produce a stream for onKeyPress events. */
-  factory KeyboardEventStream.onKeyPress(EventTarget target) =>
+  static Stream<KeyEvent> onKeyPress(EventTarget target) =>
       new _KeyboardEventHandler('keypress').forTarget(target);
 
   /** Named constructor to produce a stream for onKeyUp events. */
-  factory KeyboardEventStream.onKeyUp(EventTarget target) =>
+  static Stream<KeyEvent> onKeyUp(EventTarget target) =>
       new _KeyboardEventHandler('keyup').forTarget(target);
 
   /** Named constructor to produce a stream for onKeyDown events. */
-  factory KeyboardEventStream.onKeyDown(EventTarget target) =>
+  static Stream<KeyEvent> onKeyDown(EventTarget target) =>
     new _KeyboardEventHandler('keydown').forTarget(target);
 }