[dart:io] Namespaces for file IO

sdk/lib/io/file_system_entity.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;
 
 /**
  * The type of an entity on the file system, such as a file, directory, or link.
  *
  * These constants are used by the [FileSystemEntity] class
@@ skipping 71 matching lines @@
       this.mode, this.size);
 
   const FileStat._internalNotFound()
       : changed = null,
         modified = null,
         accessed = null,
         type = FileSystemEntityType.NOT_FOUND,
         mode = 0,
         size = -1;
 
-  external static _statSync(String path);
+  external static _statSync(_Namespace namespace, String path);
 
   /**
    * Calls the operating system's stat() function on [path].
    * Returns a [FileStat] object containing the data returned by stat().
    * If the call fails, returns a [FileStat] object with .type set to
    * FileSystemEntityType.NOT_FOUND and the other fields invalid.
    */
   static FileStat statSync(String path) {
     // Trailing path is not supported on Windows.
     if (Platform.isWindows) {
       path = FileSystemEntity._trimTrailingPathSeparators(path);
     }
-    var data = _statSync(path);
+    var data = _statSync(_Namespace._namespace, path);
     if (data is OSError) return FileStat._notFound;
     return new FileStat._internal(
         new DateTime.fromMillisecondsSinceEpoch(data[_CHANGED_TIME]),
         new DateTime.fromMillisecondsSinceEpoch(data[_MODIFIED_TIME]),
         new DateTime.fromMillisecondsSinceEpoch(data[_ACCESSED_TIME]),
         FileSystemEntityType._lookup(data[_TYPE]),
         data[_MODE],
         data[_SIZE]);
   }
 
   /**
    * Asynchronously calls the operating system's stat() function on [path].
    * Returns a Future which completes with a [FileStat] object containing
    * the data returned by stat().
    * If the call fails, completes the future with a [FileStat] object with
    * .type set to FileSystemEntityType.NOT_FOUND and the other fields invalid.
    */
   static Future<FileStat> stat(String path) {
     // Trailing path is not supported on Windows.
     if (Platform.isWindows) {
       path = FileSystemEntity._trimTrailingPathSeparators(path);
     }
-    return _IOService._dispatch(_FILE_STAT, [path]).then((response) {
+    return _File._dispatchWithNamespace(_FILE_STAT, [null, path])
+        .then((response) {
       if (_isErrorResponse(response)) {
         return FileStat._notFound;
       }
       // Unwrap the real list from the "I'm not an error" wrapper.
       List data = response[1];
       return new FileStat._internal(
           new DateTime.fromMillisecondsSinceEpoch(data[_CHANGED_TIME]),
           new DateTime.fromMillisecondsSinceEpoch(data[_MODIFIED_TIME]),
           new DateTime.fromMillisecondsSinceEpoch(data[_ACCESSED_TIME]),
           FileSystemEntityType._lookup(data[_TYPE]),
@@ skipping 157 matching lines @@
    *     var path = Uri.parse('.').resolveUri(new Uri.file(input)).toFilePath();
    *     if (path == '') path = '.';
    *     new File(path).resolveSymbolicLinks().then((resolved) {
    *       print(resolved);
    *     });
    *
    * since `Uri.resolve` removes `..` segments. This will result in the Windows
    * behavior.
    */
   Future<String> resolveSymbolicLinks() {
-    return _IOService
-        ._dispatch(_FILE_RESOLVE_SYMBOLIC_LINKS, [path]).then((response) {
+    return _File
+        ._dispatchWithNamespace(_FILE_RESOLVE_SYMBOLIC_LINKS, [null, path])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(
             response, "Cannot resolve symbolic links", path);
       }
       return response;
     });
   }
 
   /**
    * Resolves the path of a file system object relative to the
@@ skipping 16 matching lines @@
    *
    *     var path = Uri.parse('.').resolveUri(new Uri.file(input)).toFilePath();
    *     if (path == '') path = '.';
    *     var resolved = new File(path).resolveSymbolicLinksSync();
    *     print(resolved);
    *
    * since `Uri.resolve` removes `..` segments. This will result in the Windows
    * behavior.
    */
   String resolveSymbolicLinksSync() {
-    var result = _resolveSymbolicLinks(path);
+    var result = _resolveSymbolicLinks(_Namespace._namespace, path);
     _throwIfError(result, "Cannot resolve symbolic links", path);
     return result;
   }
 
   /**
    * Calls the operating system's stat() function on the [path] of this
    * [FileSystemEntity].  Identical to [:FileStat.stat(this.path):].
    *
    * Returns a [:Future<FileStat>:] object containing the data returned by
    * stat().
@@ skipping 100 matching lines @@
    *
    * Comparing a link to its target returns false, as does comparing two links
    * that point to the same target.  To check the target of a link, use
    * Link.target explicitly to fetch it.  Directory links appearing
    * inside a path are followed, though, to find the file system object.
    *
    * Completes the returned Future with an error if one of the paths points
    * to an object that does not exist.
    */
   static Future<bool> identical(String path1, String path2) {
-    return _IOService
-        ._dispatch(_FILE_IDENTICAL, [path1, path2]).then((response) {
+    return _File._dispatchWithNamespace(_FILE_IDENTICAL, [null, path1, path2])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
             "Error in FileSystemEntity.identical($path1, $path2)", "");
       }
       return response;
     });
   }
 
   static final RegExp _absoluteWindowsPathPattern =
       new RegExp(r'^(\\\\|[a-zA-Z]:[/\\])');
@@ skipping 40 matching lines @@
    *
    * Comparing a link to its target returns false, as does comparing two links
    * that point to the same target.  To check the target of a link, use
    * Link.target explicitly to fetch it.  Directory links appearing
    * inside a path are followed, though, to find the file system object.
    *
    * Throws an error if one of the paths points to an object that does not
    * exist.
    */
   static bool identicalSync(String path1, String path2) {
-    var result = _identical(path1, path2);
+    var result = _identical(_Namespace._namespace, path1, path2);
     _throwIfError(result, 'Error in FileSystemEntity.identicalSync');
     return result;
   }
 
   /**
    * Test if [watch] is supported on the current system.
    *
    * OS X 10.6 and below is not supported.
    */
   static bool get isWatchSupported => _FileSystemWatcher.isSupported;
@@ skipping 62 matching lines @@
   static bool isFileSync(String path) =>
       (_getTypeSync(path, true) == FileSystemEntityType.FILE._type);
 
   /**
    * Synchronously checks if typeSync(path) returns
    * FileSystemEntityType.DIRECTORY.
    */
   static bool isDirectorySync(String path) =>
       (_getTypeSync(path, true) == FileSystemEntityType.DIRECTORY._type);
 
-  external static _getType(String path, bool followLinks);
-  external static _identical(String path1, String path2);
-  external static _resolveSymbolicLinks(String path);
+  external static _getType(_Namespace namespace, String path, bool followLinks);
+  external static _identical(_Namespace namespace, String path1, String path2);
+  external static _resolveSymbolicLinks(_Namespace namespace, String path);
 
   // Finds the next-to-last component when dividing at path separators.
   static final RegExp _parentRegExp = Platform.isWindows
       ? new RegExp(r'[^/\\][/\\]+[^/\\]')
       : new RegExp(r'[^/]/+[^/]');
 
   /**
    * Removes the final path component of a path, using the platform's
    * path separator to split the path.  Will not remove the root component
    * of a Windows path, like "C:\\" or "\\\\server_name\\".
@@ skipping 23 matching lines @@
       return '.';
     }
   }
 
   /**
    * The directory containing [this].
    */
   Directory get parent => new Directory(parentOf(path));
 
   static int _getTypeSync(String path, bool followLinks) {
-    var result = _getType(path, followLinks);
+    var result = _getType(_Namespace._namespace, path, followLinks);
     _throwIfError(result, 'Error getting type of FileSystemEntity');
     return result;
   }
 
   static Future<int> _getTypeAsync(String path, bool followLinks) {
-    return _IOService
-        ._dispatch(_FILE_TYPE, [path, followLinks]).then((response) {
+    return _File._dispatchWithNamespace(_FILE_TYPE, [null, path, followLinks])
+        .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Error getting type", path);
       }
       return response;
     });
   }
 
   static _throwIfError(Object result, String msg, [String path]) {
     if (result is OSError) {
       throw new FileSystemException(msg, path, result);
@@ skipping 149 matching lines @@
     buffer.write(')');
     return buffer.toString();
   }
 }
 
 class _FileSystemWatcher {
   external static Stream<FileSystemEvent> _watch(
       String path, int events, bool recursive);
   external static bool get isSupported;
 }