Merge services into a shared IOService in dart:io, and use a native port.

sdk/lib/io/directory_impl.dart

 // Copyright (c) 2012, 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;
 
 class _Directory extends FileSystemEntity implements Directory {
   static const CREATE_REQUEST = 0;
   static const DELETE_REQUEST = 1;
   static const EXISTS_REQUEST = 2;
   static const CREATE_TEMP_REQUEST = 3;
   static const LIST_START_REQUEST = 4;
   static const LIST_NEXT_REQUEST = 5;
   static const LIST_STOP_REQUEST = 6;
   static const RENAME_REQUEST = 7;
 
   final String path;
-  SendPort _directoryService;
 
   _Directory(String this.path) {
     if (path is! String) {
       throw new ArgumentError('${Error.safeToString(path)} '
                               'is not a String');
     }
   }
 
   external static _current();
   external static _setCurrent(path);
   external static _createTemp(String template);
   external static int _exists(String path);
   external static _create(String path);
   external static _deleteNative(String path, bool recursive);
   external static _rename(String path, String newPath);
   external static List _list(String path, bool recursive, bool followLinks);
-  external static SendPort _newServicePort();
 
   static Directory get current {
     var result = _current();
     if (result is OSError) {
       throw new DirectoryException(
           "Getting current working directory failed", "", result);
     }
     return new _Directory(result);
   }
 
   static void set current(path) {
     if (path is Directory) path = path.path;
     var result = _setCurrent(path);
     if (result is ArgumentError) throw result;
     if (result is OSError) {
       throw new DirectoryException(
           "Setting current working directory failed", path, result);
     }
   }
 
   Future<bool> exists() {
-    _ensureDirectoryService();
-    List request = new List(2);
-    request[0] = EXISTS_REQUEST;
-    request[1] = path;
-    return _directoryService.call(request).then((response) {
+    return IOService.dispatch(DIRECTORY_EXISTS, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionOrErrorFromResponse(response, "Exists failed");
       }
       return response == 1;
     });
   }
 
   bool existsSync() {
     var result = _exists(path);
     if (result is OSError) {
@@ skipping 54 matching lines @@
       if (future == null) {
         return new Future.value(this);
       } else {
         return future.then((_) => this);
       }
     });
   }
 
   Future<Directory> create({recursive: false}) {
     if (recursive) return createRecursively();
-    _ensureDirectoryService();
-    List request = new List(2);
-    request[0] = CREATE_REQUEST;
-    request[1] = path;
-    return _directoryService.call(request).then((response) {
+    return IOService.dispatch(DIRECTORY_CREATE, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionOrErrorFromResponse(response, "Creation failed");
       }
       return this;
     });
   }
 
   void createRecursivelySync() {
     var path = new _Path(this.path);
     var dirsToCreate = [];
@@ skipping 11 matching lines @@
 
   void createSync({recursive: false}) {
     if (recursive) return createRecursivelySync();
     var result = _create(path);
     if (result is OSError) {
       throw new DirectoryException("Creation failed", path, result);
     }
   }
 
   Future<Directory> createTemp() {
-    _ensureDirectoryService();
-    List request = new List(2);
-    request[0] = CREATE_TEMP_REQUEST;
-    request[1] = path;
-    return _directoryService.call(request).then((response) {
+    return IOService.dispatch(DIRECTORY_CREATE_TEMP, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionOrErrorFromResponse(
             response, "Creation of temporary directory failed");
       }
       return new Directory(response);
     });
   }
 
   Directory createTempSync() {
     var result = _createTemp(path);
     if (result is OSError) {
       throw new DirectoryException("Creation of temporary directory failed",
                                    path,
                                    result);
     }
     return new Directory(result);
   }
 
   Future<Directory> _delete({recursive: false}) {
-    _ensureDirectoryService();
-    List request = new List(3);
-    request[0] = DELETE_REQUEST;
-    request[1] = path;
-    request[2] = recursive;
-    return _directoryService.call(request).then((response) {
-      if (_isErrorResponse(response)) {
-        throw _exceptionOrErrorFromResponse(response, "Deletion failed");
-      }
-      return this;
-    });
+    return IOService.dispatch(DIRECTORY_DELETE, [path, recursive])
+        .then((response) {
+          if (_isErrorResponse(response)) {
+            throw _exceptionOrErrorFromResponse(response, "Deletion failed");
+          }
+          return this;
+        });
   }
 
   void _deleteSync({recursive: false}) {
     var result = _deleteNative(path, recursive);
     if (result is OSError) {
       throw new DirectoryException("Deletion failed", path, result);
     }
   }
 
   Future<Directory> rename(String newPath) {
-    _ensureDirectoryService();
-    List request = new List(3);
-    request[0] = RENAME_REQUEST;
-    request[1] = path;
-    request[2] = newPath;
-    return _directoryService.call(request).then((response) {
-      if (_isErrorResponse(response)) {
-        throw _exceptionOrErrorFromResponse(response, "Rename failed");
-      }
-      return new Directory(newPath);
-    });
+    return IOService.dispatch(DIRECTORY_RENAME, [path, newPath])
+        .then((response) {
+          if (_isErrorResponse(response)) {
+            throw _exceptionOrErrorFromResponse(response, "Rename failed");
+          }
+          return new Directory(newPath);
+        });
   }
 
   Directory renameSync(String newPath) {
     if (newPath is !String) {
       throw new ArgumentError();
     }
     var result = _rename(path, newPath);
     if (result is OSError) {
       throw new DirectoryException("Rename failed", path, result);
     }
@@ skipping 30 matching lines @@
       case _ILLEGAL_ARGUMENT_RESPONSE:
         return new ArgumentError();
       case _OSERROR_RESPONSE:
         var err = new OSError(response[_OSERROR_RESPONSE_MESSAGE],
                               response[_OSERROR_RESPONSE_ERROR_CODE]);
         return new DirectoryException(message, path, err);
       default:
         return new Exception("Unknown error");
     }
   }
