Remove check whether async has been used from File objects.

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.onError = (e) {
@@ skipping 382 matching lines @@
           _onError(new Exception("Unknown error"));
           break;
       }
     }
   }
 
   void set onError(void handler(Exception e)) {
     _onError = handler;
   }
 
-  _checkNotAsync() {
-    if (_asyncUsed) {
-      throw new FileIOException(
-          "Mixed use of synchronous and asynchronous API");
-    }
-  }
-
-  bool _asyncUsed = false;
   Function _onError;
 }
 
 // Class for encapsulating the native implementation of files.
 class _File extends _FileBase implements File {
   // Constructor for file.
   _File(String this._name);
 
   void exists(void callback(bool exists)) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kExistsRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "Cannot open file");
       } else {
         callback(response);
       }
     });
   }
 
   bool existsSync() {
-    _checkNotAsync();
     return _FileUtils.checkedExists(_name);
   }
 
   void create(void callback()) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kCreateRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "Cannot create file");
       } else {
         callback();
       }
     });
   }
 
   void createSync() {
-    _checkNotAsync();
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file: $_name");
     }
   }
 
   void delete(void callback()) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDeleteRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "Cannot delete file");
       } else {
         callback();
       }
     });
   }
 
   void deleteSync() {
-    _checkNotAsync();
     _FileUtils.checkedDelete(_name);
   }
 
   void directory(void callback(Directory dir)) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kDirectoryRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "Cannot retrieve directory for file");
       } else {
         callback(new Directory(response));
       }
     });
   }
 
   Directory directorySync() {
-    _checkNotAsync();
     _FileUtils.checkedDirectory(_name);
     return new Directory(_FileUtils.directory(_name));
   }
 
   void open(FileMode mode, void callback(RandomAccessFile file)) {
     _ensureFileService();
-    _asyncUsed = true;
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       if (_onError != null) {
         _onError(new IllegalArgumentException());
         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).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "Cannot open file");
       } else {
         callback(new _RandomAccessFile(response, _name));
       }
     });
   }
 
   RandomAccessFile openSync([FileMode mode = FileMode.READ]) {
-    _checkNotAsync();
     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 = _FileUtils.checkedOpen(_name, mode._mode);
     assert(id != 0);
     return new _RandomAccessFile(id, _name);
   }
 
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _FileUtils.openStdio(fd);
     if (id == 0) {
       throw new FileIOException("Cannot open stdio file for: $fd");
     }
     return new _RandomAccessFile(id, "");
   }
 
   void fullPath(void callback(String result)) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kFullPathRequest;
     request[1] = _name;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "Cannot retrieve full path");
       } else {
         callback(response);
       }
     });
   }
 
   String fullPathSync() {
-    _checkNotAsync();
     return _FileUtils.checkedFullPath(_name);
   }
 
   InputStream openInputStream() {
     return new _FileInputStream(_name);
   }
 
   OutputStream openOutputStream([FileMode mode = FileMode.WRITE]) {
     if (mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       throw new FileIOException(
           "Wrong FileMode. Use FileMode.WRITE or FileMode.APPEND");
     }
     return new _FileOutputStream(_name, mode);
   }
 
   void readAsBytes(void callback(List<int> bytes)) {
     _ensureFileService();
-    _asyncUsed = true;
     var chunks = new _BufferList();
     var stream = openInputStream();
     stream.onClosed = () {
       callback(chunks.readBytes(chunks.length));
     };
     stream.onData = () {
       var chunk = stream.read();
       chunks.add(chunk);
     };
     stream.onError = (e) {
       if (_onError != null) {
         _onError(e);
       }
     };
   }
 
   List<int> readAsBytesSync() {
-    _checkNotAsync();
     var opened = openSync();
     var length = opened.lengthSync();
     var result = new ByteArray(length);
     var read = opened.readListSync(result, 0, length);
     if (read != length) {
       throw new FileIOException("Failed to read file");
     }
     opened.closeSync();
     return result;
   }
 
   void readAsText(Encoding encoding, void callback(String text)) {
     _ensureFileService();
-    _asyncUsed = true;
     var decoder = _StringDecoders.decoder(encoding);
     readAsBytes((bytes) {
       try {
         decoder.write(bytes);
       } catch (var e) {
         if (_onError != null) {
           _onError(e);
           return;
         }
       }
       callback(decoder.decoded);
     });
   }
 
   String readAsTextSync([Encoding encoding = Encoding.UTF_8]) {
-    _checkNotAsync();
     var decoder = _StringDecoders.decoder(encoding);
     List<int> bytes = readAsBytesSync();
     decoder.write(bytes);
     return decoder.decoded;
   }
 
   List<String> _getDecodedLines(_StringDecoder decoder) {
     List<String> result = [];
     var line = decoder.decodedLine;
     while (line != null) {
       result.add(line);
       line = decoder.decodedLine;
     }
     // If there is more data with no terminating line break we treat
     // it as the last line.
     var data = decoder.decoded;
     if (data != null) {
       result.add(data);
     }
     return result;
   }
 
   void readAsLines(Encoding encoding, void callback(List<String> lines)) {
     _ensureFileService();
-    _asyncUsed = true;
     var decoder = _StringDecoders.decoder(encoding);
     readAsBytes((bytes) {
       try {
         decoder.write(bytes);
       } catch (var e) {
         if (_onError != null) {
           _onError(e);
           return;
         }
       }
       callback(_getDecodedLines(decoder));
     });
   }
 
   List<String> readAsLinesSync([Encoding encoding = Encoding.UTF_8]) {
-    _checkNotAsync();
     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 = _FileUtils.newServicePort();
     }
   }
 
   String _name;
 
   SendPort _fileService;
 }
 
 
 class _RandomAccessFile extends _FileBase implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name);
 
   void close(void callback()) {
     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).then((result) {
       if (result != -1) {
         _id = result;
         callback();
       } else if (_onError != null) {
         _onError("Cannot close file: $_name");
       }
     });
   }
 
   void closeSync() {
-    _checkNotAsync();
     var id = _FileUtils.close(_id);
     if (id == -1) {
       throw new FileIOException("Cannot close file: $_name");
     }
     _id = id;
   }
 
   void readByte(void callback(int byte)) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kReadByteRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "readByte failed");
       } else {
         callback(response);
       }
     });
   }
 
   int readByteSync() {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     var result = _FileUtils.readByte(_id);
     if (result is OSError) {
       throw new FileIOException("readByte failed", result);
     }
     return result;
   }
 
   void readList(List<int> buffer, int offset, int bytes,
                 void callback(int read)) {
     _ensureFileService();
-    _asyncUsed = true;
     if (buffer is !List || offset is !int || bytes is !int) {
       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).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "readList failed");
       } else {
         var read = response[1];
         var data = response[2];
         buffer.setRange(offset, read, data);
         callback(read);
       }
     });
   }
 
   int readListSync(List<int> buffer, int offset, int bytes) {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     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);
     }
     var result = _FileUtils.readList(_id, buffer, offset, bytes);
     if (result is OSError) {
       throw new FileIOException("readList failed", result);
     }
     return result;
   }
 
   void writeByte(int value) {
     _ensureFileService();
-    _asyncUsed = true;
     if (value is !int) {
       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).then((response) {
       _writeCompleted();
       if (_isErrorResponse(response)) {
         _reportError(response, "writeByte failed");
       }
     });
   }
 
   int writeByteSync(int value) {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     if (value is !int) {
       throw new FileIOException("Invalid argument to writeByte");
     }
     var result = _FileUtils.writeByte(_id, value);
     if (result is OSError) {
       throw new FileIOException("writeByte failed", result);
     }
     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 (_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).then((response) {
       _writeCompleted();
       if (_isErrorResponse(response)) {
         _reportError(response, "writeList failed");
       }
     });
   }
 
   int writeListSync(List<int> buffer, int offset, int bytes) {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     if (buffer is !List || offset is !int || bytes is !int) {
       throw new FileIOException("Invalid arguments to writeList");
     }
     if (bytes == 0) return 0;
     int index =
         _FileUtils.checkReadWriteListArguments(buffer.length, offset, bytes);
     if (index != 0) {
       throw new IndexOutOfRangeException(index);
     }
     var result = _FileUtils.writeList(_id, buffer, offset, bytes);
     if (result is OSError) {
       throw new FileIOException("writeList failed", result);
     }
     return result;
   }
 
   void writeString(String string, [Encoding encoding = Encoding.UTF_8]) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kWriteStringRequest;
     request[1] = _id;
     request[2] = string;
     _writeEnqueued();
     _fileService.call(request).then((response) {
       _writeCompleted();
       if (_isErrorResponse(response)) {
         _reportError(response, "writeString failed");
       }
     });
   }
 
   int writeStringSync(String string, [Encoding encoding = Encoding.UTF_8]) {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     var result = _FileUtils.checkedWriteString(_id, string);
     if (result is OSError) {
       throw new FileIOException("writeString failed", result);
     }
     return result;
   }
 
   void position(void callback(int position)) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kPositionRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "position failed");
       } else {
         callback(response);
       }
     });
   }
 
   int positionSync() {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     var result = _FileUtils.position(_id);
     if (result is OSError) {
       throw new FileIOException("position failed", result);
     }
     return result;
   }
 
   void setPosition(int position, void callback()) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kSetPositionRequest;
     request[1] = _id;
     request[2] = position;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "setPosition failed");
       } else {
         callback();
       }
     });
   }
 
   void setPositionSync(int position) {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     var result = _FileUtils.setPosition(_id, position);
     if (result is OSError) {
       throw new FileIOException("setPosition failed", result);
     }
   }
 
   void truncate(int length, void callback()) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(3);
     request[0] = _FileUtils.kTruncateRequest;
     request[1] = _id;
     request[2] = length;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "truncate failed");
       } else {
         callback();
       }
     });
   }
 
   void truncateSync(int length) {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     var result = _FileUtils.truncate(_id, length);
     if (result is OSError) {
       throw new FileIOException("truncate failed", result);
     }
   }
 
   void length(void callback(int length)) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kLengthRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "length failed");
       } else {
         callback(response);
       }
     });
   }
 
   int lengthSync() {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     var result = _FileUtils.length(_id);
     if (result is OSError) {
       throw new FileIOException("length failed", result);
     }
     return result;
   }
 
   void flush(void callback()) {
     _ensureFileService();
-    _asyncUsed = true;
     List request = new List(2);
     request[0] = _FileUtils.kFlushRequest;
     request[1] = _id;
     _fileService.call(request).then((response) {
       if (_isErrorResponse(response)) {
         _reportError(response, "flush failed");
       } else {
         callback();
       }
     });
   }
 
   void flushSync() {
-    _checkNotAsyncAndNotClosed();
+    _checkNotClosed();
     var result = _FileUtils.flush(_id);
     if (result is OSError) {
       throw new FileIOException("flush failed", result);
     }
   }
 
   String get name() => _name;
 
   void set onNoPendingWrites(void handler()) {
     _onNoPendingWrites = handler;
@@ skipping 18 matching lines @@
     }
   }
 
   void  _writeCompleted() {
     _pendingWrites--;
     if (_pendingWrites == 0 && _onNoPendingWrites != null) {
       _onNoPendingWrites();
     }
   }
 
-  _checkNotAsyncAndNotClosed() {
-    _checkNotAsync();
+  void _checkNotClosed() {
     if (_id == 0) {
       throw new FileIOException("File closed");
     }
   }
 
   String _name;
   int _id;
   int _pendingWrites = 0;
 
   SendPort _fileService;
 
   Timer _noPendingWriteTimer;
 
   Function _onNoPendingWrites;
 }