Fix argument processing for RandomAccessFile.writeFrom

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 329 matching lines @@
     throwIfError(result, "Cannot copy file to '$newPath'", path);
     return new File(newPath);
   }
 
   Future<RandomAccessFile> open({FileMode mode: FileMode.READ}) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       return new Future.error(new ArgumentError());
     }
-    return _IOService._dispatch(_FILE_OPEN, [path, mode._mode]).then((response) {
-      if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response, "Cannot open file", path);
-      }
-      return new _RandomAccessFile(response, path);
-    });
+    return _IOService._dispatch(_FILE_OPEN, [path, mode._mode])
+        .then((response) {
+          if (_isErrorResponse(response)) {
+            throw _exceptionFromResponse(response, "Cannot open file", path);
+          }
+          return new _RandomAccessFile(response, path);
+        });
   }
 
   Future<int> length() {
-    return _IOService._dispatch(_FILE_LENGTH_FROM_PATH, [path]).then((response) {
-      if (_isErrorResponse(response)) {
-        throw _exceptionFromResponse(response,
-                                     "Cannot retrieve length of file",
-                                     path);
-      }
-      return response;
-    });
+    return _IOService._dispatch(_FILE_LENGTH_FROM_PATH, [path])
+        .then((response) {
+          if (_isErrorResponse(response)) {
+            throw _exceptionFromResponse(response,
+                                         "Cannot retrieve length of file",
+                                         path);
+          }
+          return response;
+        });
   }
 
 
   external static _lengthFromPath(String path);
 
   int lengthSync() {
     var result = _lengthFromPath(path);
     throwIfError(result, "Cannot retrieve length of file", path);
     return result;
   }
@@ skipping 304 matching lines @@
     }
     var result = _read(_id, bytes);
     if (result is OSError) {
       throw new FileSystemException("readSync failed", path, result);
     }
     _readCount++;
     _totalRead += result.length;
     return result;
   }
 
-  Future<int> readInto(List<int> buffer, [int start, int end]) {
+  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();
     }
-    if (start == null) start = 0;
-    if (end == null) end = buffer.length;
+    end = RangeError.checkValidRange(start, end, buffer.length);
+    if (end == start) return 0;
     int length = end - start;
     return _dispatch(_FILE_READ_INTO, [_id, length]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "readInto failed", path);
       }
       var read = response[1];
       var data = response[2];
       buffer.setRange(start, start + read, data);
       _readCount++;
       _totalRead += read;
       return read;
     });
   }
 
-  static void _checkReadWriteListArguments(int length, int start, int end) {
-    RangeError.checkValidRange(start, end, length);
-  }
-
   external static _readInto(int id, List<int> buffer, int start, int end);
 
-  int readIntoSync(List<int> buffer, [int start, int end]) {
+  int readIntoSync(List<int> buffer, [int start = 0, int end]) {
     _checkAvailable();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError();
     }
-    if (start == null) start = 0;
-    if (end == null) end = buffer.length;
+    end = RangeError.checkValidRange(start, end, buffer.length);
     if (end == start) return 0;
-    _checkReadWriteListArguments(buffer.length, start, end);
     var result = _readInto(_id, buffer, start, end);
     if (result is OSError) {
       throw new FileSystemException("readInto failed", path, result);
     }
     _readCount++;
     _totalRead += result;
     return result;
   }
 
   Future<RandomAccessFile> writeByte(int value) {
@@ skipping 19 matching lines @@
     }
     var result = _writeByte(_id, value);
     if (result is OSError) {
       throw new FileSystemException("writeByte failed", path, result);
     }
     _writeCount++;
     _totalWritten++;
     return result;
   }
 
-  Future<RandomAccessFile> writeFrom(List<int> buffer, [int start, int end]) {
-    if ((buffer is !List && buffer is !ByteData) ||
+  Future<RandomAccessFile> writeFrom(
+      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("Invalid arguments to writeFrom");
     }
-
+    end = RangeError.checkValidRange(start, end, buffer.length);
+    if (end == start) return;
     _BufferAndStart result;
     try {
       result = _ensureFastAndSerializableByteData(buffer, start, end);
     } catch (e) {
       return new Future.error(e);
     }
 
     List request = new List(4);
     request[0] = _id;
     request[1] = result.buffer;
     request[2] = result.start;
     request[3] = end - (start - result.start);
     return _dispatch(_FILE_WRITE_FROM, request).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "writeFrom failed", path);
       }
       _writeCount++;
       _totalWritten += end - (start - result.start);
       return this;
     });
   }
 
   external static _writeFrom(int id, List<int> buffer, int start, int end);
 
-  void writeFromSync(List<int> buffer, [int start, int end]) {
+  void writeFromSync(List<int> buffer, [int start = 0, int end]) {
     _checkAvailable();
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError("Invalid arguments to writeFromSync");
     }
-    if (start == null) start = 0;
-    if (end == null) end = buffer.length;
+    end = RangeError.checkValidRange(start, end, buffer.length);
     if (end == start) return;
-    _checkReadWriteListArguments(buffer.length, start, end);
     _BufferAndStart bufferAndStart =
         _ensureFastAndSerializableByteData(buffer, start, end);
     var result = _writeFrom(_id,
                             bufferAndStart.buffer,
                             bufferAndStart.start,
                             end - (start - bufferAndStart.start));
     if (result is OSError) {
       throw new FileSystemException("writeFrom failed", path, result);
     }
     _writeCount++;
@@ skipping 221 matching lines @@
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }