Rename blahHandler to onBlah throughout dart:io.

runtime/bin/http_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.
 
 // 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 579 matching lines @@
   String get queryString() => _queryString;
   Map get queryParameters() => _queryParameters;
 
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
-  void _requestStartHandler(String method, String uri) {
+  void _onRequestStart(String method, String uri) {
     _method = method;
     _uri = uri;
     _parseRequestUri(uri);
   }
 
-  void _headerReceivedHandler(String name, String value) {
+  void _onHeaderReceived(String name, String value) {
     _setHeader(name, value);
   }
 
-  void _headersCompleteHandler() {
+  void _onHeadersComplete() {
     // Prepare for receiving data.
     _buffer = new _BufferList();
   }
 
-  void _dataReceivedHandler(List<int> data) {
+  void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
 
-  void _dataEndHandler() {
+  void _onDataEnd() {
     if (_inputStream != null) _inputStream._closeReceived();
   }
 
   // Escaped characters in uri are expected to have been parsed.
   void _parseRequestUri(String uri) {
     int position;
     position = uri.indexOf("?", 0);
     if (position == -1) {
       _path = HttpUtil.decodeUrlEncodedString(_uri);
       _queryString = null;
@@ skipping 79 matching lines @@
     return _write(buffer, copyBuffer);
   }
 
   bool _streamWriteFrom(List<int> buffer, int offset, int len) {
     return _writeList(buffer, offset, len);
   }
 
   void _streamClose() {
     _state = DONE;
     // Stop tracking no pending write events.
-    _httpConnection.outputStream.noPendingWriteHandler = null;
+    _httpConnection.outputStream.onNoPendingWrite = null;
     // Ensure that any trailing data is written.
     _writeDone();
     // If the connection is closing then close the output stream to
     // fully close the socket.
     if (_httpConnection._closing) {
       _httpConnection.outputStream.close();
     }
   }
 
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
-      _httpConnection.outputStream.noPendingWriteHandler = callback;
+      _httpConnection.outputStream.onNoPendingWrite = callback;
     }
   }
 
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
 
   void _streamSetErrorHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
@@ skipping 141 matching lines @@
   }
 
   void close() {
     _requestOrResponse._streamClose();
   }
 
   void destroy() {
     throw "Not implemented";
   }
 
-  void set noPendingWriteHandler(void callback()) {
+  void set onNoPendingWrite(void callback()) {
     _requestOrResponse._streamSetNoPendingWriteHandler(callback);
   }
 
-  void set closeHandler(void callback()) {
+  void set onClose(void callback()) {
     _requestOrResponse._streamSetCloseHandler(callback);
   }
 
-  void set errorHandler(void callback()) {
+  void set onError(void callback()) {
     _requestOrResponse._streamSetErrorHandler(callback);
   }
 
   _HttpRequestResponseBase _requestOrResponse;
 }
 
 
 class _HttpConnectionBase {
   _HttpConnectionBase() : _sendBuffers = new Queue(),
                           _httpParser = new HttpParser();
 
   void _connectionEstablished(Socket socket) {
     _socket = socket;
     // Register handler for socket events.
-    _socket.dataHandler = _dataHandler;
-    _socket.closeHandler = _closeHandler;
-    _socket.errorHandler = _errorHandler;
+    _socket.onData = _onData;
+    _socket.onClose = _onClose;
+    _socket.onError = _onError;
   }
 
   OutputStream get outputStream() {
     return _socket.outputStream;
   }
 
-  void _dataHandler() {
+  void _onData() {
     int available = _socket.available();
     if (available == 0) {
       return;
     }
 
     ByteArray buffer = new ByteArray(available);
     int bytesRead = _socket.readList(buffer, 0, available);
     if (bytesRead > 0) {
       int parsed = _httpParser.writeList(buffer, 0, bytesRead);
       if (parsed != bytesRead) {
         // TODO(sgjesse): Error handling.
         _socket.close();
       }
     }
   }
 
-  void _closeHandler() {
+  void _onClose() {
     // Client closed socket for writing. Socket should still be open
     // for writing the response.
     _closing = true;
-    if (_disconnectHandlerCallback != null) _disconnectHandlerCallback();
+    if (_onDisconnectCallback != null) _onDisconnectCallback();
   }
 
-  void _errorHandler() {
+  void _onError() {
     // If an error occours, treat the socket as closed.
-    _closeHandler();
-    if (_errorHandlerCallback != null) {
-      _errorHandlerCallback("Connection closed while sending data to client.");
+    _onClose();
+    if (_onErrorCallback != null) {
+      _onErrorCallback("Connection closed while sending data to client.");
     }
   }
 
-  void set disconnectHandler(void callback()) {
-    _disconnectHandlerCallback = callback;
+  void set onDisconnect(void callback()) {
+    _onDisconnectCallback = callback;
   }
 
-  void set errorHandler(void callback(String errorMessage)) {
-    _errorHandlerCallback = callback;
+  void set onError(void callback(String errorMessage)) {
+    _onErrorCallback = callback;
   }
 
   Socket _socket;
   bool _closing = false;  // Is the socket closed by the client?
   HttpParser _httpParser;
 
   Queue _sendBuffers;
 
-  Function _disconnectHandlerCallback;
-  Function _errorHandlerCallback;
+  Function _onDisconnectCallback;
+  Function _onErrorCallback;
 }
 
 
 // HTTP server connection over a socket.
 class _HttpConnection extends _HttpConnectionBase {
   _HttpConnection() {
     // Register HTTP parser callbacks.
     _httpParser.requestStart =
-        (method, uri) => _requestStartHandler(method, uri);
+        (method, uri) => _onRequestStart(method, uri);
     _httpParser.responseStart =
         (statusCode, reasonPhrase) =>
-            _responseStartHandler(statusCode, reasonPhrase);
+            _onResponseStart(statusCode, reasonPhrase);
     _httpParser.headerReceived =
-        (name, value) => _headerReceivedHandler(name, value);
-    _httpParser.headersComplete = () => _headersCompleteHandler();
-    _httpParser.dataReceived = (data) => _dataReceivedHandler(data);
-    _httpParser.dataEnd = () => _dataEndHandler();
+        (name, value) => _onHeaderReceived(name, value);
+    _httpParser.headersComplete = () => _onHeadersComplete();
+    _httpParser.dataReceived = (data) => _onDataReceived(data);
+    _httpParser.dataEnd = () => _onDataEnd();
   }
 
-  void _requestStartHandler(String method, String uri) {
+  void _onRequestStart(String method, String uri) {
     // Create new request and response objects for this request.
     _request = new _HttpRequest(this);
     _response = new _HttpResponse(this);
-    _request._requestStartHandler(method, uri);
+    _request._onRequestStart(method, uri);
   }
 
-  void _responseStartHandler(int statusCode, String reasonPhrase) {
+  void _onResponseStart(int statusCode, String reasonPhrase) {
     // TODO(sgjesse): Error handling.
   }
 
-  void _headerReceivedHandler(String name, String value) {
-    _request._headerReceivedHandler(name, value);
+  void _onHeaderReceived(String name, String value) {
+    _request._onHeaderReceived(name, value);
   }
 
-  void _headersCompleteHandler() {
-    _request._headersCompleteHandler();
+  void _onHeadersComplete() {
+    _request._onHeadersComplete();
     _response.keepAlive = _httpParser.keepAlive;
     if (requestReceived != null) {
       requestReceived(_request, _response);
     }
   }
 
-  void _dataReceivedHandler(List<int> data) {
-    _request._dataReceivedHandler(data);
+  void _onDataReceived(List<int> data) {
+    _request._onDataReceived(data);
   }
 
-  void _dataEndHandler() {
-    _request._dataEndHandler();
+  void _onDataEnd() {
+    _request._onDataEnd();
   }
 
   HttpRequest _request;
   HttpResponse _response;
 
   // Callbacks.
   var requestReceived;
 }
 
 
 // HTTP server waiting for socket connections. The connections are
 // managed by the server and as requests are received the request.
 class _HttpServer implements HttpServer {
   void listen(String host, int port, [int backlog = 5]) {
 
-    void connectionHandler(Socket socket) {
+    void onConnection(Socket socket) {
       // Accept the client connection.
       _HttpConnection connection = new _HttpConnection();
       connection._connectionEstablished(socket);
-      connection.requestReceived = _requestHandler;
+      connection.requestReceived = _onRequest;
       _connections.add(connection);
-      void disconnectHandler() {
+      void onDisconnect() {
         for (int i = 0; i < _connections.length; i++) {
           if (_connections[i] == connection) {
             _connections.removeRange(i, 1);
             break;
           }
         }
       }
-      connection.disconnectHandler = disconnectHandler;
-      void errorHandler(String errorMessage) {
-        if (_errorHandler != null) _errorHandler(errorMessage);
+      connection.onDisconnect = onDisconnect;
+      void onError(String errorMessage) {
+        if (_onError != null) _onError(errorMessage);
       }
-      connection.errorHandler = errorHandler;
+      connection.onError = onError;
     }
 
     // TODO(ajohnsen): Use Set once Socket is Hashable.
     _connections = new List<_HttpConnection>();
     _server = new ServerSocket(host, port, backlog);
-    _server.connectionHandler = connectionHandler;
+    _server.onConnection = onConnection;
   }
 
   void close() => _server.close();
   int get port() => _server.port;
 
-  void set errorHandler(void handler(String errorMessage)) {
-    _errorHandler = handler;
+  void set onError(void handler(String errorMessage)) {
+    _onError = handler;
   }
 
-  void set requestHandler(void handler(HttpRequest, HttpResponse)) {
-    _requestHandler = handler;
+  void set onRequest(void handler(HttpRequest, HttpResponse)) {
+    _onRequest = handler;
   }
 
   ServerSocket _server;  // The server listen socket.
   List<_HttpConnection> _connections;  // List of currently connected clients.
-  Function _requestHandler;
-  Function _errorHandler;
+  Function _onRequest;
+  Function _onError;
 }
 
 
 class _HttpClientRequest
     extends _HttpRequestResponseBase implements HttpClientRequest {
   static final int START = 0;
   static final int HEADERS_SENT = 1;
   static final int DONE = 2;
 
   _HttpClientRequest(String this._method,
@@ skipping 39 matching lines @@
     return _write(buffer, copyBuffer);
   }
 
   bool _streamWriteFrom(List<int> buffer, int offset, int len) {
     return _writeList(buffer, offset, len);
   }
 
   void _streamClose() {
     _state = DONE;
     // Stop tracking no pending write events.
-    _httpConnection.outputStream.noPendingWriteHandler = null;
+    _httpConnection.outputStream.onNoPendingWrite = null;
     // Ensure that any trailing data is written.
     _writeDone();
     // If the connection is closing then close the output stream to
     // fully close the socket.
     if (_httpConnection._closing) {
       _httpConnection.outputStream.close();
     }
   }
 
   void _streamSetNoPendingWriteHandler(callback()) {
     if (_state != DONE) {
-      _httpConnection.outputStream.noPendingWriteHandler = callback;
+      _httpConnection.outputStream.onNoPendingWrite = callback;
     }
   }
 
   void _streamSetCloseHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
 
   void _streamSetErrorHandler(callback()) {
     // TODO(sgjesse): Handle this.
   }
@@ skipping 47 matching lines @@
   int get reasonPhrase() { return _reasonPhrase; }
   Map get headers() => _headers;
 
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
-  void _requestStartHandler(String method, String uri) {
+  void _onRequestStart(String method, String uri) {
     // TODO(sgjesse): Error handling
   }
 
-  void _responseStartHandler(int statusCode, String reasonPhrase) {
+  void _onResponseStart(int statusCode, String reasonPhrase) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
   }
 
-  void _headerReceivedHandler(String name, String value) {
+  void _onHeaderReceived(String name, String value) {
     _setHeader(name, value);
   }
 
-  void _headersCompleteHandler() {
+  void _onHeadersComplete() {
     _buffer = new _BufferList();
-    if (_connection._responseHandler != null) {
-      _connection._responseHandler(this);
+    if (_connection._onResponse != null) {
+      _connection._onResponse(this);
     }
   }
 
-  void _dataReceivedHandler(List<int> data) {
+  void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
 
-  void _dataEndHandler() {
+  void _onDataEnd() {
     if (_inputStream != null) _inputStream._closeReceived();
   }
 
   // Delegate functions for the HttpInputStream implementation.
   int _streamAvailable() {
     return _buffer.length;
   }
 
   List<int> _streamRead(int bytesToRead) {
     return _buffer.readBytes(bytesToRead);
@@ skipping 16 matching lines @@
 
 class _HttpClientConnection
     extends _HttpConnectionBase implements HttpClientConnection {
   _HttpClientConnection(_HttpClient this._client);
 
   void _connectionEstablished(_SocketConnection socketConn) {
     super._connectionEstablished(socketConn._socket);
     _socketConn = socketConn;
     // Register HTTP parser callbacks.
     _httpParser.requestStart =
-        (method, uri) => _requestStartHandler(method, uri);
+        (method, uri) => _onRequestStart(method, uri);
     _httpParser.responseStart =
         (statusCode, reasonPhrase) =>
-            _responseStartHandler(statusCode, reasonPhrase);
+            _onResponseStart(statusCode, reasonPhrase);
     _httpParser.headerReceived =
-        (name, value) => _headerReceivedHandler(name, value);
-    _httpParser.headersComplete = () => _headersCompleteHandler();
-    _httpParser.dataReceived = (data) => _dataReceivedHandler(data);
-    _httpParser.dataEnd = () => _dataEndHandler();
+        (name, value) => _onHeaderReceived(name, value);
+    _httpParser.headersComplete = () => _onHeadersComplete();
+    _httpParser.dataReceived = (data) => _onDataReceived(data);
+    _httpParser.dataEnd = () => _onDataEnd();
   }
 
   HttpClientRequest open(String method, String uri) {
     _request = new _HttpClientRequest(method, uri, this);
     _request.keepAlive = true;
     _response = new _HttpClientResponse(this);
     return _request;
   }
 
-  void _requestStartHandler(String method, String uri) {
+  void _onRequestStart(String method, String uri) {
     // TODO(sgjesse): Error handling.
   }
 
-  void _responseStartHandler(int statusCode, String reasonPhrase) {
-    _response._responseStartHandler(statusCode, reasonPhrase);
+  void _onResponseStart(int statusCode, String reasonPhrase) {
+    _response._onResponseStart(statusCode, reasonPhrase);
   }
 
-  void _headerReceivedHandler(String name, String value) {
-    _response._headerReceivedHandler(name, value);
+  void _onHeaderReceived(String name, String value) {
+    _response._onHeaderReceived(name, value);
   }
 
-  void _headersCompleteHandler() {
-    _response._headersCompleteHandler();
+  void _onHeadersComplete() {
+    _response._onHeadersComplete();
   }
 
-  void _dataReceivedHandler(List<int> data) {
-    _response._dataReceivedHandler(data);
+  void _onDataReceived(List<int> data) {
+    _response._onDataReceived(data);
   }
 
-  void _dataEndHandler() {
+  void _onDataEnd() {
     if (_response.headers["connection"] == "close") {
       _socket.close();
     } else {
       _client._returnSocketConnection(_socketConn);
       _socket = null;
       _socketConn = null;
     }
-    _response._dataEndHandler();
+    _response._onDataEnd();
   }
 
-  void set requestHandler(void handler(HttpClientRequest request)) {
-    _requestHandler = handler;
+  void set onRequest(void handler(HttpClientRequest request)) {
+    _onRequest = handler;
   }
 
-  void set responseHandler(void handler(HttpClientResponse response)) {
-    _responseHandler = handler;
+  void set onResponse(void handler(HttpClientResponse response)) {
+    _onResponse = handler;
   }
 
-  Function _requestHandler;
-  Function _responseHandler;
+  Function _onRequest;
+  Function _onResponse;
 
   _HttpClient _client;
   _SocketConnection _socketConn;
   HttpClientRequest _request;
   HttpClientResponse _response;
 
   // Callbacks.
   var requestReceived;
 
 }
 
 
 // Class for holding keep-alive sockets in the cache for the HTTP
 // client together with the connection information.
 class _SocketConnection {
   _SocketConnection(String this._host,
                     int this._port,
                     Socket this._socket);
 
   void _markReturned() {
-    _socket.dataHandler = null;
-    _socket.closeHandler = null;
-    _socket.errorHandler = null;
+    _socket.onData = null;
+    _socket.onClose = null;
+    _socket.onError = null;
     _returnTime = new Date.now();
   }
 
   Duration _idleTime(Date now) => now.difference(_returnTime);
 
   String _host;
   int _port;
   Socket _socket;
   Date _returnTime;
 }
@@ skipping 36 matching lines @@
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
       String host, int port, String method, String path) {
 
     void _connectionOpened(_SocketConnection socketConn,
                            _HttpClientConnection connection) {
       connection._connectionEstablished(socketConn);
       HttpClientRequest request = connection.open(method, path);
-      if (connection._requestHandler != null) {
-        connection._requestHandler(request);
+      if (connection._onRequest != null) {
+        connection._onRequest(request);
       } else {
         request.outputStream.close();
       }
     }
 
     _HttpClientConnection connection = new _HttpClientConnection(this);
 
     // If there are active connections for this key get the first one
     // otherwise create a new one.
     Queue socketConnections = _openSockets[_connectionKey(host, port)];
     if (socketConnections == null || socketConnections.isEmpty()) {
       Socket socket = new Socket(host, port);
-      socket.connectHandler = () {
-        socket.errorHandler = null;
+      socket.onConnect = () {
+        socket.onError = null;
         _SocketConnection socketConn =
             new _SocketConnection(host, port, socket);
         _connectionOpened(socketConn, connection);
       };
-      socket.errorHandler = () {
-        if (_errorHandler !== null) {
-          _errorHandler(HttpStatus.NETWORK_CONNECT_TIMEOUT_ERROR);
+      socket.onError = () {
+        if (_onError !== null) {
+          _onError(HttpStatus.NETWORK_CONNECT_TIMEOUT_ERROR);
         }
       };
     } else {
       _SocketConnection socketConn = socketConnections.removeFirst();
       new Timer((ignored) => _connectionOpened(socketConn, connection), 0);
 
       // Get rid of eviction timer if there are no more active connections.
       if (socketConnections.isEmpty()) {
         _evictionTimer.cancel();
         _evictionTimer = null;
@@ skipping 39 matching lines @@
             });
       }
       _evictionTimer = new Timer.repeating(_handleEviction, 10000);
     }
 
     // Return connection.
     sockets.addFirst(socketConn);
     socketConn._markReturned();
   }
 
-  void set errorHandler(void callback(int status)) {
-    _errorHandler = callback;
+  void set onError(void callback(int status)) {
+    _onError = callback;
   }
 
-  Function _openHandler;
-  Function _errorHandler;
+  Function _onOpen;
+  Function _onError;
   Map<String, Queue<_SocketConnection>> _openSockets;
   Timer _evictionTimer;
   bool _shutdown;  // Has this HTTP client been shutdown?
 }
 
 
 class HttpUtil {
   static String decodeUrlEncodedString(String urlEncoded) {
     void invalidEscape() {
       // TODO(sgjesse): Handle the error.
@@ skipping 44 matching lines @@
       } else {
         value = queryString.substring(currentPosition, position);
         currentPosition = position + 1;
       }
       result[HttpUtil.decodeUrlEncodedString(name)] =
         HttpUtil.decodeUrlEncodedString(value);
     }
     return result;
   }
 }