Dart: Futures -> Callbacks.

mojo/dart/embedder/io/file_patch.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:_mojo_services/mojo/files/types.mojom.dart' as types;
 
 //
 // Implementation of Directory, File, and RandomAccessFile for Mojo.
 //
 
@@ skipping 72 matching lines @@
       flags = types.kOpenFlagWrite |
               types.kOpenFlagAppend |
               types.kOpenFlagCreate;
       break;
     default:
       throw new UnimplementedError();
   }
   return flags;
 }
 
+
 patch class _Directory {
   // We start at the root of the file system.
   static String _currentDirectoryPath = '/';
 
   /* patch */ Future<Directory> create({bool recursive: false}) async {
     if (recursive) {
       return exists().then((exists) {
         if (exists) return this;
         if (path != parent.path) {
           return parent.create(recursive: true).then((_) {
             return create();
           });
         } else {
           return create();
         }
       });
     }
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags =
         types.kOpenFlagRead | types.kOpenFlagWrite | types.kOpenFlagCreate;
     var response =
         await rootDirectory.responseOrError(
             rootDirectory.openDirectory(_ensurePathIsRelative(path),
                                         null,
                                         flags));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     return this;
   }
 
   /* patch */ void createSync({bool recursive: false}) => _onSyncOperation();
 
   /* patch */ Future<Directory> createTemp([String prefix]) async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     // Create directory and fail if it already exists.
     int flags = types.kOpenFlagRead | types.kOpenFlagWrite |
                 types.kOpenFlagCreate | types.kOpenFlagExclusive;
     String tempPath = '$path/$prefix';
     while (true) {
       var response =
           await rootDirectory.responseOrError(
               rootDirectory.openDirectory(tempPath, null, flags));
       if (response.error == types.Error.ok) {
         // Success.
         break;
       }
       // Alter the path and try again.
       // TODO(johnmccutchan): Append a randomly generated character.
       tempPath = tempPath + 'a';
     }
     return new Directory(tempPath);
   }
 
   /* patch */ Directory createTempSync([String prefix]) => _onSyncOperation();
 
   /* patch */ Future<bool> exists() async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = types.kOpenFlagRead | types.kOpenFlagWrite;
     var response =
         await await rootDirectory.responseOrError(
             rootDirectory.openDirectory(_ensurePathIsRelative(path),
                                         null,
                                         flags));
     // If we can open it, it exists.
     return response.error == types.Error.ok;
   }
 
@@ skipping 12 matching lines @@
     return _onSyncOperation();
   }
 
   /* patch */ Future<FileStat> stat() {
     return FileStat.stat(path);
   }
 
   /* patch */ FileStat statSync() => _onSyncOperation();
 
   /* patch */ Future<Directory> rename(String newPath) async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     var response = await rootDirectory.responseOrError(
         rootDirectory.rename(_ensurePathIsRelative(path),
                              _ensurePathIsRelative(newPath)));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     return new Directory(newPath);
   }
 
   /* patch */ Directory renameSync(String newPath) => _onSyncOperation();
@@ skipping 39 matching lines @@
 class _DirectoryLister {
   final String _path;
   final bool _recursive;
   final List<String> _directoriesToList = new List<String>();
 
   _DirectoryLister(this._path, this._recursive);
 
   list(StreamController streamController) async {
     _directoriesToList.add(_path);
 
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = types.kOpenFlagRead | types.kOpenFlagWrite;
 
     while (_directoriesToList.length > 0) {
       // Remove head.
       String path = _directoriesToList.removeAt(0);
       // Open directory.
-      DirectoryProxy directory = new DirectoryProxy.unbound();
+      _DirectoryProxy directory = new _DirectoryProxy.unbound();
       var response =
           await rootDirectory.responseOrError(
               rootDirectory.openDirectory(_ensurePathIsRelative(path),
-                                          directory,
+                                          directory.proxy,
                                           flags));
       if (response.error != types.Error.ok) {
         // Skip if we can't open it.
         continue;
       }
       // Read contents.
       var readResponse = await directory.responseOrError(directory.read());
       // We are done with the directory now.
       directory.close(immediate: true);
       if (readResponse.error != types.Error.ok) {
@@ skipping 15 matching lines @@
           streamController.add(new File(childPath));
         }
       }
     }
     streamController.close();
   }
 }
 
 patch class _File {
   /* patch */ Future<bool> exists() async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = types.kOpenFlagRead;
     var response =
         await rootDirectory.responseOrError(
             rootDirectory.openFile(_ensurePathIsRelative(path),
                                    null,
                                    flags));
     // If we can open it, it exists.
     return response.error == types.Error.ok;
   }
 
   /* patch */ bool existsSync() => _onSyncOperation();
 
   /* patch */ FileStat statSync() => _onSyncOperation();
 
   /* patch */ Future<File> create({bool recursive: false}) async {
     if (recursive) {
       // Create any parent directories.
       await parent.create(recursive: true);
     }
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = types.kOpenFlagWrite | types.kOpenFlagCreate;
     var response =
         await rootDirectory.responseOrError(
             rootDirectory.openFile(_ensurePathIsRelative(path),
                                    null,
                                    flags));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     return this;
   }
 
   /* patch */ void createSync({bool recursive: false}) => _onSyncOperation();
 
   /* patch */ Future<File> rename(String newPath) async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     var response = await rootDirectory.responseOrError(
         rootDirectory.rename(_ensurePathIsRelative(path),
                              _ensurePathIsRelative(newPath)));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     return new File(newPath);
   }
 
   /* patch */ File renameSync(String newPath) => _onSyncOperation();
 
   /* patch */ Future<File> copy(String newPath) async {
     File copyFile = new File(newPath);
     Stream<List<int>> input = openRead();
     IOSink output = copyFile.openWrite();
     // Copy contents.
     await output.addStream(input);
     // Close.
     await output.close();
     return copyFile;
   }
 
   /* patch */ File copySync(String newPath) => _onSyncOperation();
 
   /* patch */ Future<RandomAccessFile> open(
       {FileMode mode: FileMode.READ}) async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
