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

sdk/lib/io/file_impl.dart

 // Copyright (c) 2013, 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;
 
 // Read the file in blocks of size 64k.
 const int _BLOCK_SIZE = 64 * 1024;
 
 
@@ skipping 351 matching lines @@
     throwIfError(ms, "Cannot retrieve modification time", path);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   }
 
   external static _open(String path, int mode);
 
   RandomAccessFile openSync({FileMode mode: FileMode.READ}) {
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
-      throw new FileException("Unknown file mode. Use FileMode.READ, "
+      throw new FileSystemException("Unknown file mode. Use FileMode.READ, "
                               "FileMode.WRITE or FileMode.APPEND.",
                               path);
     }
     var id = _open(path, mode._mode);
     throwIfError(id, "Cannot open file", path);
     return new _RandomAccessFile(id, path);
   }
 
   external static int _openStdio(int fd);
 
   static RandomAccessFile _openStdioSync(int fd) {
     var id = _openStdio(fd);
     if (id == 0) {
-      throw new FileException("Cannot open stdio file for: $fd");
+      throw new FileSystemException("Cannot open stdio file for: $fd");
     }
     return new _RandomAccessFile(id, "");
   }
 
   Future<String> fullPath() => resolveSymbolicLinks();
 
   String fullPathSync() => resolveSymbolicLinksSync();
 
   Stream<List<int>> openRead([int start, int end]) {
     return new _FileStream(path, start, end);
@@ skipping 33 matching lines @@
       builder.add(data);
     }
     opened.closeSync();
     return builder.takeBytes();
   }
 
   String _tryDecode(List<int> bytes, Encoding encoding) {
     try {
       return encoding.decode(bytes);
     } catch (_) {
-      throw new FileException(
+      throw new FileSystemException(
           "Failed to decode data using encoding '${encoding.name}'", path);
     }
   }
 
   Future<String> readAsString({Encoding encoding: UTF8}) {
     return readAsBytes().then((bytes) {
       return _tryDecode(bytes, encoding);
     });
   }
 
   String readAsStringSync({Encoding encoding: UTF8}) {
     List<int> bytes = readAsBytesSync();
     return _tryDecode(bytes, encoding);
   }
 
   List<String> _decodeLines(List<int> bytes, Encoding encoding) {
     if (bytes.length == 0) return [];
     var list = [];
     var controller = new StreamController(sync: true);
     var error = null;
     controller.stream
         .transform(encoding.decoder)
         .transform(new LineSplitter())
         .listen((line) => list.add(line), onError: (e) => error = e);
     controller.add(bytes);
     controller.close();
     if (error != null) {
-      throw new FileException(
+      throw new FileSystemException(
           "Failed to decode data using encoding '${encoding.name}'", path);
     }
     return list;
   }
 
   Future<List<String>> readAsLines({Encoding encoding: UTF8}) {
     return readAsBytes().then((bytes) {
       return _decodeLines(bytes, encoding);
     });
   }
@@ skipping 33 matching lines @@
   void writeAsStringSync(String contents,
                          {FileMode mode: FileMode.WRITE,
                           Encoding encoding: UTF8}) {
     writeAsBytesSync(encoding.encode(contents), mode: mode);
   }
 
   String toString() => "File: '$path'";
 
   static throwIfError(Object result, String msg, String path) {
     if (result is OSError) {
-      throw new FileException(msg, path, result);
+      throw new FileSystemException(msg, path, result);
     }
   }
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   final String path;
   int _id;
   bool _asyncDispatched = false;
   SendPort _fileService;
 
   _RandomAccessFile(int this._id, String this.path);
 
   Future<RandomAccessFile> close() {
     return _dispatch(_FILE_CLOSE, [_id], markClosed: true).then((result) {
       if (result != -1) {
         _id = result;
         return this;
       } else {
-        throw new FileException("Cannot close file", path);
+        throw new FileSystemException("Cannot close file", path);
       }
     });
   }
 
   external static int _close(int id);
 
   void closeSync() {
     _checkAvailable();
     var id = _close(_id);
     if (id == -1) {
-      throw new FileException("Cannot close file", path);
+      throw new FileSystemException("Cannot close file", path);
     }
     _id = id;
   }
 
   Future<int> readByte() {
     return _dispatch(_FILE_READ_BYTE, [_id]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "readByte failed", path);
       }
       return response;
     });
   }
 
   external static _readByte(int id);
 
   int readByteSync() {
     _checkAvailable();
     var result = _readByte(_id);
     if (result is OSError) {
-      throw new FileException("readByte failed", path, result);
+      throw new FileSystemException("readByte failed", path, result);
     }
     return result;
   }
 
   Future<List<int>> read(int bytes) {
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
     return _dispatch(_FILE_READ, [_id, bytes]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "read failed", path);
       }
       return response[1];
     });
   }
 
   external static _read(int id, int bytes);
 
   List<int> readSync(int bytes) {
     _checkAvailable();
     if (bytes is !int) {
       throw new ArgumentError(bytes);
     }
     var result = _read(_id, bytes);
     if (result is OSError) {
-      throw new FileException("readSync failed", path, result);
+      throw new FileSystemException("readSync failed", path, result);
     }
     return result;
   }
 
   Future<int> readInto(List<int> buffer, [int start, int end]) {
     if (buffer is !List ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError();
     }
@@ skipping 27 matching lines @@
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError();
     }
     if (start == null) start = 0;
     if (end == null) end = buffer.length;
     if (end == start) return 0;
     _checkReadWriteListArguments(buffer.length, start, end);
     var result = _readInto(_id, buffer, start, end);
     if (result is OSError) {
-      throw new FileException("readInto failed", path, result);
+      throw new FileSystemException("readInto failed", path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeByte(int value) {
     if (value is !int) {
       throw new ArgumentError(value);
     }
     return _dispatch(_FILE_WRITE_BYTE, [_id, value]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "writeByte failed", path);
       }
       return this;
     });
   }
 
   external static _writeByte(int id, int value);
 
   int writeByteSync(int value) {
     _checkAvailable();
     if (value is !int) {
       throw new ArgumentError(value);
     }
     var result = _writeByte(_id, value);
     if (result is OSError) {
-      throw new FileException("writeByte failed", path, result);
+      throw new FileSystemException("writeByte failed", path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> writeFrom(List<int> buffer, [int start, int end]) {
     if ((buffer is !List && buffer is !ByteData) ||
         (start != null && start is !int) ||
         (end != null && end is !int)) {
       throw new ArgumentError("Invalid arguments to writeFrom");
     }
@@ skipping 31 matching lines @@
     if (end == null) end = buffer.length;
     if (end == start) return;
     _checkReadWriteListArguments(buffer.length, start, end);
     _BufferAndStart bufferAndStart =
         _ensureFastAndSerializableByteData(buffer, start, end);
     var result = _writeFrom(_id,
                             bufferAndStart.buffer,
                             bufferAndStart.start,
                             end - (start - bufferAndStart.start));
     if (result is OSError) {
-      throw new FileException("writeFrom failed", path, result);
+      throw new FileSystemException("writeFrom failed", path, result);
     }
   }
 
   Future<RandomAccessFile> writeString(String string,
                                        {Encoding encoding: UTF8}) {
     if (encoding is! Encoding) {
       throw new ArgumentError(encoding);
     }
     var data = encoding.encode(string);
     return writeFrom(data, 0, data.length);
@@ skipping 15 matching lines @@
       return response;
     });
   }
 
   external static _position(int id);
 
   int positionSync() {
     _checkAvailable();
     var result = _position(_id);
     if (result is OSError) {
-      throw new FileException("position failed", path, result);
+      throw new FileSystemException("position failed", path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> setPosition(int position) {
     return _dispatch(_FILE_SET_POSITION, [_id, position])
         .then((response) {
           if (_isErrorResponse(response)) {
             throw _exceptionFromResponse(response, "setPosition failed", path);
           }
           return this;
         });
   }
 
   external static _setPosition(int id, int position);
 
   void setPositionSync(int position) {
     _checkAvailable();
     var result = _setPosition(_id, position);
     if (result is OSError) {
-      throw new FileException("setPosition failed", path, result);
+      throw new FileSystemException("setPosition failed", path, result);
     }
   }
 
   Future<RandomAccessFile> truncate(int length) {
     return _dispatch(_FILE_TRUNCATE, [_id, length]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "truncate failed", path);
       }
       return this;
     });
   }
 
   external static _truncate(int id, int length);
 
   void truncateSync(int length) {
     _checkAvailable();
     var result = _truncate(_id, length);
     if (result is OSError) {
-      throw new FileException("truncate failed", path, result);
+      throw new FileSystemException("truncate failed", path, result);
     }
   }
 
   Future<int> length() {
     return _dispatch(_FILE_LENGTH, [_id]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "length failed", path);
       }
       return response;
     });
   }
 
   external static _length(int id);
 
   int lengthSync() {
     _checkAvailable();
     var result = _length(_id);
     if (result is OSError) {
-      throw new FileException("length failed", path, result);
+      throw new FileSystemException("length failed", path, result);
     }
     return result;
   }
 
   Future<RandomAccessFile> flush() {
     return _dispatch(_FILE_FLUSH, [_id]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response,
                                      "flush failed",
                                      path);
       }
       return this;
     });
   }
 
   external static _flush(int id);
 
   void flushSync() {
     _checkAvailable();
     var result = _flush(_id);
     if (result is OSError) {
-      throw new FileException("flush failed", path, result);
+      throw new FileSystemException("flush failed", path, result);
     }
   }
 
   bool get closed => _id == 0;
 
   Future _dispatch(int request, List data, { bool markClosed: false }) {
     if (closed) {
-      return new Future.error(new FileException("File closed", path));
+      return new Future.error(new FileSystemException("File closed", path));
     }
     if (_asyncDispatched) {
       var msg = "An async operation is currently pending";
-      return new Future.error(new FileException(msg, path));
+      return new Future.error(new FileSystemException(msg, path));
     }
     if (markClosed) {
       // Set the id_ to 0 (NULL) to ensure the no more async requests
       // can be issued for this file.
       _id = 0;
     }
     _asyncDispatched = true;
     return _IOService.dispatch(request, data)
         .whenComplete(() {
           _asyncDispatched = false;
         });
   }
 
   void _checkAvailable() {
     if (_asyncDispatched) {
-      throw new FileException("An async operation is currently pending", path);
+      throw new FileSystemException("An async operation is currently pending", path);
     }
     if (closed) {
-      throw new FileException("File closed", path);
+      throw new FileSystemException("File closed", path);
     }
   }
 }