Rename blahHandler to onBlah throughout dart:io.

runtime/bin/string_stream.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.
 
 // Interface for decoders decoding binary data into string data. The
 // decoder keeps track of line breaks during decoding.
 interface _StringDecoder {
   // Add more binary data to be decoded. The ownership of the buffer
   // is transfered to the decoder and the caller most not modify it any more.
   int write(List<int> buffer);
@@ skipping 209 matching lines @@
     }
     if (_encoding == "UTF-8") {
       _decoder = new _UTF8Decoder();
     } else if (_encoding == "ISO-8859-1") {
       _decoder = new _Latin1Decoder();
     } else if (_encoding == "ASCII") {
       _decoder = new _AsciiDecoder();
     } else {
       throw new StreamException("Unsupported encoding $_encoding");
     }
-    _input.dataHandler = _dataHandler;
-    _input.closeHandler = _closeHandler;
+    _input.onData = _onData;
+    _input.onClosed = _onClosed;
   }
 
   String read() {
     String result = _decoder.decoded;
     _checkInstallDataHandler();
     return result;
   }
 
   String readLine() {
     String decodedLine = _decoder.decodedLine;
     if (decodedLine == null) {
       if (_inputClosed) {
         // Last line might not have a line separator.
         decodedLine = _decoder.decoded;
         if (decodedLine != null &&
             decodedLine[decodedLine.length - 1] == '\r') {
           decodedLine = decodedLine.substring(0, decodedLine.length - 1);
         }
       }
     }
     _checkInstallDataHandler();
     return decodedLine;
   }
 
   String get encoding() => _encoding;
 
   bool get closed() => _inputClosed && _decoder.isEmpty();
 
-  void set dataHandler(void callback()) {
+  void set onData(void callback()) {
     _clientDataHandler = callback;
     _clientLineHandler = null;
     _checkInstallDataHandler();
     _checkScheduleCallback();
   }
 
-  void set lineHandler(void callback()) {
+  void set onLine(void callback()) {
     _clientLineHandler = callback;
     _clientDataHandler = null;
     _checkInstallDataHandler();
     _checkScheduleCallback();
   }
 
-  void set closeHandler(void callback()) {
+  void set onClosed(void callback()) {
     _clientCloseHandler = callback;
   }
 
-  void set errorHandler(void callback()) {
+  void set onError(void callback()) {
     _input.errorHandler = callback;
   }
 
-  void _dataHandler() {
+  void _onData() {
     _readData();
     if (!_decoder.isEmpty() && _clientDataHandler !== null) {
       _clientDataHandler();
     }
     if (_decoder.lineBreaks > 0 && _clientLineHandler !== null) {
       _clientLineHandler();
     }
     _checkScheduleCallback();
     _checkInstallDataHandler();
   }
 
-  void _closeHandler() {
+  void _onClosed() {
     _inputClosed = true;
     if (_decoder.isEmpty() && _clientCloseHandler != null) {
       _clientCloseHandler();
       _closed = true;
     } else {
       _checkScheduleCallback();
     }
   }
 
   void _readData() {
     List<int> data = _input.read();
     if (data !== null) {
       _decoder.write(data);
     }
   }
 
   void _checkInstallDataHandler() {
     if (_inputClosed ||
         (_clientDataHandler === null && _clientLineHandler === null)) {
-      _input.dataHandler = null;
+      _input.onData = null;
     } else if (_clientDataHandler !== null) {
       if (_decoder.isEmpty()) {
-        _input.dataHandler = _dataHandler;
+        _input.onData = _onData;
       } else {
-        _input.dataHandler = null;
+        _input.onData = null;
       }
     } else {
       assert(_clientLineHandler !== null);
       if (_decoder.lineBreaks == 0) {
-        _input.dataHandler = _dataHandler;
+        _input.onData = _onData;
       } else {
-        _input.dataHandler = null;
+        _input.onData = null;
       }
     }
   }
 
   // TODO(sgjesse): Find a better way of scheduling callbacks from
   // the event loop.
   void _checkScheduleCallback() {
     void issueDataCallback(Timer timer) {
       _scheduledDataCallback = null;
       if (_clientDataHandler !== null) {
@@ skipping 54 matching lines @@
   bool _inputClosed = false;  // Is the underlying input stream closed?
   bool _closed = false;  // Is this stream closed.
   bool _eof = false;  // Has all data been read from the decoder?
   Timer _scheduledDataCallback;
   Timer _scheduledLineCallback;
   Timer _scheduledCloseCallback;
   Function _clientDataHandler;
   Function _clientLineHandler;
   Function _clientCloseHandler;
 }