-
-  void _ensureDirectoryService() {
-    if (_directoryService == null) {
-      _directoryService = _newServicePort();
-    }
-  }
 }
 
 class _AsyncDirectoryLister {
   static const int LIST_FILE = 0;
   static const int LIST_DIRECTORY = 1;
   static const int LIST_LINK = 2;
   static const int LIST_ERROR = 3;
   static const int LIST_DONE = 4;
 
   static const int RESPONSE_TYPE = 0;
@@ skipping 16 matching lines @@
                         bool this.followLinks) {
     controller = new StreamController(onListen: onListen,
                                       onResume: onResume,
                                       onCancel: onCancel,
                                       sync: true);
   }
 
   Stream get stream => controller.stream;
 
   void onListen() {
-    var request = [_Directory.LIST_START_REQUEST, path, recursive, followLinks];
-    _Directory._newServicePort().call(request)
+    IOService.dispatch(DIRECTORY_LIST_START, [path, recursive, followLinks])
         .then((response) {
           if (response is int) {
             id = response;
             next();
           } else {
             error(response);
             controller.close();
           }
         });
   }
@@ skipping 12 matching lines @@
 
   void next() {
     if (canceled) {
       close();
       return;
     }
     if (id == null) return;
     if (controller.isPaused) return;
     assert(!nextRunning);
     nextRunning = true;
-    _Directory._newServicePort().call([_Directory.LIST_NEXT_REQUEST, id])
-        .then((result) {
-          if (result is List) {
-            assert(result.length % 2 == 0);
-            for (int i = 0; i < result.length; i++) {
-              assert(i % 2 == 0);
-              switch (result[i++]) {
-                case LIST_FILE:
-                  controller.add(new File(result[i]));
-                  break;
-                case LIST_DIRECTORY:
-                  controller.add(new Directory(result[i]));
-                  break;
-                case LIST_LINK:
-                  controller.add(new Link(result[i]));
-                  break;
-                case LIST_ERROR:
-                  error(result[i]);
-                  break;
-                case LIST_DONE:
-                  close();
-                  return;
-              }
-            }
-          } else {
-            controller.addError(new DirectoryException("Internal error"));
+    IOService.dispatch(DIRECTORY_LIST_NEXT, [id]).then((result) {
+      if (result is List) {
+        assert(result.length % 2 == 0);
+        for (int i = 0; i < result.length; i++) {
+          assert(i % 2 == 0);
+          switch (result[i++]) {
+            case LIST_FILE:
+              controller.add(new File(result[i]));
+              break;
+            case LIST_DIRECTORY:
+              controller.add(new Directory(result[i]));
+              break;
+            case LIST_LINK:
+              controller.add(new Link(result[i]));
+              break;
+            case LIST_ERROR:
+              error(result[i]);
+              break;
+            case LIST_DONE:
+              close();
+              return;
           }
-          nextRunning = false;
-          next();
-        });
+        }
+      } else {
+        controller.addError(new DirectoryException("Internal error"));
+      }
+      nextRunning = false;
+      next();
+    });
   }
 
   void close() {
     if (closed) return;
     if (id == null) return;
     closed = true;
-    _Directory._newServicePort().call([_Directory.LIST_STOP_REQUEST, id])
-        .then((_) {
-          controller.close();
-        });
+    IOService.dispatch(DIRECTORY_LIST_STOP, [id]).then((_) {
+      controller.close();
+    });
   }
 
   void error(message) {
     var errorType =
         message[RESPONSE_ERROR][_ERROR_RESPONSE_ERROR_TYPE];
     if (errorType == _ILLEGAL_ARGUMENT_RESPONSE) {
       controller.addError(new ArgumentError());
     } else if (errorType == _OSERROR_RESPONSE) {
       var responseError = message[RESPONSE_ERROR];
       var err = new OSError(
           responseError[_OSERROR_RESPONSE_MESSAGE],
           responseError[_OSERROR_RESPONSE_ERROR_CODE]);
       var errorPath = message[RESPONSE_PATH];
       if (errorPath == null) errorPath = path;
       controller.addError(
           new DirectoryException("Directory listing failed",
                                  errorPath,
                                  err));
     } else {
       controller.addError(
           new DirectoryException("Internal error"));
     }
   }
 }