Revert "Fix remaining strong-mode warnings and errors in dart:io."

sdk/lib/io/file_impl.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 // Read the file in blocks of size 64k.
 const int _BLOCK_SIZE = 64 * 1024;
 
 
@@ skipping 195 matching lines @@
             completer.complete(_file);
           },
           onError: error,
           cancelOnError: true);
       })
       .catchError(completer.completeError);
     return completer.future;
   }
 
   Future<File> close() =>
-      _openFuture.then/*<File>*/((openedFile) => openedFile.close());
+      _openFuture.then((openedFile) => openedFile.close());
 }
 
 
 // Class for encapsulating the native implementation of files.
 class _File extends FileSystemEntity implements File {
   final String path;
 
   // Constructor for file.
   _File(this.path) {
     if (path is! String) {
@@ skipping 207 matching lines @@
         mode != FileMode.APPEND &&
         mode != FileMode.WRITE_ONLY &&
         mode != FileMode.WRITE_ONLY_APPEND) {
       throw new ArgumentError('Invalid file mode for this operation');
     }
     var consumer = new _FileStreamConsumer(this, mode);
     return new IOSink(consumer, encoding: encoding);
   }
 
   Future<List<int>> readAsBytes() {
-    Future<List<int>> readDataChunked(RandomAccessFile file) {
+    Future<List<int>> readDataChunked(file) {
       var builder = new BytesBuilder(copy: false);
-      var completer = new Completer<List<int>>();
+      var completer = new Completer();
       void read() {
         file.read(_BLOCK_SIZE).then((data) {
           if (data.length > 0) {
             builder.add(data);
             read();
           } else {
             completer.complete(builder.takeBytes());
           }
         }, onError: completer.completeError);
       }
       read();
       return completer.future;
     }
 
     return open().then((file) {
       return file.length().then((length) {
         if (length == 0) {
           // May be character device, try to read it in chunks.
           return readDataChunked(file);
         }
         return file.read(length);
       }).whenComplete(file.close);
     });
   }
 
   List<int> readAsBytesSync() {
     var opened = openSync();
     try {
-      List<int> data;
+      var data;
       var length = opened.lengthSync();
       if (length == 0) {
         // May be character device, try to read it in chunks.
         var builder = new BytesBuilder(copy: false);
         do {
           data = opened.readSync(_BLOCK_SIZE);
           if (data.length > 0) builder.add(data);
         } while (data.length > 0);
         data = builder.takeBytes();
       } else {
@@ skipping 177 matching lines @@
 
   Future<List<int>> read(int bytes) {
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
     return _dispatch(_FILE_READ, [null, bytes]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "read failed", path);
       }
       _resourceInfo.addRead(response[1].length);
-      return response[1] as Object/*=List<int>*/;
+      return response[1];
     });
   }
 
   List<int> readSync(int bytes) {
     _checkAvailable();
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
     var result = _ops.read(bytes);
     if (result is OSError) {
       throw new FileSystemException("readSync failed", path, result);
     }
     _resourceInfo.addRead(result.length);
-    return result as Object/*=List<int>*/;
+    return result;
   }
 
   Future<int> readInto(List<int> buffer, [int start = 0, int end]) {
     if ((buffer is !List) ||
         ((start != null) && (start is !int)) ||
         ((end != null) && (end is !int))) {
       throw new ArgumentError();
     }
     end = RangeError.checkValidRange(start, end, buffer.length);
     if (end == start) {
       return new Future.value(0);
     }
     int length = end - start;
     return _dispatch(_FILE_READ_INTO, [null, length]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "readInto failed", path);
       }
       var read = response[1];
-      var data = response[2] as Object/*=List<int>*/;
+      var data = response[2];
       buffer.setRange(start, start + read, data);
       _resourceInfo.addRead(read);
       return read;
     });
   }
 
   int readIntoSync(List<int> buffer, [int start = 0, int end]) {
     _checkAvailable();
     if ((buffer is !List) ||
         ((start != null) && (start is !int)) ||
@@ skipping 299 matching lines @@
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }