Use patching for dart:io.

lib/io/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)
       : _data = const [],
         _position = 0,
         _filePosition = 0 {
     var file = new File(name);
@@ skipping 311 matching lines @@
 const int _READ_LIST_REQUEST = 16;
 const int _WRITE_LIST_REQUEST = 17;
 const int _WRITE_STRING_REQUEST = 18;
 
 // Base class for _File and _RandomAccessFile with shared functions.
 class _FileBase {
   bool _isErrorResponse(response) {
     return response is List && response[0] != _SUCCESS_RESPONSE;
   }
 
-  Exception _exceptionFromResponse(response, String message) {
+  _exceptionFromResponse(response, String message) {
     assert(_isErrorResponse(response));
     switch (response[_ERROR_RESPONSE_ERROR_TYPE]) {
       case _ILLEGAL_ARGUMENT_RESPONSE:
         return new ArgumentError();
       case _OSERROR_RESPONSE:
         var err = new OSError(response[_OSERROR_RESPONSE_MESSAGE],
                               response[_OSERROR_RESPONSE_ERROR_CODE]);
         return new FileIOException(message, err);
       case _FILE_CLOSED_RESPONSE:
         return new FileIOException("File closed");
       default:
         return new Exception("Unknown error");
     }
   }
 }
 
-SendPort _newServicePort() native "File_NewServicePort";
+// TODO(ager): The only reason for this class is that the patching

[Søren Gjesse, 2012/10/30 09:28:32]

Answers previous comment. Then add a TODO there as well.

[Mads Ager (google), 2012/10/30 11:12:40]

Done.

+// mechanism doesn't seem to like patching a private top level
+// function.
+class _FileUtils {
+  external static SendPort _newServicePort();
+}
 
 // Class for encapsulating the native implementation of files.
 class _File extends _FileBase implements File {
   // Constructor for file.
   _File(String this._name) {
     if (_name is! String) {
       throw new ArgumentError('${NoSuchMethodError.safeToString(_name)} '
                               'is not a String');
     }
   }
 
   // Constructor from Path for file.
   _File.fromPath(Path path) : this(path.toNativePath());
 
   Future<bool> exists() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _EXISTS_REQUEST;
     request[1] = _name;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot open file '$_name'");
       }
       return response;
     });
   }
 
-
-  static _exists(String name) native "File_Exists";
+  external static _exists(String name);
 
   bool existsSync() {
     var result = _exists(_name);
     throwIfError(result, "Cannot check existence of file '$_name'");
     return result;
   }
 
   Future<File> create() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _CREATE_REQUEST;
     request[1] = _name;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot create file '$_name'");
       }
       return this;
     });
   }
 
-  static _create(String name) native "File_Create";
+  external static _create(String name);
 
   void createSync() {
     var result = _create(_name);
     throwIfError(result, "Cannot create file '$_name'");
   }
 
   Future<File> delete() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _DELETE_REQUEST;
     request[1] = _name;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot delete file '$_name'");
       }
       return this;
     });
   }
 
-  static _delete(String name) native "File_Delete";
+  external static _delete(String name);
 
   void deleteSync() {
     var result = _delete(_name);
     throwIfError(result, "Cannot delete file '$_name'");
   }
 
   Future<Directory> directory() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _DIRECTORY_REQUEST;
     request[1] = _name;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve directory for "
                                      "file '$_name'");
       }
       return new Directory(response);
     });
   }
 
-  static _directory(String name) native "File_Directory";
+  external static _directory(String name);
 
   Directory directorySync() {
     var result = _directory(name);
     throwIfError(result, "Cannot retrieve directory for file '$_name'");
     return new Directory(result);
   }
 
   Future<RandomAccessFile> open([FileMode mode = FileMode.READ]) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
@@ skipping 26 matching lines @@
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve length of "
                                      "file '$_name'");
       }
       return response;
     });
   }
 
 
-  static _lengthFromName(String name) native "File_LengthFromName";
+  external static _lengthFromName(String name);
 
   int lengthSync() {
     var result = _lengthFromName(_name);
     throwIfError(result, "Cannot retrieve length of file '$_name'");
     return result;
   }
 
   Future<Date> lastModified() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _LAST_MODIFIED_REQUEST;
     request[1] = _name;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve modification time "
                                      "for file '$_name'");
       }
       return new Date.fromMillisecondsSinceEpoch(response);
     });
   }
 
-  static _lastModified(String name) native "File_LastModified";
+  external static _lastModified(String name);
 
   Date lastModifiedSync() {
     var ms = _lastModified(name);
     throwIfError(ms, "Cannot retrieve modification time for file '$_name'");
     return new Date.fromMillisecondsSinceEpoch(ms);
   }
 
