Consistently use setters to set event handlers in native APIs.

samples/chat/http_impl.dart

 // Copyright (c) 2011, 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.
 
 // Global constants.
 class Const {
   // Bytes for "HTTP/1.0".
   static final HTTP10 = const [72, 84, 84, 80, 47, 49, 46, 48];
   // Bytes for "HTTP/1.1".
   static final HTTP11 = const [72, 84, 84, 80, 47, 49, 46, 49];
@@ skipping 910 matching lines @@
 }
 
 
 class HTTPConnectionBase {
   static final BUFFER_SIZE = 80;
 
   HTTPConnectionBase(Socket this._socket)
       : _sendBuffers = new Queue(),
         _httpParser = new HTTPParser() {
     // Register handler for socket events.
-    _socket.setDataHandler(() => _dataHandler());
-    _socket.setCloseHandler(() => _closeHandler());
-    _socket.setErrorHandler(() => _errorHandler());
+    _socket.dataHandler = _dataHandler;
+    _socket.closeHandler = _closeHandler;
+    _socket.errorHandler = _errorHandler;
   }
 
   // Add data to be send. If the flag keepBuffer is false (the
   // default) the data will be copied to an internal send buffer. If
   // the flag keepBuffer is true the data will be kept until it has
   // successfuly been sent. Note: calling this function will not
   // initiate sending of the data.
   void _addSendData(List<int> data,
                     int offset,
                     int count,
@@ skipping 29 matching lines @@
   // immediately and no callbacks will occour.
   bool _startSending(var callback) {
     void send() {
 
       void continueSending() {
         // Send more data.
         send();
 
         // If all data has been sent notify the callback.
         if (_sendBuffers.isEmpty() && callback != null) {
-          _socket.setWriteHandler(null);
+          _socket.writeHandler = null;
           callback();
         }
       }
 
       // Send as much data as possible.
       while (!_sendBuffers.isEmpty()) {
         SendBuffer buffer = _sendBuffers.first();
         buffer._write(_socket);
         if (!buffer._isSent) {
-          _socket.setWriteHandler(continueSending);
+          _socket.writeHandler = continueSending;
           break;
         } else {
           _sendBuffers.removeFirst();
         }
       }
     }
 
     // Queue the current send buffer now if any.
     if (_currentSendBuffer != null) {
       _sendBuffers.addLast(_currentSendBuffer);
@@ skipping 115 matching lines @@
       _connections.addLast(connection);
       _connectionsCount++;
       if (_debugTrace) {
         print("New connection (total $_connectionsCount connections)");
       }
     }
 
     _connections = new Queue<HTTPConnection>();
     _connectionsCount = 0;
     _server = new ServerSocket(host, port, 5);
-    _server.setConnectionHandler(connectionHandler);
+    _server.connectionHandler = connectionHandler;
   }
 
   void close() => _server.close();
   int get port() => _server.port;
 
   ServerSocket _server;  // The server listen socket.
   Queue<HTTPConnection> _connections;  // Queue of currently connected clients.
   int _connectionsCount;
   bool _debugTrace;
 }
@@ skipping 340 matching lines @@
 
     // Return connection.
     sockets.addFirst(socketConn);
     socketConn._markReturned();
   }
 
   Map<String, Queue<SocketConnection>> _openSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }