Rename blahHandler to onBlah throughout dart:io.

runtime/bin/file_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.
 
 class _FileInputStream extends _BaseDataInputStream implements InputStream {
   _FileInputStream(String name) {
     _file = new File(name);
     _data = [];
     _position = 0;
-    _file.errorHandler = (String s) {
+    _file.onError = (String s) {
       if (_clientErrorHandler != null) {
         _clientErrorHandler();
       }
     };
     _file.open();
-    _file.openHandler = (openedFile) {
+    _file.onOpen = (openedFile) {
       _readDataFromFile(openedFile);
     };
   }
 
   _FileInputStream.fromStdio(int fd) {
     assert(fd == 0);
     _file = _File._openStdioSync(fd);
     _data = [];
     _position = 0;
     _readDataFromFile(_file);
   }
 
   void _readDataFromFile(RandomAccessFile openedFile) {
-    openedFile.errorHandler = (String s) {
+    openedFile.onError = (String s) {
       if (_clientErrorHandler != null) {
         _clientErrorHandler();
       }
     };
     openedFile.length();
-    openedFile.lengthHandler = (length) {
+    openedFile.onLength = (length) {
       var contents = new ByteArray(length);
       if (length != 0) {
         openedFile.readList(contents, 0, length);
-        openedFile.readListHandler = (read) {
+        openedFile.onReadList = (read) {
           if (read != length) {
             if (_clientErrorHandler != null) {
               _clientErrorHandler();
             }
             _streamMarkedClosed = true;
             _checkScheduleCallbacks();
           } else {
             _data = contents;
             _streamMarkedClosed = true;
             _checkScheduleCallbacks();
@@ skipping 41 matching lines @@
   int _position;
   bool _closed = false;
 }
 
 
 class _FileOutputStream implements OutputStream {
   _FileOutputStream(String name, FileMode mode) {
     _pendingOperations = new List<List<int>>();
     var f = new File(name);
     f.open(mode);
-    f.openHandler = (openedFile) {
+    f.onOpen = (openedFile) {
       _file = openedFile;
       _setupFileHandlers();
       _processPendingOperations();
     };
-    f.errorHandler = (e) {
-      if (_errorHandler != null) _errorHandler();
+    f.onError = (e) {
+      if (_onError != null) _onError();
     };
   }
 
   _FileOutputStream.fromStdio(int fd) {
     assert(1 <= fd && fd <= 2);
     _file = _File._openStdioSync(fd);
     _setupFileHandlers();
   }
 
 
   void _setupFileHandlers() {
-    _file.errorHandler = (e) {
-      if (_errorHandler != null) _errorHandler();
+    _file.onError = (e) {
+      if (_onError != null) _onError();
     };
-    _file.noPendingWriteHandler = () {
-      if (!_streamMarkedClosed && _noPendingWriteHandler != null) {
-        _noPendingWriteHandler();
+    _file.onNoPendingWrite = () {
+      if (!_streamMarkedClosed && _onNoPendingWrite != null) {
+        _onNoPendingWrite();
       }
     };
-    _file.closeHandler = () {
-      if (_closeHandler != null) _closeHandler();
+    _file.onClose = () {
+      if (_onClose != null) _onClose();
     };
   }
 
   bool write(List<int> buffer, [bool copyBuffer = false]) {
     var data = buffer;
     if (copyBuffer) {
       var length = buffer.length;
       data = new ByteArray(length);
       data.setRange(0, length, buffer, 0);
     }
@@ skipping 19 matching lines @@
 
   void close() {
     if (_file == null) {
       _pendingOperations.add(null);
     } else if (!_streamMarkedClosed) {
       _file.close();
       _streamMarkedClosed = true;
     }
   }
 
-  void set noPendingWriteHandler(void callback()) {
-    _noPendingWriteHandler = callback;
+  void set onNoPendingWrite(void callback()) {
+    _onNoPendingWrite = callback;
   }
 
-  void set closeHandler(void callback()) {
-    _closeHandler = callback;
+  void set onClose(void callback()) {
+    _onClose = callback;
   }
 
-  void set errorHandler(void callback()) {
-    _errorHandler = callback;
+  void set onError(void callback()) {
+    _onError = callback;
   }
 
   void _processPendingOperations() {
     _pendingOperations.forEach((buffer) {
       (buffer != null) ? write(buffer) : close();
     });
     _pendingOperations = null;
   }
 
   void _write(List<int> buffer, int offset, int len) {
     _file.writeList(buffer, offset, len);
   }
 
   RandomAccessFile _file;
 
   // When this is set to true the stream is marked closed. When a
   // stream is marked closed no more data can be written.
   bool _streamMarkedClosed = false;
 
   // When this is set to true the close callback has been called and
   // the stream is fully closed.
   bool _closeCallbackCalled = false;
 
   // List of pending writes that were issued before the underlying
   // file was successfully opened.
   List<List<int>> _pendingOperations;
 
-  Function _noPendingWriteHandler;
-  Function _closeHandler;
-  Function _errorHandler;
+  Function _onNoPendingWrite;
+  Function _onClose;
+  Function _onError;
 }
 
 
 // Helper class containing static file helper methods.
 class _FileUtils {
   static final kExistsRequest = 0;
   static final kCreateRequest = 1;
   static final kDeleteRequest = 2;
   static final kOpenRequest = 3;
   static final kFullPathRequest = 4;
@@ skipping 101 matching lines @@
 
 // Class for encapsulating the native implementation of files.
 class _File implements File {
   // Constructor for file.
   _File(String this._name) : _asyncUsed = false;
 
   void exists() {
     _ensureFileService();
     _asyncUsed = true;
     if (_name is !String) {
-      if (_errorHandler != null) {
-        _errorHandler('File name is not a string: $_name');
+      if (_onError != null) {
+        _onError('File name is not a string: $_name');
       }
       return;
     }
     List request = new List(2);
     request[0] = _FileUtils.kExistsRequest;
     request[1] = _name;
     _fileService.call(request).receive((exists, replyTo) {
-      if (_existsHandler != null) _existsHandler(exists);
+      if (_onExists != null) _onExists(exists);
     });
   }
 
   bool existsSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (_name is !String) {
       throw new FileIOException('File name is not a string: $_name');
     }
     return _FileUtils.exists(_name);
   }
 
   void create() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kCreateRequest;
     request[1] = _name;
     _fileService.call(request).receive((created, replyTo) {
       if (created) {
-        if (_createHandler != null) _createHandler();
-      } else if (_errorHandler != null) {
-        _errorHandler("Cannot create file: $_name");
+        if (_onCreate != null) _onCreate();
+      } else if (_onError != null) {
+        _onError("Cannot create file: $_name");
       }
     });
   }
 
   void createSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file: $_name");
     }
   }
 
   void delete() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDeleteRequest;
     request[1] = _name;
     _fileService.call(request).receive((deleted, replyTo) {
       if (deleted) {
-        if (_deleteHandler != null) _deleteHandler();
-      } else if (_errorHandler != null) {
-        _errorHandler("Cannot delete file: $_name");
+        if (_onDelete != null) _onDelete();
+      } else if (_onError != null) {
+        _onError("Cannot delete file: $_name");
       }
     });
   }
 
   void deleteSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool deleted = _FileUtils.checkedDelete(_name);
     if (!deleted) {
       throw new FileIOException("Cannot delete file: $_name");
     }
   }
 
   void directory() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDirectoryRequest;
     request[1] = _name;
     _fileService.call(request).receive((path, replyTo) {
       if (path != null) {
-        if (_directoryHandler != null) _directoryHandler(new Directory(path));
-      } else if (_errorHandler != null) {
-        _errorHandler("Cannot get directory for: ${_name}");
+        if (_onDirectory != null) _onDirectory(new Directory(path));
+      } else if (_onError != null) {
+        _onError("Cannot get directory for: ${_name}");
       }
     });
   }
 
   Directory directorySync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (!existsSync()) {
       throw new FileIOException("Cannot get directory for: $_name");
     }
     return new Directory(_FileUtils.directory(_name));
   }
 
   void open([FileMode mode = FileMode.READ]) {
     _ensureFileService();
     _asyncUsed = true;
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
-      if (_errorHandler != null) {
-        _errorHandler("Unknown file mode. Use FileMode.READ, FileMode.WRITE " +
-                      "or FileMode.APPEND.");
+      if (_onError != null) {
+        _onError("Unknown file mode. Use FileMode.READ, FileMode.WRITE " +
+                 "or FileMode.APPEND.");
         return;
       }
     }
     List request = new List(3);
     request[0] = _FileUtils.kOpenRequest;
     request[1] = _name;
     request[2] = mode._mode;  // Direct int value for serialization.
     _fileService.call(request).receive((id, replyTo) {
-      var handler = _openHandler;
+      var handler = _onOpen;
       if (handler === null) {
         // If no open handler is present, close the file immediately to
         // avoid leaking an open file descriptor.
         handler = (file) => file.close();
       }
       if (id != 0) {
         var randomAccessFile = new _RandomAccessFile(id, _name);
         handler(randomAccessFile);
-      } else if (_errorHandler != null) {
-        _errorHandler("Cannot open file: $_name");
+      } else if (_onError != null) {
+        _onError("Cannot open file: $_name");
       }
     });
   }
 
   RandomAccessFile openSync([FileMode mode = FileMode.READ]) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (mode != FileMode.READ &&
@@ skipping 18 matching lines @@
   }
 
   void fullPath() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kFullPathRequest;
     request[1] = _name;
     _fileService.call(request).receive((result, replyTo) {
       if (result != null) {
-        if (_fullPathHandler != null) _fullPathHandler(result);
-      } else if (_errorHandler != null) {
-        _errorHandler("fullPath failed");
+        if (_onFullPath != null) _onFullPath(result);
+      } else if (_onError != null) {
+        _onError("fullPath failed");
       }
     });
   }
 
   String fullPathSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     String result = _FileUtils.checkedFullPath(_name);
@@ skipping 13 matching lines @@
       throw new FileIOException(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     return new _FileOutputStream(_name, mode);
   }
 
   void readAsBytes() {
     _asyncUsed = true;
     var chunks = new _BufferList();
     var stream = openInputStream();
-    stream.closeHandler = () {
-      if (_readAsBytesHandler != null) {
-        _readAsBytesHandler(chunks.readBytes(chunks.length));
+    stream.onClose = () {
+      if (_onReadAsBytes != null) {
+        _onReadAsBytes(chunks.readBytes(chunks.length));
       }
     };
-    stream.dataHandler = () {
+    stream.onData = () {
       var chunk = stream.read();
       chunks.add(chunk);
     };
-    stream.errorHandler = () {
-      if (_errorHandler != null) {
-        _errorHandler("Failed to read file as bytes: $_name");
+    stream.onError = () {
+      if (_onError != null) {
+        _onError("Failed to read file as bytes: $_name");
       }
     };
   }
 
   List<int> readAsBytesSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     var opened = openSync();
@@ skipping 15 matching lines @@
     } else if (encoding == "ASCII") {
       return new _AsciiDecoder();
     }
     throw new FileIOException("Unsupported encoding $_encoding");
   }
 
   void readAsText([String encoding = "UTF-8"]) {
     _asyncUsed = true;
     var decoder = _getDecoder(encoding);
     readAsBytes();
-    readAsBytesHandler = (bytes) {
-      if (_readAsTextHandler != null) {
+    onReadAsBytes = (bytes) {
+      if (_onReadAsText != null) {
         try {
           decoder.write(bytes);
         } catch (var e) {
-          if (_errorHandler != null) {
-            _errorHandler(e.toString());
+          if (_onError != null) {
+            _onError(e.toString());
             return;
           }
         }
-        _readAsTextHandler(decoder.decoded);
+        _onReadAsText(decoder.decoded);
       }
     };
   }
 
   String readAsTextSync([String encoding = "UTF-8"]) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     var decoder = _getDecoder(encoding);
@@ skipping 15 matching lines @@
     if (data != null) {
       result.add(data);
     }
     return result;
   }
 
   void readAsLines([String encoding = "UTF-8"]) {
     _asyncUsed = true;
     var decoder = _getDecoder(encoding);
     readAsBytes();
-    readAsBytesHandler = (bytes) {
-      if (_readAsLinesHandler != null) {
+    onReadAsBytes = (bytes) {
+      if (_onReadAsLines != null) {
         try {
           decoder.write(bytes);
         } catch (var e) {
-          if (_errorHandler != null) {
-            _errorHandler(e.toString());
+          if (_onError != null) {
+            _onError(e.toString());
             return;
           }
         }
-        _readAsLinesHandler(_getDecodedLines(decoder));
+        _onReadAsLines(_getDecodedLines(decoder));
       }
     };
   }
 
   List<String> readAsLinesSync([String encoding = "UTF-8"]) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     var decoder = _getDecoder(encoding);
     List<int> bytes = readAsBytesSync();
     decoder.write(bytes);
     return _getDecodedLines(decoder);
   }
 
   String get name() => _name;
 
-  void set existsHandler(void handler(bool exists)) {
-    _existsHandler = handler;
+  void set onExists(void handler(bool exists)) {
+    _onExists = handler;
   }
 
-  void set createHandler(void handler()) {
-    _createHandler = handler;
+  void set onCreate(void handler()) {
+    _onCreate = handler;
   }
 
-  void set deleteHandler(void handler()) {
-    _deleteHandler = handler;
+  void set onDelete(void handler()) {
+    _onDelete = handler;
   }
 
-  void set directoryHandler(void handler(Directory directory)) {
-    _directoryHandler = handler;
+  void set onDirectory(void handler(Directory directory)) {
+    _onDirectory = handler;
   }
 
-  void set openHandler(void handler(RandomAccessFile file)) {
-    _openHandler = handler;
+  void set onOpen(void handler(RandomAccessFile file)) {
+    _onOpen = handler;
   }
 
-  void set readAsBytesHandler(void handler(List<int> bytes)) {
-    _readAsBytesHandler = handler;
+  void set onReadAsBytes(void handler(List<int> bytes)) {
+    _onReadAsBytes = handler;
   }
 
-  void set readAsTextHandler(void handler(String text)) {
-    _readAsTextHandler = handler;
+  void set onReadAsText(void handler(String text)) {
+    _onReadAsText = handler;
   }
 
-  void set readAsLinesHandler(void handler(List<String> lines)) {
-    _readAsLinesHandler = handler;
+  void set onReadAsLines(void handler(List<String> lines)) {
+    _onReadAsLines = handler;
   }
 
-  void set fullPathHandler(void handler(String)) {
-    _fullPathHandler = handler;
+  void set onFullPath(void handler(String)) {
+    _onFullPath = handler;
   }
 
-  void set errorHandler(void handler(String error)) {
-    _errorHandler = handler;
+  void set onError(void handler(String error)) {
+    _onError = handler;
   }
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils.newServicePort();
     }
   }
 
   String _name;
   bool _asyncUsed;
 
   SendPort _fileService;
 
-  Function _existsHandler;
-  Function _createHandler;
-  Function _deleteHandler;
-  Function _directoryHandler;
-  Function _openHandler;
-  Function _readAsBytesHandler;
-  Function _readAsTextHandler;
-  Function _readAsLinesHandler;
-  Function _fullPathHandler;
-  Function _errorHandler;
+  Function _onExists;
+  Function _onCreate;
+  Function _onDelete;
+  Function _onDirectory;
+  Function _onOpen;
+  Function _onReadAsBytes;
+  Function _onReadAsText;
+  Function _onReadAsLines;
+  Function _onFullPath;
+  Function _onError;
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name) : _asyncUsed = false;
 
   void close() {
     if (_id == 0) return;
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kCloseRequest;
     request[1] = _id;
     // Set the id_ to 0 (NULL) to ensure the no more async requests
     // can be issues for this file.
     _id = 0;
     _fileService.call(request).receive((result, replyTo) {
       if (result != -1) {
         _id = result;
-        if (_closeHandler != null) _closeHandler();
-      } else if (_errorHandler != null) {
-        _errorHandler("Cannot close file: $_name");
+        if (_onClose != null) _onClose();
+      } else if (_onError != null) {
+        _onError("Cannot close file: $_name");
       }
     });
   }
 
   void closeSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     var id = _FileUtils.close(_id);
     if (id == -1) {
       throw new FileIOException("Cannot close file: $_name");
     }
     _id = id;
   }
 
   void readByte() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kReadByteRequest;
     request[1] = _id;
     _fileService.call(request).receive((result, replyTo) {
       if (result != -1) {
-        if (_readByteHandler != null) _readByteHandler(result);
-      } else if (_errorHandler != null) {
-        _errorHandler("readByte failed");
+        if (_onReadByte != null) _onReadByte(result);
+      } else if (_onError != null) {
+        _onError("readByte failed");
       }
     });
   }
 
   int readByteSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.readByte(_id);
     if (result == -1) {
       throw new FileIOException("readByte failed");
     }
     return result;
   }
 
   void readList(List<int> buffer, int offset, int bytes) {
     _ensureFileService();
     _asyncUsed = true;
     if (buffer is !List || offset is !int || bytes is !int) {
-      if (_errorHandler != null) {
-        _errorHandler("Invalid arguments to readList");
+      if (_onError != null) {
+        _onError("Invalid arguments to readList");
       }
       return;
     };
     List request = new List(3);
     request[0] = _FileUtils.kReadListRequest;
     request[1] = _id;
     request[2] = bytes;
     _fileService.call(request).receive((result, replyTo) {
       if (result is List && result.length == 2 && result[0] != -1) {
         var read = result[0];
         var data = result[1];
         buffer.setRange(offset, read, data);
-        if (_readListHandler != null) _readListHandler(read);
+        if (_onReadList != null) _onReadList(read);
         return;
-      } else if (_errorHandler != null) {
-        _errorHandler(result is String ? result : "readList failed");
+      } else if (_onError != null) {
+        _onError(result is String ? result : "readList failed");
       }
     });
   }
 
   int readListSync(List<int> buffer, int offset, int bytes) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (buffer is !List || offset is !int || bytes is !int) {
       throw new FileIOException("Invalid arguments to readList");
     }
     if (bytes == 0) return 0;
     int index =
         _FileUtils.checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     int result = _FileUtils.readList(_id, buffer, offset, bytes);
     if (result == -1) {
       throw new FileIOException("readList failed");
     }
     return result;
   }
 
   void writeByte(int value) {
     _ensureFileService();
     _asyncUsed = true;
     if (value is !int) {
-      if (_errorHandler != null) {
-        _errorHandler("Invalid argument to writeByte");
+      if (_onError != null) {
+        _onError("Invalid argument to writeByte");
       }
       return;
     }
     List request = new List(3);
     request[0] = _FileUtils.kWriteByteRequest;
     request[1] = _id;
     request[2] = value;
     _writeEnqueued();
     _fileService.call(request).receive((result, replyTo) {
       _writeCompleted();
-      if (result == -1 && _errorHandler !== null) {
-        _errorHandler("writeByte failed");
+      if (result == -1 && _onError !== null) {
+        _onError("writeByte failed");
       }
     });
   }
 
   int writeByteSync(int value) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (value is !int) {
       throw new FileIOException("Invalid argument to writeByte");
     }
     int result = _FileUtils.writeByte(_id, value);
     if (result == -1) {
       throw new FileIOException("writeByte failed");
     }
     return result;
   }
 
   void writeList(List<int> buffer, int offset, int bytes) {
     _ensureFileService();
     _asyncUsed = true;
     if (buffer is !List || offset is !int || bytes is !int) {
-      if (_errorHandler != null) {
-        _errorHandler("Invalid arguments to writeList");
+      if (_onError != null) {
+        _onError("Invalid arguments to writeList");
       }
       return;
     }
 
     List result =
         _FileUtils.ensureFastAndSerializableBuffer(buffer, offset, bytes);
     List outBuffer = result[0];
     int outOffset = result[1];
 
     List request = new List(5);
     request[0] = _FileUtils.kWriteListRequest;
     request[1] = _id;
     request[2] = outBuffer;
     request[3] = outOffset;
     request[4] = bytes;
     _writeEnqueued();
     _fileService.call(request).receive((result, replyTo) {
       _writeCompleted();
-      if (result == -1 && _errorHandler !== null) {
-        _errorHandler("writeList failed");
+      if (result == -1 && _onError !== null) {
+        _onError("writeList failed");
       }
     });
   }
 
   int writeListSync(List<int> buffer, int offset, int bytes) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (buffer is !List || offset is !int || bytes is !int) {
@@ skipping 15 matching lines @@
   void writeString(String string) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kWriteStringRequest;
     request[1] = _id;
     request[2] = string;
     _writeEnqueued();
     _fileService.call(request).receive((result, replyTo) {
       _writeCompleted();
-      if (result == -1 && _errorHandler !== null) {
-        _errorHandler("writeString failed");
+      if (result == -1 && _onError !== null) {
+        _onError("writeString failed");
       }
     });
   }
 
   int writeStringSync(String string) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.checkedWriteString(_id, string);
     if (result == -1) {
       throw new FileIOException("writeString failed");
     }
     return result;
   }
 
   void position() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kPositionRequest;
     request[1] = _id;
     _fileService.call(request).receive((result, replyTo) {
       if (result != -1) {
-        if (_positionHandler != null) _positionHandler(result);
-      } else if (_errorHandler != null) {
-        _errorHandler("position failed");
+        if (_onPosition != null) _onPosition(result);
+      } else if (_onError != null) {
+        _onError("position failed");
       }
     });
   }
 
   int positionSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.position(_id);
     if (result == -1) {
       throw new FileIOException("position failed");
     }
     return result;
   }
 
   void setPosition(int position) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kSetPositionRequest;
     request[1] = _id;
     request[2] = position;
     _fileService.call(request).receive((result, replyTo) {
       if (result) {
-        if (_setPositionHandler != null) _setPositionHandler();
-      } else if (_errorHandler != null) {
-        _errorHandler("setPosition failed");
+        if (_onSetPosition != null) _onSetPosition();
+      } else if (_onError != null) {
+        _onError("setPosition failed");
       }
     });
   }
 
   void setPositionSync(int position) {
     _ensureFileService();
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool result = _FileUtils.setPosition(_id, position);
     if (result == false) {
       throw new FileIOException("setPosition failed");
     }
   }
 
   void truncate(int length) {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kTruncateRequest;
     request[1] = _id;
     request[2] = length;
     _fileService.call(request).receive((result, replyTo) {
       if (result) {
-        if (_truncateHandler != null) _truncateHandler();
-      } else if (_errorHandler != null) {
-        _errorHandler("truncate failed");
+        if (_onTruncate != null) _onTruncate();
+      } else if (_onError != null) {
+        _onError("truncate failed");
       }
     });
   }
 
   void truncateSync(int length) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool result = _FileUtils.truncate(_id, length);
     if (result == false) {
       throw new FileIOException("truncate failed");
     }
   }
 
   void length() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kLengthRequest;
     request[1] = _id;
     _fileService.call(request).receive((result, replyTo) {
       if (result != -1) {
-        if (_lengthHandler != null) _lengthHandler(result);
-      } else if (_errorHandler != null) {
-        _errorHandler("length failed");
+        if (_onLength != null) _onLength(result);
+      } else if (_onError != null) {
+        _onError("length failed");
       }
     });
   }
 
   int lengthSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.length(_id);
     if (result == -1) {
       throw new FileIOException("length failed");
     }
     return result;
   }
 
   void flush() {
     _ensureFileService();
     _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kFlushRequest;
     request[1] = _id;
     _fileService.call(request).receive((result, replyTo) {
       if (result != -1) {
-        if (_flushHandler != null) _flushHandler();
-      } else if (_errorHandler != null) {
-        _errorHandler("flush failed");
+        if (_onFlush != null) _onFlush();
+      } else if (_onError != null) {
+        _onError("flush failed");
       }
     });
   }
 
   void flushSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.flush(_id);
     if (result == -1) {
       throw new FileIOException("flush failed");
     }
   }
 
   String get name() => _name;
 
-  void set errorHandler(void handler(String error)) {
-    _errorHandler = handler;
+  void set onError(void handler(String error)) {
+    _onError = handler;
   }
 
-  void set closeHandler(void handler()) {
-    _closeHandler = handler;
+  void set onClose(void handler()) {
+    _onClose = handler;
   }
 
-  void set readByteHandler(void handler(int byte)) {
-    _readByteHandler = handler;
+  void set onReadByte(void handler(int byte)) {
+    _onReadByte = handler;
   }
 
-  void set readListHandler(void handler(int read)) {
-    _readListHandler = handler;
+  void set onReadList(void handler(int read)) {
+    _onReadList = handler;
   }
 
-  void set noPendingWriteHandler(void handler()) {
-    _noPendingWriteHandler = handler;
+  void set onNoPendingWrite(void handler()) {
+    _onNoPendingWrite = handler;
     if (_pendingWrites == 0) {
       _noPendingWriteTimer = new Timer((t) {
-        if (_noPendingWriteHandler != null) _noPendingWriteHandler();
+        if (_onNoPendingWrite != null) _onNoPendingWrite();
       }, 0);
     }
   }
 
-  void set positionHandler(void handler(int pos)) {
-    _positionHandler = handler;
+  void set onPosition(void handler(int pos)) {
+    _onPosition = handler;
   }
 
-  void set setPositionHandler(void handler()) {
-    _setPositionHandler = handler;
+  void set onSetPosition(void handler()) {
+    _onSetPosition = handler;
   }
 
-  void set truncateHandler(void handler()) {
-    _truncateHandler = handler;
+  void set onTruncate(void handler()) {
+    _onTruncate = handler;
   }
 
-  void set lengthHandler(void handler(int length)) {
-    _lengthHandler = handler;
+  void set onLength(void handler(int length)) {
+    _onLength = handler;
   }
 
-  void set flushHandler(void handler()) {
-    _flushHandler = handler;
+  void set onFlush(void handler()) {
+    _onFlush = handler;
   }
 
   void _ensureFileService() {
     if (_fileService == null) {
       _fileService = _FileUtils.newServicePort();
     }
   }
 
   void _writeEnqueued() {
     _pendingWrites++;
     if (_noPendingWriteTimer != null) {
       _noPendingWriteTimer.cancel();
       _noPendingWriteTimer = null;
     }
   }
 
   void  _writeCompleted() {
     _pendingWrites--;
-    if (_pendingWrites == 0 && _noPendingWriteHandler != null) {
-      _noPendingWriteHandler();
+    if (_pendingWrites == 0 && _onNoPendingWrite != null) {
+      _onNoPendingWrite();
     }
   }
 
 
   String _name;
   int _id;
   bool _asyncUsed;
   int _pendingWrites = 0;
 
   SendPort _fileService;
 
   Timer _noPendingWriteTimer;
 
-  Function _closeHandler;
-  Function _readByteHandler;
-  Function _readListHandler;
-  Function _noPendingWriteHandler;
-  Function _positionHandler;
-  Function _setPositionHandler;
-  Function _truncateHandler;
-  Function _lengthHandler;
-  Function _flushHandler;
-  Function _errorHandler;
+  Function _onClose;
+  Function _onReadByte;
+  Function _onReadList;
+  Function _onNoPendingWrite;
+  Function _onPosition;
+  Function _onSetPosition;
+  Function _onTruncate;
+  Function _onLength;
+  Function _onFlush;
+  Function _onError;
 }