-  static _open(String name, int mode) native "File_Open";
+  external static _open(String name, int mode);
 
   RandomAccessFile openSync([FileMode mode = FileMode.READ]) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException("Unknown file mode. Use FileMode.READ, "
                                 "FileMode.WRITE or FileMode.APPEND.");
     }
     var id = _open(_name, mode._mode);
     throwIfError(id, "Cannot open file '$_name'");
     return new _RandomAccessFile(id, _name);
   }
 
-  static int _openStdio(int fd) native "File_OpenStdio";
+  external static int _openStdio(int fd);
 
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _openStdio(fd);
     if (id == 0) {
       throw new FileIOException("Cannot open stdio file for: $fd");
     }
     return new _RandomAccessFile(id, "");
   }
 
   Future<String> fullPath() {
     _ensureFileService();
     List request = new List(2);
     request[0] = _FULL_PATH_REQUEST;
     request[1] = _name;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "Cannot retrieve full path"
                                      " for '$_name'");
       }
       return response;
     });
   }
 
-  static _fullPath(String name) native "File_FullPath";
+  external static _fullPath(String name);
 
   String fullPathSync() {
     var result = _fullPath(_name);
     throwIfError(result, "Cannot retrieve full path for file '$_name'");
     return result;
   }
 
   InputStream openInputStream() {
     return new _FileInputStream(_name);
   }
@@ skipping 85 matching lines @@
     var decoder = _StringDecoders.decoder(encoding);
     List<int> bytes = readAsBytesSync();
     decoder.write(bytes);
     return _getDecodedLines(decoder);
   }
 
   String get name => _name;
 
   void _ensureFileService() {
     if (_fileService == null) {
-      _fileService = _newServicePort();
+      _fileService = _FileUtils._newServicePort();
     }
   }
 
   static throwIfError(Object result, String msg) {
     if (result is OSError) {
       throw new FileIOException(msg, result);
     }
   }
 
   final String _name;
@@ skipping 18 matching lines @@
     return _fileService.call(request).transform((result) {
       if (result != -1) {
         _id = result;
         return this;
       } else {
         throw new FileIOException("Cannot close file '$_name'");
       }
     });
   }
 
-  static int _close(int id) native "File_Close";
+  external static int _close(int id);
 
   void closeSync() {
     _checkNotClosed();
     var id = _close(_id);
     if (id == -1) {
       throw new FileIOException("Cannot close file '$_name'");
     }
     _id = id;
   }
 
   Future<int> readByte() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _READ_BYTE_REQUEST;
     request[1] = _id;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "readByte failed for file '$_name'");
       }
       return response;
     });
   }
 
-  static _readByte(int id) native "File_ReadByte";
+  external static _readByte(int id);
 
   int readByteSync() {
     _checkNotClosed();
     var result = _readByte(_id);
     if (result is OSError) {
       throw new FileIOException("readByte failed for file '$_name'", result);
     }
     return result;
   }
 
@@ skipping 28 matching lines @@
   }
 
   static void _checkReadWriteListArguments(int length, int offset, int bytes) {
     if (offset < 0) throw new IndexOutOfRangeException(offset);
     if (bytes < 0) throw new IndexOutOfRangeException(bytes);
     if ((offset + bytes) > length) {
       throw new IndexOutOfRangeException(offset + bytes);
     }
   }
 
-  static _readList(int id, List<int> buffer, int offset, int bytes)
-      native "File_ReadList";
+  external static _readList(int id, List<int> buffer, int offset, int bytes);
 
   int readListSync(List<int> buffer, int offset, int bytes) {
     _checkNotClosed();
     if (buffer is !List || offset is !int || bytes is !int) {
       throw new FileIOException(
           "Invalid arguments to readList for file '$_name'");
     }
     if (bytes == 0) return 0;
     _checkReadWriteListArguments(buffer.length, offset, bytes);
     var result = _readList(_id, buffer, offset, bytes);
@@ skipping 24 matching lines @@
     request[2] = value;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "writeByte failed for file '$_name'");
       }
       return this;
     });
   }
 
-  static _writeByte(int id, int value) native "File_WriteByte";
+  external static _writeByte(int id, int value);
 
   int writeByteSync(int value) {
     _checkNotClosed();
     if (value is !int) {
       throw new FileIOException(
           "Invalid argument to writeByte for file '$_name'");
     }
     var result = _writeByte(_id, value);
     if (result is OSError) {
       throw new FileIOException("writeByte failed for file '$_name'",
@@ skipping 36 matching lines @@
     request[4] = bytes;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "writeList failed for file '$_name'");
       }
       return this;
     });
   }
 
