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

runtime/bin/socket_patch.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.
 
 patch class ServerSocket {
   /* patch */ factory ServerSocket(String bindAddress, int port, int backlog) {
     return new _ServerSocket(bindAddress, port, backlog);
   }
 }
 
@@ skipping 119 matching lines @@
       } else {
         if (_closedRead) { data &= ~(1 << _IN_EVENT); }
         if (_closedWrite) { data &= ~(1 << _OUT_EVENT); }
         if (_isPipe()) data |= (1 << _PIPE);
       }
       _sendToEventHandler(data);
     }
   }
 
   int get port {
-    if (_port === null) {
+    if (_port == null) {
       _port = _getPort();
     }
     return _port;
   }
 
   void close([bool halfClose = false]) {
     if (!_closed) {
       if (halfClose) {
         _closeWrite();
       } else {
@@ skipping 32 matching lines @@
   void _close() {
     if (!_closed) {
       _sendToEventHandler(1 << _CLOSE_COMMAND);
       _handler.close();
       _handler = null;
       _closed = true;
     }
   }
 
   void _sendToEventHandler(int data) {
-    if (_handler === null) {
+    if (_handler == null) {
       _handler = new ReceivePort();
       _handler.receive((var message, ignored) { _multiplex(message); });
     }
     assert(!_closed);
     _EventHandler._sendData(this, _handler, data);
   }
 
   bool _reportError(error, String message) {
     void doReportError(Exception e) {
       // Invoke the socket error callback if any.
@@ skipping 284 matching lines @@
            "Cannot set close handler when input stream is used");
     _onClosed = callback;
   }
 
   bool _isListenSocket() => false;
 
   bool _isPipe() => _pipe;
 
   InputStream get inputStream {
     if (_inputStream == null) {
-      if (_handlerMap[_SocketBase._IN_EVENT] !== null ||
-          _handlerMap[_SocketBase._CLOSE_EVENT] !== null) {
+      if (_handlerMap[_SocketBase._IN_EVENT] != null ||
+          _handlerMap[_SocketBase._CLOSE_EVENT] != null) {
         throw new StreamException(
             "Cannot get input stream when socket handlers are used");
       }
       _inputStream = new _SocketInputStream(this);
     }
     return _inputStream;
   }
 
   OutputStream get outputStream {
     if (_outputStream == null) {
-      if (_handlerMap[_SocketBase._OUT_EVENT] !== null) {
+      if (_handlerMap[_SocketBase._OUT_EVENT] != null) {
         throw new StreamException(
             "Cannot get input stream when socket handlers are used");
       }
       _outputStream = new _SocketOutputStream(this);
     }
     return _outputStream;
   }
 
   void set _onWrite(void callback()) {
     _setHandler(_SocketBase._OUT_EVENT, callback);
@@ skipping 20 matching lines @@
 
   void _updateOutHandler() {
     void firstWriteHandler() {
       assert(!_seenFirstOutEvent);
       _seenFirstOutEvent = true;
 
       // From now on the write handler is only the client write
       // handler (connect handler cannot be called again). Change this
       // before calling any handlers as handlers can change the
       // handlers.
-      if (_clientWriteHandler === null) _onWrite = _clientWriteHandler;
+      if (_clientWriteHandler == null) _onWrite = _clientWriteHandler;
 
       // First out event is socket connected event.
-      if (_clientConnectHandler !== null) _clientConnectHandler();
+      if (_clientConnectHandler != null) _clientConnectHandler();
       _clientConnectHandler = null;
 
       // Always (even for the first out event) call the write handler.
-      if (_clientWriteHandler !== null) _clientWriteHandler();
+      if (_clientWriteHandler != null) _clientWriteHandler();
     }
 
-    if (_clientConnectHandler === null && _clientWriteHandler === null) {
+    if (_clientConnectHandler == null && _clientWriteHandler == null) {
       _onWrite = null;
     } else {
       if (_seenFirstOutEvent) {
         _onWrite = _clientWriteHandler;
       } else {
         _onWrite = firstWriteHandler;
       }
     }
   }
 
   int get remotePort {
-    if (_remotePort === null) {
+    if (_remotePort == null) {
       remoteHost;
     }
     return _remotePort;
   }
 
   String get remoteHost {
-    if (_remoteHost === null) {
+    if (_remoteHost == null) {
       List peer = _getRemotePeer();
       _remoteHost = peer[0];
       _remotePort = peer[1];
     }
     return _remoteHost;
   }
 
   List _getRemotePeer() native "Socket_GetRemotePeer";
 
   static SendPort _newServicePort() native "Socket_NewServicePort";
 
   static void _ensureSocketService() {
     if (_socketService == null) {
       _socketService = _Socket._newServicePort();
     }
   }
 
   bool _seenFirstOutEvent = false;
   bool _pipe = false;
   Function _clientConnectHandler;
   Function _clientWriteHandler;
   _SocketInputStream _inputStream;
   _SocketOutputStream _outputStream;
   String _remoteHost;
   int _remotePort;
   static SendPort _socketService;
 }