Format all dart: library files

sdk/lib/io/http.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;
 
 /**
  * HTTP status codes.
  */
 abstract class HttpStatus {
@@ skipping 35 matching lines @@
   static const int INTERNAL_SERVER_ERROR = 500;
   static const int NOT_IMPLEMENTED = 501;
   static const int BAD_GATEWAY = 502;
   static const int SERVICE_UNAVAILABLE = 503;
   static const int GATEWAY_TIMEOUT = 504;
   static const int HTTP_VERSION_NOT_SUPPORTED = 505;
   // Client generated status code.
   static const int NETWORK_CONNECT_TIMEOUT_ERROR = 599;
 }
 
-
 /**
  * A server that delivers content, such as web pages, using the HTTP protocol.
  *
  * The HttpServer is a [Stream] that provides [HttpRequest] objects. Each
  * HttpRequest has an associated [HttpResponse] object.
  * The server responds to a request by writing to that HttpResponse object.
  * The following example shows how to bind an HttpServer to an IPv6
  * [InternetAddress] on port 80 (the standard port for HTTP servers)
  * and how to listen for requests.
  * Port 80 is the default HTTP port. However, on most systems accessing
@@ skipping 107 matching lines @@
    *     Content-Type: text/plain; charset=utf-8
    *     X-Frame-Options: SAMEORIGIN
    *     X-Content-Type-Options: nosniff
    *     X-XSS-Protection: 1; mode=block
    *
    * If the `Server` header is added here and the `serverHeader` is set as
    * well then the value of `serverHeader` takes precedence.
    */
   HttpHeaders get defaultResponseHeaders;
 
-   /**
+  /**
    * Whether the [HttpServer] should compress the content, if possible.
    *
    * The content can only be compressed when the response is using
    * chunked Transfer-Encoding and the incoming request has `gzip`
    * as an accepted encoding in the Accept-Encoding header.
    *
    * The default value is `false` (compression disabled).
    * To enable, set `autoCompress` to `true`.
    */
   bool autoCompress;
 
   /**
    * Get or set the timeout used for idle keep-alive connections. If no further
    * request is seen within [idleTimeout] after the previous request was
    * completed, the connection is dropped.
    *
    * Default is 120 seconds.
    *
    * Note that it may take up to `2 * idleTimeout` before a idle connection is
    * aborted.
    *
    * To disable, set [idleTimeout] to `null`.
    */
   Duration idleTimeout;
 
-
   /**
    * Starts listening for HTTP requests on the specified [address] and
    * [port].
    *
    * The [address] can either be a [String] or an
    * [InternetAddress]. If [address] is a [String], [bind] will
    * perform a [InternetAddress.lookup] and use the first value in the
    * list. To listen on the loopback adapter, which will allow only
    * incoming connections from the local host, use the value
    * [InternetAddress.LOOPBACK_IP_V4] or
@@ skipping 16 matching lines @@
    * value of [:0:] (the default) a reasonable value will be chosen by
    * the system.
    *
    * The optional argument [shared] specifies whether additional HttpServer
    * objects can bind to the same combination of `address`, `port` and `v6Only`.
    * If `shared` is `true` and more `HttpServer`s from this isolate or other
    * isolates are bound to the port, then the incoming connections will be
    * distributed among all the bound `HttpServer`s. Connections can be
    * distributed over multiple isolates this way.
    */
-  static Future<HttpServer> bind(address,
-                                 int port,
-                                 {int backlog: 0,
-                                  bool v6Only: false,
-                                  bool shared: false})
-      => _HttpServer.bind(address, port, backlog, v6Only, shared);
+  static Future<HttpServer> bind(address, int port,
+          {int backlog: 0, bool v6Only: false, bool shared: false}) =>
+      _HttpServer.bind(address, port, backlog, v6Only, shared);
 
   /**
    * The [address] can either be a [String] or an
    * [InternetAddress]. If [address] is a [String], [bind] will
    * perform a [InternetAddress.lookup] and use the first value in the
    * list. To listen on the loopback adapter, which will allow only
    * incoming connections from the local host, use the value
    * [InternetAddress.LOOPBACK_IP_V4] or
    * [InternetAddress.LOOPBACK_IP_V6]. To allow for incoming
    * connection from the network use either one of the values
@@ skipping 21 matching lines @@
    * set using [SecurityContext.setClientAuthorities].
    *
    * The optional argument [shared] specifies whether additional HttpServer
    * objects can bind to the same combination of `address`, `port` and `v6Only`.
    * If `shared` is `true` and more `HttpServer`s from this isolate or other
    * isolates are bound to the port, then the incoming connections will be
    * distributed among all the bound `HttpServer`s. Connections can be
    * distributed over multiple isolates this way.
    */
 