-  static _writeList(int id, List<int> buffer, int offset, int bytes)
-      native "File_WriteList";
+  external static _writeList(int id, List<int> buffer, int offset, int bytes);
 
   int writeListSync(List<int> buffer, int offset, int bytes) {
     _checkNotClosed();
     if (buffer is !List || offset is !int || bytes is !int) {
       throw new FileIOException(
           "Invalid arguments to writeList for file '$_name'");
     }
     if (bytes == 0) return 0;
     _checkReadWriteListArguments(buffer.length, offset, bytes);
     _BufferAndOffset bufferAndOffset =
@@ skipping 17 matching lines @@
     request[2] = string;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "writeString failed for file '$_name'");
       }
       return this;
     });
   }
 
-  static _writeString(int id, String string) native "File_WriteString";
+  external static _writeString(int id, String string);
 
   int writeStringSync(String string, [Encoding encoding = Encoding.UTF_8]) {
     _checkNotClosed();
     if (string is !String) throw new ArgumentError();
     var result = _writeString(_id, string);
     if (result is OSError) {
       throw new FileIOException("writeString failed for file '$_name'");
     }
     return result;
   }
 
   Future<int> position() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _POSITION_REQUEST;
     request[1] = _id;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "position failed for file '$_name'");
       }
       return response;
     });
   }
 
-  static _position(int id) native "File_Position";
+  external static _position(int id);
 
   int positionSync() {
     _checkNotClosed();
     var result = _position(_id);
     if (result is OSError) {
       throw new FileIOException("position failed for file '$_name'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> setPosition(int position) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _SET_POSITION_REQUEST;
     request[1] = _id;
     request[2] = position;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "setPosition failed for file '$_name'");
       }
       return this;
     });
   }
 
-  static _setPosition(int id, int position) native "File_SetPosition";
+  external static _setPosition(int id, int position);
 
   void setPositionSync(int position) {
     _checkNotClosed();
     var result = _setPosition(_id, position);
     if (result is OSError) {
       throw new FileIOException("setPosition failed for file '$_name'", result);
     }
   }
 
   Future<RandomAccessFile> truncate(int length) {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     List request = new List(3);
     request[0] = _TRUNCATE_REQUEST;
     request[1] = _id;
     request[2] = length;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "truncate failed for file '$_name'");
       }
       return this;
     });
   }
 
-  static _truncate(int id, int length) native "File_Truncate";
+  external static _truncate(int id, int length);
 
   void truncateSync(int length) {
     _checkNotClosed();
     var result = _truncate(_id, length);
     if (result is OSError) {
       throw new FileIOException("truncate failed for file '$_name'", result);
     }
   }
 
   Future<int> length() {
     _ensureFileService();
     Completer<int> completer = new Completer<int>();
     if (closed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _LENGTH_REQUEST;
     request[1] = _id;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "length failed for file '$_name'");
       }
       return response;
     });
   }
 
-  static _length(int id) native "File_Length";
+  external static _length(int id);
 
   int lengthSync() {
     _checkNotClosed();
     var result = _length(_id);
     if (result is OSError) {
       throw new FileIOException("length failed for file '$_name'", result);
     }
     return result;
   }
 
   Future<RandomAccessFile> flush() {
     _ensureFileService();
     Completer<RandomAccessFile> completer = new Completer<RandomAccessFile>();
     if (closed) return _completeWithClosedException(completer);
     List request = new List(2);
     request[0] = _FLUSH_REQUEST;
     request[1] = _id;
     return _fileService.call(request).transform((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "flush failed for file '$_name'");
       }
       return this;
     });
   }
 
-  static _flush(int id) native "File_Flush";
+  external static _flush(int id);
 
   void flushSync() {
     _checkNotClosed();
     var result = _flush(_id);
     if (result is OSError) {
       throw new FileIOException("flush failed for file '$_name'", result);
     }
   }
 
   String get name => _name;
 
   void _ensureFileService() {
     if (_fileService == null) {
-      _fileService = _newServicePort();
+      _fileService = _FileUtils._newServicePort();
     }
   }
 
   bool get closed => _id == 0;
 
   void _checkNotClosed() {
     if (closed) {
       throw new FileIOException("File closed '$_name'");
     }
   }
 
   Future _completeWithClosedException(Completer completer) {
     new Timer(0, (t) {
       completer.completeException(
           new FileIOException("File closed '$_name'"));
     });
     return completer.future;
   }
 
   final String _name;
   int _id;
 
   SendPort _fileService;
 }