-    FileProxy file = new FileProxy.unbound();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
+    _FileProxy file = new _FileProxy.unbound();
     var response = await rootDirectory.responseOrError(
         rootDirectory.openFile(_ensurePathIsRelative(path),
-                               file,
+                               file.proxy,
                                _openFlagsFromFileMode(mode)));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     // We use the raw mojo handle as our fd.
-    final int fd = file.ctrl.endpoint.handle.h;
+    final int fd = file.proxy.ctrl.endpoint.handle.h;
     // Construct the RandomAccessFile using the original constructor.
     _RandomAccessFile raf = new _RandomAccessFile(fd, path);
     // Hook up our proxy.
     raf._proxy = file;
     return raf;
   }
 
   /* patch */ Future<int> length() async {
     FileStat fileStat = await FileStat.stat(path);
     return fileStat.size;
@@ skipping 120 matching lines @@
     throw new UnimplementedError();
   }
 }
 
 patch class FileStat {
   /* patch */ static FileStat statSync(String path) {
     return _onSyncOperation();
   }
 
   /* patch */ static Future<FileStat> stat(String path) async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = types.kOpenFlagRead | types.kOpenFlagWrite;
-    DirectoryProxy directory = new DirectoryProxy.unbound();
+    _DirectoryProxy directory = new _DirectoryProxy.unbound();
     var response =
         await await rootDirectory.responseOrError(
             rootDirectory.openDirectory(_ensurePathIsRelative(path),
-                                        directory,
+                                        directory.proxy,
                                         flags));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     var statResponse = await directory.responseOrError(directory.stat());
     // We are done with the directory now.
     directory.close(immediate: true);
     if (statResponse.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
@@ skipping 22 matching lines @@
   /* patch */ Future<String> resolveSymbolicLinks() {
     // TODO(johnmccutchan): Canonicalize path before returning.
     return path;
   }
 
   /* patch */ String resolveSymbolicLinksSync() {
     return _onSyncOperation();
   }
 
   /* patch */ Future<FileSystemEntity> delete({bool recursive: false}) async {
-    DirectoryProxy rootDirectory = await _getRootDirectory();
+    _DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = recursive ? types.kDeleteFlagRecursive : 0;
     var response = await rootDirectory.responseOrError(
         rootDirectory.delete(_ensurePathIsRelative(path), flags));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     return this;
   }
 
   /* patch */ void deleteSync({bool recursive: false}) {
@@ skipping 61 matching lines @@
       => throw new UnimplementedError();
   position() => throw new UnimplementedError();
   setPosition(int position) => throw new UnimplementedError();
   truncate(int length) => throw new UnimplementedError();
   length() => throw new UnimplementedError();
   flush() => throw new UnimplementedError();
   lock(int lock, int start, int end) => throw new UnimplementedError();
 }
 
 patch class _RandomAccessFile {
-  FileProxy _proxy;
+  _FileProxy _proxy;
 
   void _ensureProxy() {
     if (_proxy == null) {
       throw new StateError("_RandomAccessFile has a null proxy.");
     }
   }
 
   void _handleError(dynamic response) {
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
@@ skipping 201 matching lines @@
 
   /* patch */ void lockSync(
       [FileLock mode = FileLock.EXCLUSIVE, int start = 0, int end]) {
     _onSyncOperation();
   }
 
   /* patch */ void unlockSync([int start = 0, int end]) {
     _onSyncOperation();
   }
 }