Fix file fuzz test failure

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 569 matching lines @@
   length();
   flush();
   lock(int lock, int start, int end);
 }
 
 class _RandomAccessFile implements RandomAccessFile {
   static bool _connectedResourceHandler = false;
 
   final String path;
 
-  // Calling this function will increase the reference count on the native
-  // object that implements the file operations. It should only be called to
-  // pass the pointer to the IO Service, which will decrement the reference
-  // count when it is finished with it.
-  int _pointer() => _ops.getPointer();
-
   bool _asyncDispatched = false;
   SendPort _fileService;
 
   _FileResourceInfo _resourceInfo;
   _RandomAccessFileOps _ops;
 
   _RandomAccessFile(int pointer, this.path) {
     _ops = new _RandomAccessFileOps(pointer);
     _resourceInfo = new _FileResourceInfo(this);
     _maybeConnectHandler();
@@ skipping 13 matching lines @@
       // open.
       registerExtension('ext.dart.io.getOpenFiles',
                         _FileResourceInfo.getOpenFiles);
       registerExtension('ext.dart.io.getFileByID',
                         _FileResourceInfo.getFileInfoMapByID);
       _connectedResourceHandler = true;
     }
   }
 
   Future<RandomAccessFile> close() {
-    return _dispatch(_FILE_CLOSE, [_pointer()], markClosed: true).then((result) {
+    return _dispatch(_FILE_CLOSE, [null], markClosed: true).then((result) {
       if (result != -1) {
         closed = closed || (result == 0);
         _maybePerformCleanup();
         return this;
       } else {
         throw new FileSystemException("Cannot close file", path);
       }
     });
   }
 
   void closeSync() {
     _checkAvailable();
     var id = _ops.close();
     if (id == -1) {
       throw new FileSystemException("Cannot close file", path);
     }
     closed = closed || (id == 0);
     _maybePerformCleanup();
   }
 
   Future<int> readByte() {
-    return _dispatch(_FILE_READ_BYTE, [_pointer()]).then((response) {
+    return _dispatch(_FILE_READ_BYTE, [null]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "readByte failed", path);
       }
       _resourceInfo.addRead(1);
       return response;
     });
   }
 
   int readByteSync() {
     _checkAvailable();
     var result = _ops.readByte();
     if (result is OSError) {
       throw new FileSystemException("readByte failed", path, result);
     }
     _resourceInfo.addRead(1);
     return result;
   }
 
   Future<List<int>> read(int bytes) {
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
-    return _dispatch(_FILE_READ, [_pointer(), bytes]).then((response) {
+    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];
     });
   }
 
   List<int> readSync(int bytes) {
     _checkAvailable();
@@ skipping 12 matching lines @@
     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, [_pointer(), length]).then((response) {
+    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];
       buffer.setRange(start, start + read, data);
       _resourceInfo.addRead(read);
       return read;
     });
   }
@@ skipping 14 matching lines @@
       throw new FileSystemException("readInto failed", path, result);
     }
     _resourceInfo.addRead(result);
     return result;
   }
 
   Future<RandomAccessFile> writeByte(int value) {
     if (value is !int) {
       throw new ArgumentError(value);
     }
-    return _dispatch(_FILE_WRITE_BYTE, [_pointer(), value]).then((response) {
+    return _dispatch(_FILE_WRITE_BYTE, [null, value]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "writeByte failed", path);
       }
       _resourceInfo.addWrite(1);
       return this;
     });
   }
 
   int writeByteSync(int value) {
     _checkAvailable();
@@ skipping 20 matching lines @@
       return new Future.value(this);
     }
     _BufferAndStart result;
     try {
       result = _ensureFastAndSerializableByteData(buffer, start, end);
     } catch (e) {
       return new Future.error(e);
     }
 
     List request = new List(4);
-    request[0] = _pointer();
+    request[0] = null;
     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);
       }
       _resourceInfo.addWrite(end - (start - result.start));
       return this;
     });
