Mark all private functions in dart: libraries as invisible (*sniff*).

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 {
   final String path;
 
   _Directory(this.path) {
@@ skipping 26 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 FileSystemException(
           "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 38 matching lines @@
         if (exists) return this;
         if (path != parent.path) {
           return parent.create(recursive: true).then((_) {
             return create();
           });
         } else {
           return create();
         }
       });
     } else {
-      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 createSync({bool recursive: false}) {
     if (recursive) {
@@ skipping 16 matching lines @@
       throw new ArgumentError(
           "Directory.createTemp called with an empty path. "
           "To use the system temp directory, use Directory.systemTemp");
     }
     String fullPrefix;
     if (path.endsWith('/') || (Platform.isWindows && path.endsWith('\\'))) {
       fullPrefix = "$path$prefix";
     } else {
       fullPrefix = "$path${Platform.pathSeparator}$prefix";
     }
-    return _IOService.dispatch(_DIRECTORY_CREATE_TEMP, [fullPrefix])
+    return _IOService._dispatch(_DIRECTORY_CREATE_TEMP, [fullPrefix])
         .then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionOrErrorFromResponse(
             response, "Creation of temporary directory failed");
       }
       return new Directory(response);
     });
   }
 
   Directory createTempSync([String prefix]) {
@@ skipping 12 matching lines @@
     var result = _createTemp(fullPrefix);
     if (result is OSError) {
       throw new FileSystemException("Creation of temporary directory failed",
                                    fullPrefix,
                                    result);
     }
     return new Directory(result);
   }
 
   Future<Directory> _delete({bool 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({bool recursive: false}) {
     var result = _deleteNative(path, recursive);
     if (result is OSError) {
       throw new FileSystemException("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 70 matching lines @@
   _AsyncDirectoryLister(this.path, this.recursive, 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 if (response is Error) {
             controller.addError(response);
             close();
           } else {
             error(response);
             close();
@@ skipping 17 matching lines @@
 
   void next() {
     if (canceled) {
       close();
       return;
     }
     if (id == null) return;
     if (controller.isPaused) return;
     if (nextRunning) return;
     nextRunning = true;
-    _IOService.dispatch(_DIRECTORY_LIST_NEXT, [id]).then((result) {
+    _IOService._dispatch(_DIRECTORY_LIST_NEXT, [id]).then((result) {
       nextRunning = false;
       if (result is List) {
         next();
         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;
@@ skipping 19 matching lines @@
 
   void close() {
     if (closed) return;
     if (nextRunning) return;
     void cleanup() {
       controller.close();
       closeCompleter.complete();
     }
     closed = true;
     if (id != null) {
-      _IOService.dispatch(_DIRECTORY_LIST_STOP, [id]).whenComplete(cleanup);
+      _IOService._dispatch(_DIRECTORY_LIST_STOP, [id]).whenComplete(cleanup);
     } else {
       cleanup();
     }
   }
 
   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 FileSystemException("Directory listing failed",
                                  errorPath,
                                  err));
     } else {
       controller.addError(
           new FileSystemException("Internal error"));
     }
   }
 }