[dart:io] Namespaces for file 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;
 
 class _FileStream extends Stream<List<int>> {
@@ skipping 196 matching lines @@
   final String path;
 
   // Constructor for file.
   _File(this.path) {
     if (path is! String) {
       throw new ArgumentError('${Error.safeToString(path)} '
           'is not a String');
     }
   }
 
+  // WARNING:
+  // Calling this function will increase the reference count on the native
+  // namespace object. It should only be called to pass the pointer to the
+  // IOService, which will decrement the reference count when it is finished
+  // with it.
+  static int _namespacePointer() => _Namespace._namespacePointer;
+
+  static Future _dispatchWithNamespace(int request, List data) {
+    data[0] = _namespacePointer();
+    return _IOService._dispatch(request, data);
+  }
+
   Future<bool> exists() {
-    return _IOService._dispatch(_FILE_EXISTS, [path]).then((response) {
+    return _dispatchWithNamespace(_FILE_EXISTS, [null, path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot check existence", path);
       }
       return response;
     });
   }
 
-  external static _exists(String path);
+  external static _exists(_Namespace namespace, String path);
 
   bool existsSync() {
-    var result = _exists(path);
+    var result = _exists(_Namespace._namespace, path);
     throwIfError(result, "Cannot check existence of file", path);
     return result;
   }
 
   File get absolute => new File(_absolutePath);
 
   Future<File> create({bool recursive: false}) {
     var result =
         recursive ? parent.create(recursive: true) : new Future.value(null);
     return result
-        .then((_) => _IOService._dispatch(_FILE_CREATE, [path]))
+        .then((_) => _dispatchWithNamespace(_FILE_CREATE, [null, path]))
         .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot create file", path);
       }
       return this;
     });
   }
 
-  external static _create(String path);
+  external static _create(_Namespace namespace, String path);
 
-  external static _createLink(String path, String target);
+  external static _createLink(_Namespace namespace, String path, String target);
 
-  external static _linkTarget(String path);
+  external static _linkTarget(_Namespace namespace, String path);
 
   void createSync({bool recursive: false}) {
     if (recursive) {
       parent.createSync(recursive: true);
     }
-    var result = _create(path);
+    var result = _create(_Namespace._namespace, path);
     throwIfError(result, "Cannot create file", path);
   }
 
   Future<File> _delete({bool recursive: false}) {
     if (recursive) {
       return new Directory(path).delete(recursive: true).then((_) => this);
     }
-    return _IOService._dispatch(_FILE_DELETE, [path]).then((response) {
+    return _dispatchWithNamespace(_FILE_DELETE, [null, path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot delete file", path);
       }
       return this;
     });
   }
 
-  external static _deleteNative(String path);
+  external static _deleteNative(_Namespace namespace, String path);
 
-  external static _deleteLinkNative(String path);
+  external static _deleteLinkNative(_Namespace namespace, String path);
 
   void _deleteSync({bool recursive: false}) {
     if (recursive) {
       return new Directory(path).deleteSync(recursive: true);
     }
-    var result = _deleteNative(path);
+    var result = _deleteNative(_Namespace._namespace, path);
     throwIfError(result, "Cannot delete file", path);
   }
 
   Future<File> rename(String newPath) {
-    return _IOService._dispatch(_FILE_RENAME, [path, newPath]).then((response) {
+    return _dispatchWithNamespace(_FILE_RENAME, [null, path, newPath])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot rename file to '$newPath'", path);
       }
       return new File(newPath);
     });
   }
 
-  external static _rename(String oldPath, String newPath);
+  external static _rename(_Namespace namespace, String oldPath, String newPath);
 
-  external static _renameLink(String oldPath, String newPath);
+  external static _renameLink(
+      _Namespace namespace, String oldPath, String newPath);
 
   File renameSync(String newPath) {
-    var result = _rename(path, newPath);
+    var result = _rename(_Namespace._namespace, path, newPath);
     throwIfError(result, "Cannot rename file to '$newPath'", path);
     return new File(newPath);
   }
 
   Future<File> copy(String newPath) {
-    return _IOService._dispatch(_FILE_COPY, [path, newPath]).then((response) {
+    return _dispatchWithNamespace(_FILE_COPY, [null, path, newPath])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot copy file to '$newPath'", path);
       }
       return new File(newPath);
     });
   }
 
-  external static _copy(String oldPath, String newPath);
+  external static _copy(_Namespace namespace, String oldPath, String newPath);
 
   File copySync(String newPath) {
-    var result = _copy(path, newPath);
+    var result = _copy(_Namespace._namespace, path, newPath);
     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 &&
         mode != FileMode.WRITE_ONLY &&
         mode != FileMode.WRITE_ONLY_APPEND) {
       return new Future.error(
           new ArgumentError('Invalid file mode for this operation'));
     }