@@ skipping 32 matching lines @@
 
   void writeStringSync(String string, {Encoding encoding: UTF8}) {
     if (encoding is! Encoding) {
       throw new ArgumentError(encoding);
     }
     var data = encoding.encode(string);
     writeFromSync(data, 0, data.length);
   }
 
   Future<int> position() {
-    return _dispatch(_FILE_POSITION, [_pointer()]).then((response) {
+    return _dispatch(_FILE_POSITION, [null]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "position failed", path);
       }
       return response;
     });
   }
 
   int positionSync() {
     _checkAvailable();
     var result = _ops.position();
     if (result is OSError) {
       throw new FileSystemException("position failed", path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> setPosition(int position) {
-    return _dispatch(_FILE_SET_POSITION, [_pointer(), position])
+    return _dispatch(_FILE_SET_POSITION, [null, position])
         .then((response) {
           if (_isErrorResponse(response)) {
             throw _exceptionFromResponse(response, "setPosition failed", path);
           }
           return this;
         });
   }
 
   void setPositionSync(int position) {
     _checkAvailable();
     var result = _ops.setPosition(position);
     if (result is OSError) {
       throw new FileSystemException("setPosition failed", path, result);
     }
   }
 
   Future<RandomAccessFile> truncate(int length) {
-    return _dispatch(_FILE_TRUNCATE, [_pointer(), length]).then((response) {
+    return _dispatch(_FILE_TRUNCATE, [null, length]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "truncate failed", path);
       }
       return this;
     });
   }
 
   void truncateSync(int length) {
     _checkAvailable();
     var result = _ops.truncate(length);
     if (result is OSError) {
       throw new FileSystemException("truncate failed", path, result);
     }
   }
 
   Future<int> length() {
-    return _dispatch(_FILE_LENGTH, [_pointer()]).then((response) {
+    return _dispatch(_FILE_LENGTH, [null]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "length failed", path);
       }
       return response;
     });
   }
 
   int lengthSync() {
     _checkAvailable();
     var result = _ops.length();
     if (result is OSError) {
       throw new FileSystemException("length failed", path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> flush() {
-    return _dispatch(_FILE_FLUSH, [_pointer()]).then((response) {
+    return _dispatch(_FILE_FLUSH, [null]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "flush failed",
                                      path);
       }
       return this;
     });
   }
 
   void flushSync() {
@@ skipping 10 matching lines @@
 
   Future<RandomAccessFile> lock(
       [FileLock mode = FileLock.EXCLUSIVE, int start = 0, int end = -1]) {
     if ((mode is !FileLock) || (start is !int) || (end is !int)) {
       throw new ArgumentError();
     }
     if ((start < 0) || (end < -1) || ((end != -1) && (start >= end))) {
       throw new ArgumentError();
     }
     int lock = (mode == FileLock.EXCLUSIVE) ? LOCK_EXCLUSIVE : LOCK_SHARED;
-    return _dispatch(_FILE_LOCK, [_pointer(), lock, start, end])
+    return _dispatch(_FILE_LOCK, [null, lock, start, end])
         .then((response) {
           if (_isErrorResponse(response)) {
             throw _exceptionFromResponse(response, 'lock failed', path);
           }
           return this;
         });
   }
 
   Future<RandomAccessFile> unlock([int start = 0, int end = -1]) {
     if ((start is !int) || (end is !int)) {
       throw new ArgumentError();
     }
     if (start == end) {
       throw new ArgumentError();
     }
-    return _dispatch(_FILE_LOCK, [_pointer(), LOCK_UNLOCK, start, end])
+    return _dispatch(_FILE_LOCK, [null, LOCK_UNLOCK, start, end])
         .then((response) {
           if (_isErrorResponse(response)) {
             throw _exceptionFromResponse(response, 'unlock failed', path);
           }
           return this;
         });
   }
 
   void lockSync(
       [FileLock mode = FileLock.EXCLUSIVE, int start = 0, int end = -1]) {
@@ skipping 20 matching lines @@
       throw new ArgumentError();
     }
     var result = _ops.lock(LOCK_UNLOCK, start, end);
     if (result is OSError) {
       throw new FileSystemException('unlock failed', path, result);
     }
   }
 
   bool closed = false;
 
+  // Calling this function will increase the reference count on the native
+  // object that implements the file operations. It should only be called to
+  // pass the pointer to the IO Service, which will decrement the reference
+  // count when it is finished with it.
+  int _pointer() => _ops.getPointer();
+
   Future _dispatch(int request, List data, { bool markClosed: false }) {
     if (closed) {
       return new Future.error(new FileSystemException("File closed", path));
     }
     if (_asyncDispatched) {
       var msg = "An async operation is currently pending";
       return new Future.error(new FileSystemException(msg, path));
     }
     if (markClosed) {
       // Set closed to true to ensure that no more async requests can be issued
       // for this file.
       closed = true;
     }
     _asyncDispatched = true;
+    data[0] = _pointer();
     return _IOService._dispatch(request, data)
         .whenComplete(() {
           _asyncDispatched = false;
         });
   }
 
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending",
                                     path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }