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

sdk/lib/io/secure_socket.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;
 
 /**
  * A high-level class for communicating securely over a TCP socket, using
  * TLS and SSL. The [SecureSocket] exposes both a [Stream] and an
  * [IOSink] interface, making it ideal for using together with
@@ skipping 473 matching lines @@
                                  bufferedData,
                                  requestClientCertificate,
                                  requireClientCertificate,
                                  sendClientCertificate,
                                  onBadCertificate)
          ._handshakeComplete.future;
     });
   }
 
   _RawSecureSocket(
-      InternetAddress this.address,
+      this.address,
       int requestedPort,
-      String this.certificateName,
-      bool this.is_server,
+      this.certificateName,
+      this.is_server,
       RawSocket socket,
-      StreamSubscription this._socketSubscription,
-      List<int> this._bufferedData,
-      bool this.requestClientCertificate,
-      bool this.requireClientCertificate,
-      bool this.sendClientCertificate,
-      bool this.onBadCertificate(X509Certificate certificate)) {
+      this._socketSubscription,
+      this._bufferedData,
+      this.requestClientCertificate,
+      this.requireClientCertificate,
+      this.sendClientCertificate,
+      this.onBadCertificate(X509Certificate certificate)) {
     _controller = new StreamController<RawSocketEvent>(
         sync: true,
         onListen: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange,
         onCancel: _onSubscriptionStateChange);
     _stream = _controller.stream;
     // Throw an ArgumentError if any field is invalid.  After this, all
     // errors will be reported through the future or the stream.
     _secureFilter.init();
@@ skipping 13 matching lines @@
       _socket = rawSocket;
       _socket.readEventsEnabled = true;
       _socket.writeEventsEnabled = false;
       if (_socketSubscription == null) {
         // If a current subscription is provided use this otherwise
         // create a new one.
         _socketSubscription = _socket.listen(_eventDispatcher,
                                              onError: _reportError,
                                              onDone: _doneHandler);
       } else {
-        _socketSubscription.onData(_eventDispatcher);
-        _socketSubscription.onError(_reportError);
-        _socketSubscription.onDone(_doneHandler);
+        _socketSubscription
+          ..onData(_eventDispatcher)
+          ..onError(_reportError)
+          ..onDone(_doneHandler);
       }
       _secureFilter.connect(address.host,
                             (address as dynamic)._in_addr,
                             port,
                             is_server,
                             certificateName,
                             requestClientCertificate ||
                                 requireClientCertificate,
                             requireClientCertificate,
                             sendClientCertificate);
@@ skipping 49 matching lines @@
       throw new ArgumentError("onBadCertificate is not null or a Function");
     }
    }
 
   int get port => _socket.port;
 
   InternetAddress get remoteAddress => _socket.remoteAddress;
 
   int get remotePort => _socket.remotePort;
 
-  int available() {
-    if (_status != CONNECTED) return 0;
-    return _secureFilter.buffers[READ_PLAINTEXT].length;
-  }
+  int available() => _status != CONNECTED ?

[Lasse Reichstein Nielsen, 2014/01/06 09:29:30]

I'd prefer the block-and-return here.

+      0 :
+      _secureFilter.buffers[READ_PLAINTEXT].length;
 
   Future<RawSecureSocket> close() {
     shutdown(SocketDirection.BOTH);
     return _closeCompleter.future;
   }
 
   void _completeCloseCompleter([dummy]) {
     if (!_closeCompleter.isCompleted) _closeCompleter.complete(this);
   }
 
@@ skipping 437 matching lines @@
   }
 }
 
 
 /**
  * A circular buffer backed by an external byte array.  Accessed from
  * both C++ and Dart code in an unsynchronized way, with one reading
  * and one writing.  All updates to start and end are done by Dart code.
  */
 class _ExternalBuffer {
+  List data;  // This will be a ExternalByteArray, backed by C allocated data.
+  int start;
+  int end;
+  final size;
+
   _ExternalBuffer(this.size) {
-    start = size~/2;
-    end = size~/2;
+    start = end = size ~/ 2;
   }
 
   void advanceStart(int bytes) {
     assert(start > end || start + bytes <= end);
     start += bytes;
     if (start >= size) {
       start -= size;
       assert(start <= end);
       assert(start < size);
     }
   }
 
   void advanceEnd(int bytes) {
     assert(start <= end || start > end + bytes);
     end += bytes;
     if (end >= size) {
       end -= size;
       assert(end < start);
       assert(end < size);
     }
   }
 
   bool get isEmpty => end == start;
 
-  int get length {
-    if (start > end) return size + end - start;
-    return end - start;
-  }
+  int get length => start > end ?

[Lasse Reichstein Nielsen, 2014/01/06 09:29:30]

Use block-and-return for these three too.

+      size + end - start :
+      end - start;
 
-  int get linearLength {
-    if (start > end) return size - start;
-    return end - start;
-  }
+  int get linearLength => start > end ?
+      size - start :
+      end - start;
 
-  int get free {
-    if (start > end) return start - end - 1;
-    return size + start - end - 1;
-  }
+  int get free => start > end ?
+    start - end - 1 :
+    size + start - end - 1;
 
   int get linearFree {
     if (start > end) return start - end - 1;
     if (start == 0) return size - end - 1;
     return size - end;
   }
 
   List<int> read(int bytes) {
     if (bytes == null) {
       bytes = length;
@@ skipping 56 matching lines @@
       var toWrite = linearLength;
       if (toWrite == 0) return false;
       int bytes = socket.write(data, start, toWrite);
       advanceStart(bytes);
       if (bytes < toWrite) {
         // The socket has blocked while we have data to write.
         return true;
       }
     }
   }
-
-  List data;  // This will be a ExternalByteArray, backed by C allocated data.
-  int start;
-  int end;
-  final size;
 }
 
 
 abstract class _SecureFilter {
   external factory _SecureFilter();
 
   void connect(String hostName,
                Uint8List addr,
                int port,
                bool is_server,
@@ skipping 22 matching lines @@
  */
 class TlsException implements IOException {
   final String type;
   final String message;
   final OSError osError;
 
   const TlsException([String message = "",
                       OSError osError = null])
      : this._("TlsException", message, osError);
 
-  const TlsException._(String this.type,
-                       String this.message,
-                       OSError this.osError);
+  const TlsException._(this.type, this.message, this.osError);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write(type);
     if (!message.isEmpty) {
       sb.write(": $message");
       if (osError != null) {
         sb.write(" ($osError)");
       }
     } else if (osError != null) {
@@ skipping 18 matching lines @@
 /**
  * An exception that happens in the handshake phase of establishing
  * a secure network connection, when looking up or verifying a
  * certificate.
  */
 class CertificateException extends TlsException {
   const CertificateException([String message = "",
                             OSError osError = null])
      : super._("CertificateException", message, osError);
 }