Clean up IOService implementation to be shared between patched and non-patched code.

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;
@@ skipping 34 matching lines @@
     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() {
-    return IOService.dispatch(DIRECTORY_EXISTS, [path]).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();
-    return IOService.dispatch(DIRECTORY_CREATE, [path]).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() {
-    return IOService.dispatch(DIRECTORY_CREATE_TEMP, [path]).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}) {
-    return IOService.dispatch(DIRECTORY_DELETE, [path, recursive])
+    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) {
-    return IOService.dispatch(DIRECTORY_RENAME, [path, 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) {
@@ skipping 72 matching lines @@
                         bool this.followLinks) {
     controller = new StreamController(onListen: onListen,
                                       onResume: onResume,
                                       onCancel: onCancel,
                                       sync: true);
   }
 
   Stream get stream => controller.stream;
 
   void onListen() {
-    IOService.dispatch(DIRECTORY_LIST_START, [path, recursive, followLinks])
+    _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;
-    IOService.dispatch(DIRECTORY_LIST_NEXT, [id]).then((result) {
+    _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]));
@@ skipping 14 matching lines @@
       }
       nextRunning = false;
       next();
     });
   }
 
   void close() {
     if (closed) return;
     if (id == null) return;
     closed = true;
-    IOService.dispatch(DIRECTORY_LIST_STOP, [id]).then((_) {
+    _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"));
     }
   }
 }