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

sdk/lib/html/src/Isolates.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;
 
 _serialize(var message) {
   return new _JsSerializer().traverse(message);
 }
 
 class _JsSerializer extends _Serializer {
 
   visitSendPortSync(SendPortSync x) {
     if (x is _JsSendPortSync) return visitJsSendPortSync(x);
     if (x is _LocalSendPortSync) return visitLocalSendPortSync(x);
     if (x is _RemoteSendPortSync) return visitRemoteSendPortSync(x);
     throw "Unknown port type $x";
   }
 
   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 22 matching lines @@
 }
 
 get _isolateId => ReceivePortSync._isolateId;
 
 void _dispatchEvent(String receiver, var message) {
   var event = new CustomEvent(receiver, false, false, JSON.stringify(message));
   window.$dom_dispatchEvent(event);
 }
 
 String _getPortSyncEventData(CustomEvent event) => event.detail;