Consistently use setters to set event handlers in native APIs.

runtime/bin/socket_stream.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.
 
 class SocketInputStream implements InputStream {
   SocketInputStream(Socket socket) {
     _socket = socket;
   }
 
   List<int> read([int len]) {
@@ skipping 23 matching lines @@
     if (offset < 0) throw new StreamException("Illegal offset $offset");
     if (len < 0) throw new StreamException("Illegal length $len");
     return _socket.readList(buffer, offset, len);
   }
 
   int available() {
     return _socket.available();
   }
 
   void set dataHandler(void callback()) {
-    _socket.setDataHandler(callback);
+    _socket.dataHandler = callback;
   }
 
   void set closeHandler(void callback()) {
-    _socket.setCloseHandler(callback);
+    _socket.closeHandler = callback;
   }
 
   void set errorHandler(void callback()) {
-    _socket.setErrorHandler(callback);
+    _socket.errorHandler = callback;
   }
 
   Socket _socket;
 }
 
 
 class _BufferList2 {
   _BufferList2() {
     clear();
   }
@@ skipping 35 matching lines @@
 
   int _length;  // Total length of pending data.
   Queue<List<int>> _buffers;
   int _index;  // Offset into the first buffer of next write position.
 }
 
 
 class SocketOutputStream implements OutputStream {
   SocketOutputStream(Socket socket)
       : _socket = socket, _pendingWrites = new _BufferList2() {
-    _socket.setWriteHandler(_writeHandler);
-    _socket.setErrorHandler(_errorHandler);
+    _socket.writeHandler = _writeHandler;
+    _socket.errorHandler = _errorHandler;
   }
 
   bool write(List<int> buffer) {
     return _write(buffer, 0, buffer.length, false);
   }
 
   bool writeFrom(List<int> buffer, [int offset = 0, int len]) {
     return _write(buffer, offset, (len == null) ? buffer.length : len, true);
   }
 
   void end() {
     if (_ending || _ended) throw new StreamException("Stream ended");
     _ending = true;
     if (_pendingWrites.isEmpty()) {
       close();
     }
   }
 
   void close() {
-    _socket.setWriteHandler(null);
+    _socket.writeHandler = null;
     _pendingWrites.clear();
     _socket.close();
     _ended = true;
   }
 
   void set noPendingWriteHandler(void callback()) {
     _noPendingWriteHandler = callback;
-    _socket.setWriteHandler(_writeHandler);
+    _socket.writeHandler = _writeHandler;
   }
 
   void set closeHandler(void callback()) {
-    _socket.setCloseHandler(callback());
+    _socket.closeHandler = callback;
   }
 
   void set errorHandler(void callback()) {
-    _streamErrorHandler = callback();
+    _streamErrorHandler = callback;
   }
 
   bool _write(List<int> buffer, int offset, int len, bool copyBuffer) {
     if (_ending || _ended) throw new StreamException("Stream ended");
     if (len == null) len = buffer.length;
     int bytesWritten = 0;
     if (_pendingWrites.isEmpty()) {
       // If nothing is buffered write as much as possible and buffer
       // the rest.
       bytesWritten = _socket.writeList(buffer, offset, len);
       if (bytesWritten == len) return true;
     }
 
     // Place remaining data on the pending writes queue.
     if (copyBuffer) {
       List<int> newBuffer =
           buffer.getRange(offset + bytesWritten, buffer.length);
       _pendingWrites.add(newBuffer);
     } else {
       _pendingWrites.add(buffer, bytesWritten);
     }
   }
 
   void _writeHandler() {
-    _socket.setWriteHandler(_writeHandler);
+    _socket.writeHandler = _writeHandler;
     // Write as much buffered data to the socket as possible.
     while (!_pendingWrites.isEmpty()) {
       List<int> buffer = _pendingWrites.first;
       int offset = _pendingWrites.index;
       int bytesToWrite = buffer.length - offset;
       int bytesWritten = _socket.writeList(buffer, offset, bytesToWrite);
       _pendingWrites.removeBytes(bytesWritten);
       if (bytesWritten < bytesToWrite) return;
     }
 
@@ skipping 11 matching lines @@
     if (_streamErrorHandler != null) _streamErrorHandler();
   }
 
   Socket _socket;
   _BufferList2 _pendingWrites;
   bool _ending = false;
   bool _ended = false;
   var _noPendingWriteHandler;
   var _streamErrorHandler;
 }