Remove DirectoryException and LinkException from dart:io and use FileException instaed.

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(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 path);
   external static String _systemTemp();
   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);
 
   static Directory get current {
     var result = _current();
     if (result is OSError) {
-      throw new DirectoryException(
+      throw new FileSystemException(
           "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(
+      throw new FileSystemException(
           "Setting current working directory failed", path, result);
     }
   }
 
   Future<bool> exists() {
     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) {
-      throw new DirectoryException("Exists failed", path, result);
+      throw new FileSystemException("Exists failed", path, result);
     }
     return (result == 1);
   }
 
   Directory get absolute => new Directory(_absolutePath);
 
   Future<FileStat> stat() => FileStat.stat(path);
 
   FileStat statSync() => FileStat.statSync(path);
 
@@ skipping 67 matching lines @@
     }
     for (var i = dirsToCreate.length - 1; i >= 0; i--) {
       dirsToCreate[i].createSync();
     }
   }
 
   void createSync({bool recursive: false}) {
     if (recursive) return createRecursivelySync();
     var result = _create(path);
     if (result is OSError) {
-      throw new DirectoryException("Creation failed", path, result);
+      throw new FileSystemException("Creation failed", path, result);
     }
   }
 
   static Directory get systemTemp => new Directory(_systemTemp());
 
   Future<Directory> createTemp([String prefix]) {
     if (prefix == null) prefix = '';
     if (path == '') {
       throw new ArgumentError(
           "Directory.createTemp called with an empty path. "
@@ skipping 23 matching lines @@
           "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";
     }
     var result = _createTemp(fullPrefix);
     if (result is OSError) {
-      throw new DirectoryException("Creation of temporary directory failed",
+      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])
         .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 DirectoryException("Deletion failed", path, result);
+      throw new FileSystemException("Deletion failed", path, result);
     }
   }
 
   Future<Directory> rename(String 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);
+      throw new FileSystemException("Rename failed", path, result);
     }
     return new Directory(newPath);
   }
 
   Stream<FileSystemEntity> list({bool recursive: false,
                                  bool followLinks: true}) {
     return new _AsyncDirectoryLister(
         FileSystemEntity._trimTrailingPathSeparators(path),
         recursive,
         followLinks).stream;
@@ skipping 16 matching lines @@
   }
 
   _exceptionOrErrorFromResponse(response, String message) {
     assert(_isErrorResponse(response));
     switch (response[_ERROR_RESPONSE_ERROR_TYPE]) {
       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);
+        return new FileSystemException(message, path, err);
       default:
         return new Exception("Unknown error");
     }
   }
 }
 
 class _AsyncDirectoryLister {
   static const int LIST_FILE = 0;
   static const int LIST_DIRECTORY = 1;
   static const int LIST_LINK = 2;
@@ skipping 77 matching lines @@
               break;
             case LIST_ERROR:
               error(result[i]);
               break;
             case LIST_DONE:
               close();
               return;
           }
         }
       } else {
-        controller.addError(new DirectoryException("Internal error"));
+        controller.addError(new FileSystemException("Internal error"));
       }
       nextRunning = false;
       next();
     });
   }
 
   void close() {
     if (closed) return;
     if (id == null) return;
     closed = true;
     _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",
+          new FileSystemException("Directory listing failed",
                                  errorPath,
                                  err));
     } else {
       controller.addError(
-          new DirectoryException("Internal error"));
+          new FileSystemException("Internal error"));
     }
   }
 }