-  static Future<HttpServer> bindSecure(address,
-                                       int port,
-                                       SecurityContext context,
-                                       {int backlog: 0,
-                                        bool v6Only: false,
-                                        bool requestClientCertificate: false,
-                                        bool shared: false})
-      => _HttpServer.bindSecure(address,
-                                port,
-                                context,
-                                backlog,
-                                v6Only,
-                                requestClientCertificate,
-                                shared);
+  static Future<HttpServer> bindSecure(
+          address, int port, SecurityContext context,
+          {int backlog: 0,
+          bool v6Only: false,
+          bool requestClientCertificate: false,
+          bool shared: false}) =>
+      _HttpServer.bindSecure(address, port, context, backlog, v6Only,
+          requestClientCertificate, shared);
 
   /**
    * Attaches the HTTP server to an existing [ServerSocket]. When the
    * [HttpServer] is closed, the [HttpServer] will just detach itself,
    * closing current connections but not closing [serverSocket].
    */
-  factory HttpServer.listenOn(ServerSocket serverSocket)
-      => new _HttpServer.listenOn(serverSocket);
+  factory HttpServer.listenOn(ServerSocket serverSocket) =>
+      new _HttpServer.listenOn(serverSocket);
 
   /**
    * Permanently stops this [HttpServer] from listening for new
    * connections.  This closes the [Stream] of [HttpRequest]s with a
    * done event. The returned future completes when the server is
    * stopped. For a server started using [bind] or [bindSecure] this
    * means that the port listened on no longer in use.
    *
    * If [force] is `true`, active connections will be closed immediately.
    */
@@ skipping 19 matching lines @@
    */
   set sessionTimeout(int timeout);
 
   /**
    * Returns an [HttpConnectionsInfo] object summarizing the number of
    * current connections handled by the server.
    */
   HttpConnectionsInfo connectionsInfo();
 }
 
-
 /**
  * Summary statistics about an [HttpServer]s current socket connections.
  */
 class HttpConnectionsInfo {
   /**
    * Total number of socket connections.
    */
   int total = 0;
 
   /**
    * Number of active connections where actual request/response
    * processing is active.
    */
   int active = 0;
 
   /**
    * Number of idle connections held by clients as persistent connections.
    */
   int idle = 0;
 
   /**
    * Number of connections which are preparing to close. Note: These
    * connections are also part of the [:active:] count as they might
    * still be sending data to the client before finally closing.
    */
   int closing = 0;
 }
 
-
 /**
  * Headers for HTTP requests and responses.
  *
  * In some situations, headers are immutable:
  *
  * * HttpRequest and HttpClientResponse always have immutable headers.
  *
  * * HttpResponse and HttpClientRequest have immutable headers
  *   from the moment the body is written to.
  *
@@ skipping 62 matching lines @@
   static const USER_AGENT = "user-agent";
   static const VARY = "vary";
   static const VIA = "via";
   static const WARNING = "warning";
   static const WWW_AUTHENTICATE = "www-authenticate";
 
   // Cookie headers from RFC 6265.
   static const COOKIE = "cookie";
   static const SET_COOKIE = "set-cookie";
 
-  static const GENERAL_HEADERS = const [CACHE_CONTROL,
-                                        CONNECTION,
-                                        DATE,
-                                        PRAGMA,
-                                        TRAILER,
-                                        TRANSFER_ENCODING,
-                                        UPGRADE,
-                                        VIA,
-                                        WARNING];
+  static const GENERAL_HEADERS = const [
+    CACHE_CONTROL,
+    CONNECTION,
+    DATE,
+    PRAGMA,
+    TRAILER,
+    TRANSFER_ENCODING,
+    UPGRADE,
+    VIA,
+    WARNING
+  ];
 
-  static const ENTITY_HEADERS = const [ALLOW,
-                                       CONTENT_ENCODING,
-                                       CONTENT_LANGUAGE,
-                                       CONTENT_LENGTH,
-                                       CONTENT_LOCATION,
-                                       CONTENT_MD5,
-                                       CONTENT_RANGE,
-                                       CONTENT_TYPE,
-                                       EXPIRES,
-                                       LAST_MODIFIED];
+  static const ENTITY_HEADERS = const [
+    ALLOW,
+    CONTENT_ENCODING,
+    CONTENT_LANGUAGE,
+    CONTENT_LENGTH,
+    CONTENT_LOCATION,
+    CONTENT_MD5,
+    CONTENT_RANGE,
+    CONTENT_TYPE,
+    EXPIRES,
+    LAST_MODIFIED
+  ];
 
+  static const RESPONSE_HEADERS = const [
+    ACCEPT_RANGES,
+    AGE,
+    ETAG,
+    LOCATION,
+    PROXY_AUTHENTICATE,
+    RETRY_AFTER,
+    SERVER,
+    VARY,
+    WWW_AUTHENTICATE
+  ];
 
-  static const RESPONSE_HEADERS = const [ACCEPT_RANGES,
-                                         AGE,
-                                         ETAG,
-                                         LOCATION,
-                                         PROXY_AUTHENTICATE,
-                                         RETRY_AFTER,
-                                         SERVER,
-                                         VARY,
-                                         WWW_AUTHENTICATE];
-
-  static const REQUEST_HEADERS = const [ACCEPT,
-                                        ACCEPT_CHARSET,
-                                        ACCEPT_ENCODING,
-                                        ACCEPT_LANGUAGE,
-                                        AUTHORIZATION,
-                                        EXPECT,
-                                        FROM,
-                                        HOST,
-                                        IF_MATCH,
-                                        IF_MODIFIED_SINCE,
-                                        IF_NONE_MATCH,
-                                        IF_RANGE,
-                                        IF_UNMODIFIED_SINCE,
-                                        MAX_FORWARDS,
-                                        PROXY_AUTHORIZATION,
-                                        RANGE,
-                                        REFERER,
-                                        TE,
-                                        USER_AGENT];
+  static const REQUEST_HEADERS = const [
+    ACCEPT,
+    ACCEPT_CHARSET,
+    ACCEPT_ENCODING,
+    ACCEPT_LANGUAGE,
+    AUTHORIZATION,
+    EXPECT,
+    FROM,
+    HOST,
+    IF_MATCH,
+    IF_MODIFIED_SINCE,
+    IF_NONE_MATCH,
+    IF_RANGE,
+    IF_UNMODIFIED_SINCE,
+    MAX_FORWARDS,
+    PROXY_AUTHORIZATION,
+    RANGE,
+    REFERER,
+    TE,
+    USER_AGENT
+  ];
 
   /**
    * Gets and sets the date. The value of this property will
    * reflect the 'date' header.
    */
   DateTime date;
 
   /**
    * Gets and sets the expiry date. The value of this property will
    * reflect the 'expires' header.
@@ skipping 38 matching lines @@
 
   /**
    * Gets and sets the chunked transfer encoding header value.
    */
   bool chunkedTransferEncoding;
 
   /**
    * Returns the list of values for the header named [name]. If there
    * is no header with the provided name, [:null:] will be returned.
    */
-  List<String> operator[](String name);
+  List<String> operator [](String name);
 
   /**
    * Convenience method for the value for a single valued header. If
    * there is no header with the provided name, [:null:] will be
    * returned. If the header has more than one value an exception is
    * thrown.
    */
   String value(String name);
 
   /**
@@ skipping 44 matching lines @@
   void noFolding(String name);
 
   /**
    * Remove all headers. Some headers have system supplied values and
    * for these the system supplied values will still be added to the
    * collection of values for the header.
    */
   void clear();
 }
 
