a === b -> identical(a, b)

sdk/lib/io/websocket_impl.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.
 
 const String _webSocketGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
 class _WebSocketMessageType {
   static const int NONE = 0;
   static const int BINARY = 1;
   static const int TEXT = 2;
@@ skipping 70 matching lines @@
               if (_currentMessageType == _WebSocketMessageType.NONE) {
                 throw new WebSocketException("Protocol error");
               }
               break;
 
             case _WebSocketOpcode.TEXT:
               if (_currentMessageType != _WebSocketMessageType.NONE) {
                 throw new WebSocketException("Protocol error");
               }
               _currentMessageType = _WebSocketMessageType.TEXT;
-              if (onMessageStart !== null) {
+              if (onMessageStart != null) {
                 onMessageStart(_WebSocketMessageType.TEXT);
               }
               break;
 
             case _WebSocketOpcode.BINARY:
               if (_currentMessageType != _WebSocketMessageType.NONE) {
                 throw new WebSocketException("Protocol error");
               }
               _currentMessageType = _WebSocketMessageType.BINARY;
-              if (onMessageStart !== null) {
+              if (onMessageStart != null) {
                 onMessageStart(_WebSocketMessageType.BINARY);
               }
               break;
 
             case _WebSocketOpcode.CLOSE:
             case _WebSocketOpcode.PING:
             case _WebSocketOpcode.PONG:
               // Control frames cannot be fragmented.
               if (!_fin) throw new WebSocketException("Protocol error");
               break;
@@ skipping 73 matching lines @@
               if (_remainingPayloadBytes == 0) {
                 _controlFrameEnd();
               }
             } else {
               switch (_currentMessageType) {
                 case _WebSocketMessageType.NONE:
                   throw new WebSocketException("Protocol error");
 
                 case _WebSocketMessageType.TEXT:
                 case _WebSocketMessageType.BINARY:
-                  if (onMessageData !== null) {
+                  if (onMessageData != null) {
                     onMessageData(buffer, index, payload);
                   }
                   index += payload;
                   if (_remainingPayloadBytes == 0) {
                     _messageFrameEnd();
                   }
                   break;
 
                 default:
                   throw new WebSocketException("Protocol error");
               }
             }
 
             // Hack - as we always do index++ below.
             index--;
             break;
         }
 
         // Move to the next byte.
         index++;
       }
     } catch (e) {
-      if (onClosed !== null) onClosed(WebSocketStatus.PROTOCOL_ERROR,
+      if (onClosed != null) onClosed(WebSocketStatus.PROTOCOL_ERROR,
                                       "Protocol error");
       _state = FAILURE;
     }
   }
 
   /**
    * Indicate that the underlying communication channel has been closed.
    */
   void closed() {
     if (_state == START || _state == CLOSED || _state == FAILURE) return;
-    if (onClosed !== null) onClosed(WebSocketStatus.ABNORMAL_CLOSURE,
+    if (onClosed != null) onClosed(WebSocketStatus.ABNORMAL_CLOSURE,
                                     "Connection closed unexpectedly");
     _state = CLOSED;
   }
 
   void _lengthDone() {
     if (_masked) {
       _state = MASK;
       _remainingMaskingKeyBytes = 4;
     } else {
       _remainingPayloadBytes = _len;
       _startPayload();
     }
   }
 
   void _maskDone() {
     _remainingPayloadBytes = _len;
     _startPayload();
   }
 
   void _startPayload() {
     // If there is no actual payload perform perform callbacks without
     // going through the PAYLOAD state.
     if (_remainingPayloadBytes == 0) {
       if (_isControlFrame()) {
         switch (_opcode) {
           case _WebSocketOpcode.CLOSE:
-            if (onClosed !== null) onClosed(1005, "");
+            if (onClosed != null) onClosed(1005, "");
             _state = CLOSED;
             break;
           case _WebSocketOpcode.PING:
-            if (onPing !== null) onPing(null);
+            if (onPing != null) onPing(null);
             break;
           case _WebSocketOpcode.PONG:
-            if (onPong !== null) onPong(null);
+            if (onPong != null) onPong(null);
             break;
         }
         _prepareForNextFrame();
       } else {
         _messageFrameEnd();
       }
     } else {
       _state = PAYLOAD;
     }
   }
 
   void _messageFrameEnd() {
     if (_fin) {
-      if (onMessageEnd !== null) onMessageEnd();
+      if (onMessageEnd != null) onMessageEnd();
       _currentMessageType = _WebSocketMessageType.NONE;
     }
     _prepareForNextFrame();
   }
 
   void _controlFrameEnd() {
     switch (_opcode) {
       case _WebSocketOpcode.CLOSE:
         int status = WebSocketStatus.NO_STATUS_RECEIVED;
         String reason = "";
         if (_controlPayload.length > 0) {
           if (_controlPayload.length == 1) {
             throw new WebSocketException("Protocol error");
           }
           status = _controlPayload[0] << 8 | _controlPayload[1];
           if (status == WebSocketStatus.NO_STATUS_RECEIVED) {
             throw new WebSocketException("Protocol error");
           }
           if (_controlPayload.length > 2) {
             var decoder = _StringDecoders.decoder(Encoding.UTF_8);
             decoder.write(
                 _controlPayload.getRange(2, _controlPayload.length - 2));
             reason = decoder.decoded();
           }
         }
-        if (onClosed !== null) onClosed(status, reason);
+        if (onClosed != null) onClosed(status, reason);
         _state = CLOSED;
         break;
 
       case _WebSocketOpcode.PING:
-        if (onPing !== null) onPing(_controlPayload);
+        if (onPing != null) onPing(_controlPayload);
         break;
 
       case _WebSocketOpcode.PONG:
-        if (onPong !== null) onPong(_controlPayload);
+        if (onPong != null) onPong(_controlPayload);
         break;
     }
     _prepareForNextFrame();
   }
 
   bool _isControlFrame() {
     return _opcode == _WebSocketOpcode.CLOSE ||
            _opcode == _WebSocketOpcode.PING ||
            _opcode == _WebSocketOpcode.PONG;
   }
@@ skipping 42 matching lines @@
   }
 
   void _startProcessing(List<int> unparsedData) {
     _WebSocketProtocolProcessor processor = new _WebSocketProtocolProcessor();
     processor.onMessageStart = _onWebSocketMessageStart;
     processor.onMessageData = _onWebSocketMessageData;
     processor.onMessageEnd = _onWebSocketMessageEnd;
     processor.onPing = _onWebSocketPing;
     processor.onPong = _onWebSocketPong;
     processor.onClosed = _onWebSocketClosed;
-    if (unparsedData !== null) {
+    if (unparsedData != null) {
       processor.update(unparsedData, 0, unparsedData.length);
     }
     _socket.onData = () {
       int available = _socket.available();
       List<int> data = new List<int>(available);
       int read = _socket.readList(data, 0, available);
       processor.update(data, 0, read);
     };
     _socket.onClosed = () {
       processor.closed();
       if (_closeSent) {
         // Got socket close in response to close frame. Don't treat
         // that as an error.
-        if (_closeTimer !== null) _closeTimer.cancel();
+        if (_closeTimer != null) _closeTimer.cancel();
       } else {
-        if (_onClosed !== null) _onClosed(WebSocketStatus.ABNORMAL_CLOSURE,
+        if (_onClosed != null) _onClosed(WebSocketStatus.ABNORMAL_CLOSURE,
                                           "Unexpected close");
       }
       _socket.close();
     };
   }
 
   void set onMessage(void callback(Object message)) {
     _onMessage = callback;
   }
 
   void set onClosed(void callback(int status, String reason)) {
     _onClosed = callback;
   }
 
   send(message) {
     if (_closeSent) {
       throw new WebSocketException("Connection closed");
     }
     List<int> data;
     int opcode;
-    if (message !== null) {
+    if (message != null) {
       if (message is String) {
         opcode = _WebSocketOpcode.TEXT;
         data = _StringEncoders.encoder(Encoding.UTF_8).encodeString(message);
       } else {
         if (message is !List<int>) {
           throw new ArgumentError(message);
         }
         opcode = _WebSocketOpcode.BINARY;
         data = message;
       }
     } else {
       opcode = _WebSocketOpcode.TEXT;
     }
     _sendFrame(opcode, data);
   }
 
   close([int status, String reason]) {
     if (status == WebSocketStatus.RESERVED_1004 ||
         status == WebSocketStatus.NO_STATUS_RECEIVED ||
         status == WebSocketStatus.RESERVED_1015) {
       throw new WebSocketException("Reserved status code $status");
     }
 
     if (_closeSent) return;
     List<int> data;
-    if (status !== null) {
+    if (status != null) {
       data = new List<int>();
       data.add((status >> 8) & 0xFF);
       data.add(status & 0xFF);
-      if (reason !== null) {
+      if (reason != null) {
         data.addAll(
            _StringEncoders.encoder(Encoding.UTF_8).encodeString(reason));
       }
     }
     _sendFrame(_WebSocketOpcode.CLOSE, data);
 
     if (_closeReceived) {
       // Close the socket when the close frame has been sent - if it
       // does not take too long.
       _socket.outputStream.close();
       _socket.outputStream.onClosed = () {
-        if (_closeTimer !== null) _closeTimer.cancel();
+        if (_closeTimer != null) _closeTimer.cancel();
         _socket.close();
       };
       _closeTimer = new Timer(5000, (t) {
         _socket.close();
       });
     } else {
       // Half close the socket and expect a close frame in response
       // before closing the socket. If a close frame does not arrive
       // within a reasonable amount of time just close the socket.
       _socket.outputStream.close();
@@ skipping 17 matching lines @@
 
   _onWebSocketMessageData(List<int> buffer, int offset, int count) {
     if (_currentMessageType == _WebSocketMessageType.TEXT) {
       _decoder.write(buffer.getRange(offset, count));
     } else {
       _outputStream.write(buffer.getRange(offset, count));
     }
   }
 
   _onWebSocketMessageEnd() {
-    if (_onMessage !== null) {
+    if (_onMessage != null) {
       if (_currentMessageType == _WebSocketMessageType.TEXT) {
         _onMessage(_decoder.decoded());
       } else {
         _onMessage(_outputStream.read());
       }
     }
     _decoder = null;
     _outputStream = null;
   }
 
   _onWebSocketPing(List<int> payload) {
     _sendFrame(_WebSocketOpcode.PONG, payload);
   }
 
   _onWebSocketPong(List<int> payload) {
     // Currently pong messages are ignored.
   }
 
   _onWebSocketClosed(int status, String reason) {
     _closeReceived = true;
-    if (_onClosed !== null) _onClosed(status, reason);
+    if (_onClosed != null) _onClosed(status, reason);
     if (_closeSent) {
       // Got close frame in response to close frame. Now close the socket.
-      if (_closeTimer !== null) _closeTimer.cancel();
+      if (_closeTimer != null) _closeTimer.cancel();
       _socket.close();
     } else {
       if (status != WebSocketStatus.NO_STATUS_RECEIVED) {
         close(status);
       } else {
         close();
       }
     }
   }
 
@@ skipping 20 matching lines @@
     } else if (dataLength > 125) {
       header[index++] = 126;
       lengthBytes = 2;
     }
     // Write the length in network byte order into the header.
     for (int i = 0; i < lengthBytes; i++) {
       header[index++] = dataLength >> (((lengthBytes - 1) - i) * 8) & 0xFF;
     }
     assert(index == headerSize);
     _socket.outputStream.write(header);
-    if (data !== null) {
+    if (data != null) {
       _socket.outputStream.write(data);
     }
   }
 
   Socket _socket;
   Timer _closeTimer;
   int _hash;
 
   Function _onMessage;
   Function _onClosed;
@@ skipping 32 matching lines @@
     String key = request.headers.value("Sec-WebSocket-Key");
     SHA1 sha1 = new SHA1();
     sha1.update("$key$_webSocketGUID".charCodes);
     String accept = _Base64._encode(sha1.digest());
     response.headers.add("Sec-WebSocket-Accept", accept);
     response.contentLength = 0;
 
     // Upgrade the connection and get the underlying socket.
     WebSocketConnection conn =
         new _WebSocketConnection(response.detachSocket());
-    if (_onOpen !== null) _onOpen(conn);
+    if (_onOpen != null) _onOpen(conn);
   }
 
   void set onOpen(callback(WebSocketConnection connection)) {
     _onOpen = callback;
   }
 
   bool _isWebSocketUpgrade(HttpRequest request) {
     if (request.method != "GET") {
       return false;
     }
@@ skipping 24 matching lines @@
 }
 
 
 class _WebSocketClientConnection
     extends _WebSocketConnectionBase implements WebSocketClientConnection {
   _WebSocketClientConnection(HttpClientConnection this._conn,
                              [List<String> protocols]) {
     _conn.onRequest = _onHttpClientRequest;
     _conn.onResponse = _onHttpClientResponse;
     _conn.onError = (e) {
-      if (_onClosed !== null) {
+      if (_onClosed != null) {
         _onClosed(WebSocketStatus.ABNORMAL_CLOSURE, "$e");
       }
     };
 
     // Generate the nonce now as it is also used to set the hash code.
     _generateNonceAndHash();
   }
 
   void set onRequest(void callback(HttpClientRequest request)) {
     _onRequest = callback;
   }
 
   void set onOpen(void callback()) {
     _onOpen = callback;
   }
 
   void set onNoUpgrade(void callback(HttpClientResponse request)) {
     _onNoUpgrade = callback;
   }
 
   void _onHttpClientRequest(HttpClientRequest request) {
-    if (_onRequest !== null) {
+    if (_onRequest != null) {
       _onRequest(request);
     }
     // Setup the initial handshake.
     request.headers.add(HttpHeaders.CONNECTION, "upgrade");
     request.headers.set(HttpHeaders.UPGRADE, "websocket");
     request.headers.set("Sec-WebSocket-Key", _nonce);
     request.headers.set("Sec-WebSocket-Version", "13");
     request.contentLength = 0;
     request.outputStream.close();
   }
 
   void _onHttpClientResponse(HttpClientResponse response) {
     if (response.statusCode != HttpStatus.SWITCHING_PROTOCOLS) {
-      if (_onNoUpgrade !== null) {
+      if (_onNoUpgrade != null) {
         _onNoUpgrade(response);
       } else {
         _conn.detachSocket().socket.close();
         throw new WebSocketException("Protocol upgrade refused");
       }
       return;
     }
 
     if (!_isWebSocketUpgrade(response)) {
       _conn.detachSocket().socket.close();
       throw new WebSocketException("Protocol upgrade failed");
       return;
     }
 
     // Connection upgrade successful.
     DetachedSocket detached = _conn.detachSocket();
     _socketConnected(detached.socket);
-    if (_onOpen !== null) _onOpen();
+    if (_onOpen != null) _onOpen();
     _startProcessing(detached.unparsedData);
   }
 
   void _generateNonceAndHash() {
     Random random = new Random();
     assert(_nonce == null);
     void intToBigEndianBytes(int value, List<int> bytes, int offset) {
       bytes[offset] = (value >> 24) & 0xFF;
       bytes[offset + 1] = (value >> 16) & 0xFF;
       bytes[offset + 2] = (value >> 8) & 0xFF;
@@ skipping 68 matching lines @@
 
     HttpClient client = new HttpClient();
     HttpClientConnection conn = client.open("GET", uri.domain, port, path);
     if (protocols is String) protocols = [protocols];
     _wsconn = new WebSocketClientConnection(conn, protocols);
     _wsconn.onOpen = () {
       // HTTP client not needed after socket have been detached.
       client.shutdown();
       client = null;
       _readyState = WebSocket.OPEN;
-      if (_onopen !== null) _onopen();
+      if (_onopen != null) _onopen();
     };
     _wsconn.onMessage = (message) {
-      if (_onmessage !== null) {
+      if (_onmessage != null) {
         _onmessage(new _WebSocketMessageEvent(message));
       }
     };
     _wsconn.onClosed = (status, reason) {
       _readyState = WebSocket.CLOSED;
-      if (_onclose !== null) {
+      if (_onclose != null) {
         _onclose(new _WebSocketCloseEvent(true, status, reason));
       }
     };
     _wsconn.onNoUpgrade = (response) {
-      if (_onclose !== null) {
+      if (_onclose != null) {
         _onclose(
             new _WebSocketCloseEvent(true,
                                      WebSocketStatus.ABNORMAL_CLOSURE,
                                      "Connection not upgraded"));
       }
     };
   }
 
   int get readyState => _readyState;
   int get bufferedAmount => 0;
@@ skipping 41 matching lines @@
 
 class _WebSocketCloseEvent implements CloseEvent {
   _WebSocketCloseEvent(this._wasClean, this._code, this._reason);
   bool get wasClean => _wasClean;
   int get code => _code;
   String get reason => _reason;
   bool _wasClean;
   int _code;
   String _reason;
 }