Fixed a lot of dartanalyzer static analysis issues with the html lib.

sdk/lib/html/dartium/html_dartium.dart

 library html;
 
 import 'dart:collection';
 import 'dart:html_common';
 import 'dart:indexed_db';
 import 'dart:isolate';
 import 'dart:json';
 import 'dart:nativewrappers';
 import 'dart:svg' as svg;
 import 'dart:web_audio' as web_audio;
@@ skipping 27203 matching lines @@
    *     window.location('http://www.mysite.com', 'foo');
    *     // Does not close this window, as the history has changed.
    *     window.close();
    *     print(window.closed()); // 'false'
    *
    * See also:
    *
    * * [Window close discussion](http://www.w3.org/TR/html5/browsers.html#dom-window-close) from the W3C
    */
   void close();
-  void postMessage(var message, String targetOrigin, [List messagePorts = null]);
+  void postMessage(var message, String targetOrigin, [List messagePorts]);
 }
 
 abstract class Location {
   void set href(String val);
 }
 
 abstract class History {
   void back();
   void forward();
   void go(int distance);
@@ skipping 274 matching lines @@
    */
   List<KeyboardEvent> _keyDownList;
 
   /** The set of functions that wish to be notified when a KeyEvent happens. */
   List<Function> _callbacks;
 
   /** The type of KeyEvent we are tracking (keyup, keydown, keypress). */
   String _type;
 
   /** The element we are watching for events to happen on. */
-  EventTarget _target;
+  Element _target;
 
   // The distance to shift from upper case alphabet Roman letters to lower case.
   final int _ROMAN_ALPHABET_OFFSET = "a".charCodes[0] - "A".charCodes[0];
 
   // Instance members referring to the internal event handlers because closures
   // are not hashable.
   var _keyUp, _keyDown, _keyPress;
 
   /**
    * An enumeration of key identifiers currently part of the W3C draft for DOM3
@@ skipping 38 matching lines @@
 
   /** Named constructor to add an onKeyDown event listener to our handler. */
   KeyboardEventController.keydown(EventTarget target) {
     _KeyboardEventController(target, 'keydown');
   }
 
   /**
    * General constructor, performs basic initialization for our improved
    * KeyboardEvent controller.
    */
-  _KeyboardEventController(EventTarget target, String type) {
+  _KeyboardEventController(Element target, String type) {
     _callbacks = [];
     _type = type;
     _target = target;
     _keyDown = processKeyDown;
     _keyUp = processKeyUp;
     _keyPress = processKeyPress;
   }
 
   /**
    * Hook up all event listeners under the covers so we can estimate keycodes
@@ skipping 1330 matching lines @@
   void stopPropagation() => _parent.stopPropagation();
   void $dom_initUIEvent(String type, bool canBubble, bool cancelable,
       LocalWindow view, int detail) {
     throw new UnsupportedError("Cannot initialize a UI Event from a KeyEvent.");
   }
   void $dom_initEvent(String eventTypeArg, bool canBubbleArg,
       bool cancelableArg) {
     throw new UnsupportedError("Cannot initialize an Event from a KeyEvent.");
   }
   String get _shadowKeyIdentifier => _parent.$dom_keyIdentifier;
+
+  int get $dom_charCode => charCode;
+  int get $dom_keyCode => keyCode;
+  EventTarget get target => _parent.target;
+  String get $dom_keyIdentifier {
+    throw new UnsupportedError("keyIdentifier is unsupported.");
+  }
+  void $dom_initKeyboardEvent(String type, bool canBubble, bool cancelable,
+      LocalWindow view, String keyIdentifier, int keyLocation, bool ctrlKey,
+      bool altKey, bool shiftKey, bool metaKey,
+      bool altGraphKey) {
+    throw new UnsupportedError(
+        "Cannot initialize a KeyboardEvent from a KeyEvent.");
+  }
 }
 // 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.
 
 
 class _TypedArrayFactoryProvider {
   static Float32Array createFloat32Array(int length) => _F32(length);
   static Float32Array createFloat32Array_fromList(List<num> list) =>
       _F32(ensureNative(list));
@@ skipping 130 matching lines @@
 
   visitJsSendPortSync(_JsSendPortSync x) {
     return [ 'sendport', 'nativejs', x._id ];
   }
 
   visitLocalSendPortSync(_LocalSendPortSync x) {
     return [ 'sendport', 'dart',
              ReceivePortSync._isolateId, x._receivePort._portId ];
   }
 
+  visitSendPort(SendPort x) {
+    throw new UnimplementedError('Asynchronous send port not yet implemented.');
+  }
+
   visitRemoteSendPortSync(_RemoteSendPortSync x) {
-    return [ 'sendport', 'dart',
-             x._receivePort._isolateId, x._receivePort._portId ];
+    return [ 'sendport', 'dart', x._isolateId, x._portId ];
   }
 }
 
 _deserialize(var message) {
   return new _JsDeserializer().deserialize(message);
 }
 
 
 class _JsDeserializer extends _Deserializer {
 
@@ skipping 37 matching lines @@
   int _portId;
   _RemoteSendPortSync(this._isolateId, this._portId);
 
   callSync(var message) {
     var serialized = _serialize(message);
     var result = _call(_isolateId, _portId, serialized);
     return _deserialize(result);
   }
 
   static _call(int isolateId, int portId, var message) {
-    var target = 'dart-port-$isolateId-$portId'; 
+    var target = 'dart-port-$isolateId-$portId';
     // TODO(vsm): Make this re-entrant.
     // TODO(vsm): Set this up set once, on the first call.
     var source = '$target-result';
     var result = null;
     var listener = (Event e) {
       result = JSON.parse(_getPortSyncEventData(e));
     };
     window.on[source].add(listener);
     _dispatchEvent(target, [source, message]);
     window.on[source].remove(listener);
@@ skipping 44 matching lines @@
       _portIdCount = 0;
       _portMap = new Map<int, ReceivePortSync>();
     }
     _portId = _portIdCount++;
     _portMap[_portId] = this;
   }
 
   static int get _isolateId {
     // TODO(vsm): Make this coherent with existing isolate code.
     if (_cachedIsolateId == null) {
-      _cachedIsolateId = _getNewIsolateId();      
+      _cachedIsolateId = _getNewIsolateId();
     }
     return _cachedIsolateId;
   }
 
   static String _getListenerName(isolateId, portId) =>
-      'dart-port-$isolateId-$portId'; 
+      'dart-port-$isolateId-$portId';
   String get _listenerName => _getListenerName(_isolateId, _portId);
 
   void receive(callback(var message)) {
     _callback = callback;
     if (_listener == null) {
       _listener = (Event e) {
         var data = JSON.parse(_getPortSyncEventData(e));
         var replyTo = data[0];
         var message = _deserialize(data[1]);
         var result = _callback(message);
@@ skipping 611 matching lines @@
   bool get isEmpty => Maps.isEmpty(this);
 }
 
 get _printClosure => (s) {
   try {
     window.console.log(s);
   } catch (_) {
     _Utils.print(s);
   }
 };