-
 /**
  * Representation of a header value in the form:
  *
  *   [:value; parameter1=value1; parameter2=value2:]
  *
  * [HeaderValue] can be used to conveniently build and parse header
  * values on this form.
  *
  * To build an [:accepts:] header with the value
  *
@@ skipping 23 matching lines @@
    */
   factory HeaderValue([String value = "", Map<String, String> parameters]) {
     return new _HeaderValue(value, parameters);
   }
 
   /**
    * Creates a new header value object from parsing a header value
    * string with both value and optional parameters.
    */
   static HeaderValue parse(String value,
-                           {String parameterSeparator: ";",
-                            String valueSeparator: null,
-                            bool preserveBackslash: false}) {
+      {String parameterSeparator: ";",
+      String valueSeparator: null,
+      bool preserveBackslash: false}) {
     return _HeaderValue.parse(value,
-                              parameterSeparator: parameterSeparator,
-                              valueSeparator: valueSeparator,
-                              preserveBackslash: preserveBackslash);
+        parameterSeparator: parameterSeparator,
+        valueSeparator: valueSeparator,
+        preserveBackslash: preserveBackslash);
   }
 
   /**
    * Gets the header value.
    */
   String get value;
 
   /**
    * Gets the map of parameters.
    *
@@ skipping 26 matching lines @@
    * Sets a callback that will be called when the session is timed out.
    */
   void set onTimeout(void callback());
 
   /**
    * Is true if the session has not been sent to the client yet.
    */
   bool get isNew;
 }
 
-
 /**
  * Representation of a content type. An instance of [ContentType] is
  * immutable.
  */
 abstract class ContentType implements HeaderValue {
   /**
    * Content type for plain text using UTF-8 encoding.
    *
    *     text/plain; charset=utf-8
    */
@@ skipping 22 matching lines @@
 
   /**
    * Creates a new content type object setting the primary type and
    * sub type. The charset and additional parameters can also be set
    * using [charset] and [parameters]. If charset is passed and
    * [parameters] contains charset as well the passed [charset] will
    * override the value in parameters. Keys passed in parameters will be
    * converted to lower case. The `charset` entry, whether passed as `charset`
    * or in `parameters`, will have its value converted to lower-case.
    */
-  factory ContentType(String primaryType,
-                      String subType,
-                      {String charset, Map<String, String> parameters}) {
+  factory ContentType(String primaryType, String subType,
+      {String charset, Map<String, String> parameters}) {
     return new _ContentType(primaryType, subType, charset, parameters);
   }
 
   /**
    * Creates a new content type object from parsing a Content-Type
    * header value. As primary type, sub type and parameter names and
    * values are not case sensitive all these values will be converted
    * to lower case. Parsing this string
    *
    *     text/html; charset=utf-8
@@ skipping 19 matching lines @@
    * Gets the sub type.
    */
   String get subType;
 
   /**
    * Gets the character set.
    */
   String get charset;
 }
 
-
 /**
  * Representation of a cookie. For cookies received by the server as
  * Cookie header values only [:name:] and [:value:] fields will be
  * set. When building a cookie for the 'set-cookie' header in the server
  * and when receiving cookies in the client as 'set-cookie' headers all
  * fields can be used.
  */
 abstract class Cookie {
   /**
    * Gets and sets the name.
@@ skipping 52 matching lines @@
   }
 
   /**
    * Returns the formatted string representation of the cookie. The
    * string representation can be used for for setting the Cookie or
    * 'set-cookie' headers
    */
   String toString();
 }
 
-
 /**
  * A server-side object
  * that contains the content of and information about an HTTP request.
  *
  * __Note__: Check out the
  * [http_server](http://pub.dartlang.org/packages/http_server)
  * package, which makes working with the low-level
  * dart:io HTTP server subsystem easier.
  *
  * `HttpRequest` objects are generated by an [HttpServer],
@@ skipping 126 matching lines @@
    * The [HttpResponse] object, used for sending back the response to the
    * client.
    *
    * If the [contentLength] of the body isn't 0, and the body isn't being read,
    * any write calls on the [HttpResponse] automatically drain the request
    * body.
    */
   HttpResponse get response;
 }
 
-
 /**
  * An HTTP response, which returns the headers and data
  * from the server to the client in response to an HTTP request.
  *
  * Every HttpRequest object provides access to the associated [HttpResponse]
  * object through the `response` property.
  * The server sends its response to the client by writing to the
  * HttpResponse object.
  *
  * ## Writing the response
@@ skipping 138 matching lines @@
    */
   Future<Socket> detachSocket({bool writeHeaders: true});
 
   /**
    * Gets information about the client connection. Returns [:null:] if the
    * socket is not available.
    */
   HttpConnectionInfo get connectionInfo;
 }
 