-    return _IOService
-        ._dispatch(_FILE_OPEN, [path, mode._mode]).then((response) {
+    return _dispatchWithNamespace(_FILE_OPEN, [null, 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) {
+    return _dispatchWithNamespace(_FILE_LENGTH_FROM_PATH, [null, path])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot retrieve length of file", path);
       }
       return response;
     });
   }
 
-  external static _lengthFromPath(String path);
+  external static _lengthFromPath(_Namespace namespace, String path);
 
   int lengthSync() {
-    var result = _lengthFromPath(path);
+    var result = _lengthFromPath(_Namespace._namespace, path);
     throwIfError(result, "Cannot retrieve length of file", path);
     return result;
   }
 
   Future<DateTime> lastAccessed() {
-    return _IOService._dispatch(_FILE_LAST_ACCESSED, [path]).then((response) {
+    return _dispatchWithNamespace(_FILE_LAST_ACCESSED, [null, path])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot retrieve access time", path);
       }
       return new DateTime.fromMillisecondsSinceEpoch(response);
     });
   }
 
-  external static _lastAccessed(String path);
+  external static _lastAccessed(_Namespace namespace, String path);
 
   DateTime lastAccessedSync() {
-    var ms = _lastAccessed(path);
+    var ms = _lastAccessed(_Namespace._namespace, path);
     throwIfError(ms, "Cannot retrieve access time", path);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   }
 
   Future setLastAccessed(DateTime time) {
     int millis = time.millisecondsSinceEpoch;
-    return _IOService
-        ._dispatch(_FILE_SET_LAST_ACCESSED, [path, millis]).then((response) {
+    return _dispatchWithNamespace(_FILE_SET_LAST_ACCESSED, [null, path, millis])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot set access time", path);
       }
       return null;
     });
   }
 
-  external static _setLastAccessed(String path, int millis);
+  external static _setLastAccessed(
+      _Namespace namespace, String path, int millis);
 
   void setLastAccessedSync(DateTime time) {
     int millis = time.millisecondsSinceEpoch;
-    var result = _setLastAccessed(path, millis);
+    var result = _setLastAccessed(_Namespace._namespace, path, millis);
     if (result is OSError) {
       throw new FileSystemException(
           "Failed to set file access time", path, result);
     }
   }
 
   Future<DateTime> lastModified() {
-    return _IOService._dispatch(_FILE_LAST_MODIFIED, [path]).then((response) {
+    return _dispatchWithNamespace(_FILE_LAST_MODIFIED, [null, path])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot retrieve modification time", path);
       }
       return new DateTime.fromMillisecondsSinceEpoch(response);
     });
   }
 
-  external static _lastModified(String path);
+  external static _lastModified(_Namespace namespace, String path);
 
   DateTime lastModifiedSync() {
-    var ms = _lastModified(path);
+    var ms = _lastModified(_Namespace._namespace, path);
     throwIfError(ms, "Cannot retrieve modification time", path);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   }
 
   Future setLastModified(DateTime time) {
     int millis = time.millisecondsSinceEpoch;
-    return _IOService
-        ._dispatch(_FILE_SET_LAST_MODIFIED, [path, millis]).then((response) {
+    return _dispatchWithNamespace(_FILE_SET_LAST_MODIFIED, [null, path, millis])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot set modification time", path);
       }
       return null;
     });
   }
 
-  external static _setLastModified(String path, int millis);
+  external static _setLastModified(
+      _Namespace namespace, String path, int millis);
 
   void setLastModifiedSync(DateTime time) {
     int millis = time.millisecondsSinceEpoch;
-    var result = _setLastModified(path, millis);
+    var result = _setLastModified(_Namespace._namespace, path, millis);
     if (result is OSError) {
       throw new FileSystemException(
           "Failed to set file modification time", path, result);
     }
   }
 
-  external static _open(String path, int mode);
+  external static _open(_Namespace namespace, String path, int mode);
 
   RandomAccessFile openSync({FileMode mode: FileMode.READ}) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND &&
         mode != FileMode.WRITE_ONLY &&
         mode != FileMode.WRITE_ONLY_APPEND) {
       throw new ArgumentError('Invalid file mode for this operation');
     }
-    var id = _open(path, mode._mode);
+    var id = _open(_Namespace._namespace, path, mode._mode);
     throwIfError(id, "Cannot open file", path);
     return new _RandomAccessFile(id, path);
   }
 
   external static int _openStdio(int fd);
 
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _openStdio(fd);
     if (id == 0) {
       throw new FileSystemException("Cannot open stdio file for: $fd");
@@ skipping 564 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;
 
+  // WARNING:
   // 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));
     }
@@ skipping 16 matching lines @@
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException(
           "An async operation is currently pending", path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }