Dart: Refactors Proxies

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 94 matching lines @@
         } else {
           return create();
         }
       });
     }
     DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags =
         types.kOpenFlagRead | types.kOpenFlagWrite | types.kOpenFlagCreate;
     var response =
         await rootDirectory.responseOrError(
-            rootDirectory.ptr.openDirectory(_ensurePathIsRelative(path),
-                                            null,
-                                            flags));
+            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();
     // 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.ptr.openDirectory(tempPath, null, flags));
+              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();
     int flags = types.kOpenFlagRead | types.kOpenFlagWrite;
     var response =
         await await rootDirectory.responseOrError(
-            rootDirectory.ptr.openDirectory(_ensurePathIsRelative(path),
-                                            null,
-                                            flags));
+            rootDirectory.openDirectory(_ensurePathIsRelative(path),
+                                        null,
+                                        flags));
     // If we can open it, it exists.
     return response.error == types.Error.ok;
   }
 
   /* patch */ bool existsSync() => _onSyncOperation();
 
   /* patch */ Stream<FileSystemEntity> list({bool recursive: false,
                                             bool followLinks: true}) {
     _DirectoryLister directoryLister = new _DirectoryLister(path, recursive);
     StreamController streamController = new StreamController();
     directoryLister.list(streamController);
     return streamController.stream;
   }
 
   /* patch */ List listSync({bool recursive: false,
                              bool followLinks: true}) {
     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();
     var response = await rootDirectory.responseOrError(
-        rootDirectory.ptr.rename(_ensurePathIsRelative(path),
-                                 _ensurePathIsRelative(newPath)));
+        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();
 
   /* patch */ static _current() {
     return _currentDirectoryPath;
@@ skipping 46 matching lines @@
     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();
       var response =
           await rootDirectory.responseOrError(
-              rootDirectory.ptr.openDirectory(_ensurePathIsRelative(path),
-                                              directory,
-                                              flags));
+              rootDirectory.openDirectory(_ensurePathIsRelative(path),
+                                          directory,
+                                          flags));
       if (response.error != types.Error.ok) {
         // Skip if we can't open it.
         continue;
       }
       // Read contents.
-      var readResponse = await directory.responseOrError(directory.ptr.read());
+      var readResponse = await directory.responseOrError(directory.read());
       // We are done with the directory now.
       directory.close(immediate: true);
       if (readResponse.error != types.Error.ok) {
         // Skip if we can't read it.
         continue;
       }
       List<types.DirectoryEntry> directoryContents =
           readResponse.directoryContents;
       for (types.DirectoryEntry entry in directoryContents) {
         String childPath = '$path/${entry.name}';
@@ skipping 12 matching lines @@
     streamController.close();
   }
 }
 
 patch class _File {
   /* patch */ Future<bool> exists() async {
     DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = types.kOpenFlagRead;
     var response =
         await rootDirectory.responseOrError(
-            rootDirectory.ptr.openFile(_ensurePathIsRelative(path),
-                                       null,
-                                       flags));
+            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();
     int flags = types.kOpenFlagWrite | types.kOpenFlagCreate;
     var response =
         await rootDirectory.responseOrError(
-            rootDirectory.ptr.openFile(_ensurePathIsRelative(path),
-                                       null,
-                                       flags));
+            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();
     var response = await rootDirectory.responseOrError(
-        rootDirectory.ptr.rename(_ensurePathIsRelative(path),
-                                 _ensurePathIsRelative(newPath)));
+        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();
     var response = await rootDirectory.responseOrError(
-        rootDirectory.ptr.openFile(_ensurePathIsRelative(path),
-                                   file,
-                                   _openFlagsFromFileMode(mode)));
+        rootDirectory.openFile(_ensurePathIsRelative(path),
+                               file,
+                               _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.impl.endpoint.handle.h;
+    final int fd = file.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 125 matching lines @@
   /* patch */ static FileStat statSync(String path) {
     return _onSyncOperation();
   }
 
   /* patch */ static Future<FileStat> stat(String path) async {
     DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = types.kOpenFlagRead | types.kOpenFlagWrite;
     DirectoryProxy directory = new DirectoryProxy.unbound();
     var response =
         await await rootDirectory.responseOrError(
-            rootDirectory.ptr.openDirectory(_ensurePathIsRelative(path),
-                                            directory,
-                                            flags));
+            rootDirectory.openDirectory(_ensurePathIsRelative(path),
+                                        directory,
+                                        flags));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
-    var statResponse = await directory.responseOrError(directory.ptr.stat());
+    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);
     }
     types.FileInformation fileInformation = statResponse.fileInformation;
     DateTime modified = _dateTimeFromTimespec(fileInformation.mtime);
     DateTime accessed = _dateTimeFromTimespec(fileInformation.atime);
     int size = fileInformation.size;
     const userReadWriteExecutableUnixMode = 0x1c0;
@@ skipping 20 matching lines @@
   }
 
   /* patch */ String resolveSymbolicLinksSync() {
     return _onSyncOperation();
   }
 
   /* patch */ Future<FileSystemEntity> delete({bool recursive: false}) async {
     DirectoryProxy rootDirectory = await _getRootDirectory();
     int flags = recursive ? types.kDeleteFlagRecursive : 0;
     var response = await rootDirectory.responseOrError(
-        rootDirectory.ptr.delete(_ensurePathIsRelative(path), flags));
+        rootDirectory.delete(_ensurePathIsRelative(path), flags));
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
     return this;
   }
 
   /* patch */ void deleteSync({bool recursive: false}) {
     _onSyncOperation();
   }
 
@@ skipping 74 matching lines @@
   }
 
   void _handleError(dynamic response) {
     if (response.error != types.Error.ok) {
       throw _OSErrorFromError(response.error);
     }
   }
 
   /* patch */ Future<RandomAccessFile> close() async {
     _ensureProxy();
-    await _proxy.responseOrError(_proxy.ptr.close());
+    await _proxy.responseOrError(_proxy.close());
     await _proxy.close(immediate: true);
     _proxy = null;
     closed = true;
     _maybePerformCleanup();
     return this;
   }
 
   /* patch */ void closeSync() {
     _onSyncOperation();
   }
 
   /* patch */ Future<int> readByte() async {
     _ensureProxy();
     var response = await _proxy.responseOrError(
-        _proxy.ptr.read(1, 0, types.Whence.fromCurrent));
+        _proxy.read(1, 0, types.Whence.fromCurrent));
     _handleError(response);
     _resourceInfo.addRead(response.bytesRead.length);
     if (response.bytesRead.length == 0) {
       throw new FileSystemException("readByte failed.");
     }
     return response.bytesRead[0];
   }
 
   /* patch */ int readByteSync() {
     return _onSyncOperation();
   }
 
   /* patch */ Future<List<int>> read(int bytes) async {
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
     _ensureProxy();
     var response = await _proxy.responseOrError(
-        _proxy.ptr.read(bytes, 0, types.Whence.fromCurrent));
+        _proxy.read(bytes, 0, types.Whence.fromCurrent));
     _handleError(response);
     _resourceInfo.addRead(response.bytesRead.length);
     return response.bytesRead;
   }
 
   /* patch */ List<int> readSync(int bytes) {
     return _onSyncOperation();
   }
 
   /* patch */ Future<int> readInto(List<int> buffer,
                                    [int start = 0, int end]) async {
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError();
     }
     end = RangeError.checkValidRange(start, end, buffer.length);
     _ensureProxy();
     if (end == start) {
       return 0;
     }
     int length = end - start;
     var response = await _proxy.responseOrError(
-        _proxy.ptr.read(length, 0, types.Whence.fromCurrent));
+        _proxy.read(length, 0, types.Whence.fromCurrent));
     _handleError(response);
     int read = response.bytesRead.length;
     _resourceInfo.addRead(read);
     buffer.setRange(start, start + read, response.bytesRead);
     return read;
   }
 
   /* patch */ int readIntoSync(List<int> buffer, [int start = 0, int end]) {
     return _onSyncOperation();
   }
 
   /* patch */ Future<RandomAccessFile> writeByte(int value) async {
     if (value is !int) {
       throw new ArgumentError(value);
     }
     _ensureProxy();
     var response = await _proxy.responseOrError(
-        _proxy.ptr.write([value], 0, types.Whence.fromCurrent));
+        _proxy.write([value], 0, types.Whence.fromCurrent));
     _handleError(response);
     assert(response.numBytesWritten == 1);
     _resourceInfo.addWrite(response.numBytesWritten);
     return this;
   }
 
   /* patch */ int writeByteSync(int value) {
     return _onSyncOperation();
   }
 