-
 /**
  * A client that receives content, such as web pages, from
  * a server using the HTTP protocol.
  *
  * HttpClient contains a number of methods to send an [HttpClientRequest]
  * to an Http server and receive an [HttpClientResponse] back.
  * For example, you can use the [get], [getUrl], [post], and [postUrl] methods
  * for GET and POST requests, respectively.
  *
  * ## Making a simple GET request: an example
@@ skipping 148 matching lines @@
    * The `Host` header for the request will be set to the value
    * [host]:[port]. This can be overridden through the
    * [HttpClientRequest] interface before the request is sent.  NOTE
    * if [host] is an IP address this will still be set in the `Host`
    * header.
    *
    * For additional information on the sequence of events during an
    * HTTP transaction, and the objects returned by the futures, see
    * the overall documentation for the class [HttpClient].
    */
-  Future<HttpClientRequest> open(String method,
-                                 String host,
-                                 int port,
-                                 String path);
+  Future<HttpClientRequest> open(
+      String method, String host, int port, String path);
 
   /**
    * Opens a HTTP connection.
    *
    * The HTTP method is specified in [method] and the URL to use in
    * [url].
    *
    * The `Host` header for the request will be set to the value
    * [host]:[port]. This can be overridden through the
    * [HttpClientRequest] interface before the request is sent.  NOTE
@@ skipping 217 matching lines @@
    *           url, {"http_proxy": ..., "no_proxy": ...});
    *     }
    *
    * If a proxy requires authentication it is possible to configure
    * the username and password as well. Use the format
    * [:username:password@hostname:port:] to include the username and
    * password. Alternatively the API [addProxyCredentials] can be used
    * to set credentials for proxies which require authentication.
    */
   static String findProxyFromEnvironment(Uri url,
-                                         {Map<String, String> environment}) {
+      {Map<String, String> environment}) {
     return _HttpClient._findProxyFromEnvironment(url, environment);
   }
 
   /**
    * Sets the function to be called when a proxy is requesting
    * authentication. Information on the proxy in use and the security
    * realm for the authentication are passed in the arguments [host],
    * [port] and [realm].
    *
    * The function returns a [Future] which should complete when the
    * authentication has been resolved. If credentials cannot be
    * provided the [Future] should complete with [:false:]. If
    * credentials are available the function should add these using
    * [addProxyCredentials] before completing the [Future] with the value
    * [:true:].
    *
    * If the [Future] completes with [:true:] the request will be retried
    * using the updated credentials. Otherwise response processing will
    * continue normally.
    */
   set authenticateProxy(
       Future<bool> f(String host, int port, String scheme, String realm));
 
   /**
    * Add credentials to be used for authorizing HTTP proxies.
    */
-  void addProxyCredentials(String host,
-                           int port,
-                           String realm,
-                           HttpClientCredentials credentials);
+  void addProxyCredentials(
+      String host, int port, String realm, HttpClientCredentials credentials);
 
   /**
    * Sets a callback that will decide whether to accept a secure connection
    * with a server certificate that cannot be authenticated by any of our
    * trusted root certificates.
    *
    * When an secure HTTP request if made, using this HttpClient, and the
    * server returns a server certificate that cannot be authenticated, the
    * callback is called asynchronously with the [X509Certificate] object and
    * the server's hostname and port.  If the value of [badCertificateCallback]
    * is [:null:], the bad certificate is rejected, as if the callback
    * returned [:false:]
    *
    * If the callback returns true, the secure connection is accepted and the
    * [:Future<HttpClientRequest>:] that was returned from the call making the
    * request completes with a valid HttpRequest object. If the callback returns
    * false, the [:Future<HttpClientRequest>:] completes with an exception.
    *
    * If a bad certificate is received on a connection attempt, the library calls
    * the function that was the value of badCertificateCallback at the time
    * the request is made, even if the value of badCertificateCallback
    * has changed since then.
    */
-  set badCertificateCallback(bool callback(X509Certificate cert,
-                                           String host,
-                                           int port));
+  set badCertificateCallback(
+      bool callback(X509Certificate cert, String host, int port));
 
   /**
    * Shut down the HTTP client. If [force] is [:false:] (the default)
    * the [:HttpClient:] will be kept alive until all active
    * connections are done. If [force] is [:true:] any active
    * connections will be closed to immediately release all
    * resources. These closed connections will receive an [:onError:]
    * callback to indicate that the client was shut down. In both cases
    * trying to establish a new connection after calling [close]
    * will throw an exception.
    */
   void close({bool force: false});
 }
 
-
 /**
  * HTTP request for a client connection.
  *
  * To set up a request, set the headers using the headers property
  * provided in this class and write the data to the body of the request.
  * HttpClientRequest is an [IOSink]. Use the methods from IOSink,
  * such as writeCharCode(), to write the body of the HTTP
  * request. When one of the IOSink methods is used for the first
  * time, the request header is sent. Calling any methods that
  * change the header after it is sent throws an exception.
@@ skipping 107 matching lines @@
    */
   Future<HttpClientResponse> close();
 
   /**
    * Get information about the client connection. Returns [:null:] if the socket
    * is not available.
    */
   HttpConnectionInfo get connectionInfo;
 }
 
-
 /**
  * HTTP response for a client connection.
  *
  * The body of a [HttpClientResponse] object is a
  * [Stream] of data from the server. Listen to the body to handle
  * the data and be notified when the entire body is received.
  *
  *     new HttpClient().get('localhost', 80, '/file.txt')
  *          .then((HttpClientRequest request) => request.close())
  *          .then((HttpClientResponse response) {
@@ skipping 64 matching lines @@
    *
    * All headers added to the request will be added to the redirection
    * request. However, any body sent with the request will not be
    * part of the redirection request.
    *
    * If [followLoops] is set to [:true:], redirect will follow the redirect,
    * even if the URL was already visited. The default value is [:false:].
    *
    * [redirect] will ignore [maxRedirects] and will always perform the redirect.
    */
-  Future<HttpClientResponse> redirect([String method,
-                                       Uri url,
-                                       bool followLoops]);
-
+  Future<HttpClientResponse> redirect(
+      [String method, Uri url, bool followLoops]);
 
   /**
    * Returns the client response headers.
    *
    * The client response headers are immutable.
    */
   HttpHeaders get headers;
 
   /**
    * Detach the underlying socket from the HTTP client. When the
@@ skipping 16 matching lines @@
    */
   X509Certificate get certificate;
 
   /**
    * Gets information about the client connection. Returns [:null:] if the socket
    * is not available.
    */
   HttpConnectionInfo get connectionInfo;
 }
 
-
-abstract class HttpClientCredentials { }
-
+abstract class HttpClientCredentials {}
 
 /**
  * Represents credentials for basic authentication.
  */
 abstract class HttpClientBasicCredentials extends HttpClientCredentials {
   factory HttpClientBasicCredentials(String username, String password) =>
       new _HttpClientBasicCredentials(username, password);
 }
 
-
 /**
  * Represents credentials for digest authentication. Digest
  * authentication is only supported for servers using the MD5
  * algorithm and quality of protection (qop) of either "none" or
  * "auth".
  */
 abstract class HttpClientDigestCredentials extends HttpClientCredentials {
   factory HttpClientDigestCredentials(String username, String password) =>
       new _HttpClientDigestCredentials(username, password);
 }
 
-
 /**
  * Information about an [HttpRequest], [HttpResponse], [HttpClientRequest], or
  * [HttpClientResponse] connection.
  */
 abstract class HttpConnectionInfo {
   InternetAddress get remoteAddress;
   int get remotePort;
   int get localPort;
 }
 
-
 /**
  * Redirect information.
  */
 abstract class RedirectInfo {
   /**
    * Returns the status code used for the redirect.
    */
   int get statusCode;
 
   /**
    * Returns the method used for the redirect.
    */
   String get method;
 
   /**
    * Returns the location for the redirect.
    */
   Uri get location;
 }
 
-
 /**
  * When detaching a socket from either the [:HttpServer:] or the
  * [:HttpClient:] due to a HTTP connection upgrade there might be
  * unparsed data already read from the socket. This unparsed data
  * together with the detached socket is returned in an instance of
  * this class.
  */
 abstract class DetachedSocket {
   Socket get socket;
   List<int> get unparsedData;
 }
 
-
 class HttpException implements IOException {
   final String message;
   final Uri uri;
 
   const HttpException(this.message, {this.uri});
 
   String toString() {
-    var b = new StringBuffer()
-        ..write('HttpException: ')
-        ..write(message);
+    var b = new StringBuffer()..write('HttpException: ')..write(message);
     if (uri != null) {
       b.write(', uri = $uri');
     }
     return b.toString();
   }
 }
 
-
 class RedirectException implements HttpException {
   final String message;
   final List<RedirectInfo> redirects;
 
   const RedirectException(this.message, this.redirects);
 
   String toString() => "RedirectException: $message";
 
   Uri get uri => redirects.last.location;
 }