Code cleanup (mostly io lib and some http lib).

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 12 matching lines @@
   bool _paused = false;
   bool _unsubscribed = false;
 
   // Is there a read currently in progress?
   bool _readInProgress = false;
   bool _closed = false;
 
   // Block read but not yet send because stream is paused.
   List<int> _currentBlock;
 
-  _FileStream(String this._path, this._position, this._end) {
+  _FileStream(this._path, this._position, this._end) {
     _setupController();
   }
 
   _FileStream.forStdin() : _position = 0 {
     _setupController();
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {Function onError,
                                         void onDone(),
@@ skipping 164 matching lines @@
             completer.completeError(e, stackTrace);
           },
           cancelOnError: true);
       })
       .catchError((e) {
         completer.completeError(e);
       });
     return completer.future;
   }
 
-  Future<File> close() {
-    return _openFuture.then((openedFile) => openedFile.close());
-  }
+  Future<File> close() =>
+      _openFuture.then((openedFile) => openedFile.close());
 }
 
 
 // Class for encapsulating the native implementation of files.
 class _File extends FileSystemEntity implements File {
   final String path;
 
   // Constructor for file.
-  _File(String this.path) {
+  _File(this.path) {
     if (path is! String) {
       throw new ArgumentError('${Error.safeToString(path)} '
                               'is not a String');
     }
   }
 
   Future<bool> exists() {
     return _IOService.dispatch(_FILE_EXISTS, [path]).then((response) {
       if (_isErrorResponse(response)) {
         throw _exceptionFromResponse(response, "Cannot check existence", path);
@@ skipping 226 matching lines @@
 
   String _tryDecode(List<int> bytes, Encoding encoding) {
     try {
       return encoding.decode(bytes);
     } catch (_) {
       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);
-    });
-  }
+  Future<String> readAsString({Encoding encoding: UTF8}) =>
+    readAsBytes().then((bytes) => _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);
@@ skipping 10 matching lines @@
     }
     return list;
   }
 
   Future<List<String>> readAsLines({Encoding encoding: UTF8}) {
     return readAsBytes().then((bytes) {
       return _decodeLines(bytes, encoding);
     });
   }
 
-  List<String> readAsLinesSync({Encoding encoding: UTF8}) {
-    return _decodeLines(readAsBytesSync(), encoding);
-  }
+  List<String> readAsLinesSync({Encoding encoding: UTF8}) =>
+      _decodeLines(readAsBytesSync(), encoding);
 
   Future<File> writeAsBytes(List<int> bytes,
                             {FileMode mode: FileMode.WRITE,
                              bool flush: false}) {
     try {
       IOSink sink = openWrite(mode: mode);
       sink.add(bytes);
       if (flush) {
         sink.flush().then((_) => sink.close());
       } else {
@@ skipping 41 matching lines @@
   }
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   final String path;
   int _id;
   bool _asyncDispatched = false;
   SendPort _fileService;
 
-  _RandomAccessFile(int this._id, String this.path);
+  _RandomAccessFile(this._id, this.path);
 
   Future<RandomAccessFile> close() {
     return _dispatch(_FILE_CLOSE, [_id], markClosed: true).then((result) {
       if (result != -1) {
         _id = result;
         return this;
       } else {
         throw new FileSystemException("Cannot close file", path);
       }
     });
@@ skipping 322 matching lines @@
 
   void _checkAvailable() {
     if (_asyncDispatched) {
       throw new FileSystemException("An async operation is currently pending", path);
     }
     if (closed) {
       throw new FileSystemException("File closed", path);
     }
   }
 }