@@ skipping 17 matching lines @@
       // so that the data we want to write starts at the beginning of the
       // buffer.
       final buffer = new Uint8List(length);
       buffer.setRange(0, length, result.buffer, start);
       // Replace the buffer in result.
       result.buffer = buffer;
       result.start = 0;
     }
     assert(result.start == 0);
     var response = await _proxy.responseOrError(
-        _proxy.ptr.write(result.buffer, 0, types.Whence.fromCurrent));
+        _proxy.write(result.buffer, 0, types.Whence.fromCurrent));
     _handleError(response);
     _resourceInfo.addWrite(response.numBytesWritten);
     return this;
   }
 
   /* patch */ void writeFromSync(List<int> buffer, [int start = 0, int end]) {
     _onSyncOperation();
   }
 
   /* patch */ void writeStringSync(String string, {Encoding encoding: UTF8}) {
     _onSyncOperation();
   }
 
   /* patch */ Future<int> position() async {
     _ensureProxy();
-    var response = await _proxy.responseOrError(_proxy.ptr.tell());
+    var response = await _proxy.responseOrError(_proxy.tell());
     _handleError(response);
     return response.position;
   }
 
   /* patch */ int positionSync() {
     _onSyncOperation();
   }
 
   /* patch */ Future<RandomAccessFile> setPosition(int position) async {
     if (position is !int) {
       throw new ArgumentError(position);
     }
     _ensureProxy();
     var response = await _proxy.responseOrError(
-        _proxy.ptr.seek(position, types.Whence.fromStart));
+        _proxy.seek(position, types.Whence.fromStart));
     _handleError(response);
     return this;
   }
 
   /* patch */ void setPositionSync(int position) {
     _onSyncOperation();
   }
 
   /* patch */ Future<RandomAccessFile> truncate(int length) async {
     if (length is !int) {
       throw new ArgumentError(length);
     }
     _ensureProxy();
-    var response = await _proxy.responseOrError(_proxy.ptr.truncate(length));
+    var response = await _proxy.responseOrError(_proxy.truncate(length));
     _handleError(response);
   }
 
   /* patch */ void truncateSync(int length) {
     _onSyncOperation();
   }
 
   /* patch */ Future<int> length() async {
     _ensureProxy();
-    var response = await _proxy.responseOrError(_proxy.ptr.stat());
+    var response = await _proxy.responseOrError(_proxy.stat());
     _handleError(response);
     return response.fileInformation.size;
   }
 
   /* patch */ int lengthSync() {
     _onSyncOperation();
   }
 
   /* patch */ Future<RandomAccessFile> flush() {
     return this;
@@ skipping 16 matching lines @@
 
   /* patch */ void lockSync(
       [FileLock mode = FileLock.EXCLUSIVE, int start = 0, int end]) {
     _onSyncOperation();
   }
 
   /* patch */ void unlockSync([int start = 0, int end]) {
     _onSyncOperation();
   }
 }