Add 'uri' to HttpException, and include in toString.

sdk/lib/io/http_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;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 23 matching lines @@
   _HttpIncoming(_HttpHeaders this.headers,
                 int this._transferLength,
                 Stream<List<int>> this._stream) {
   }
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {void onError(error),
                                         void onDone(),
                                         bool cancelOnError}) {
     hasSubscriber = true;
-    return _stream.listen(onData,
-                          onError: onError,
-                          onDone: onDone,
-                          cancelOnError: cancelOnError);
+    return _stream
+        .handleError((error) {
+          throw new HttpException(error.message, uri: uri);
+        })
+        .listen(onData,
+                onError: onError,
+                onDone: onDone,
+                cancelOnError: cancelOnError);
   }
 
   // Is completed once all data have been received.
   Future get dataDone => _dataCompleter.future;
 
   void close(bool closing) {
     fullBodyRead = true;
     hasSubscriber = true;
     _dataCompleter.complete(closing);
   }
@@ skipping 95 matching lines @@
   final _HttpClient _httpClient;
 
   // The HttpClientRequest of this response.
   final _HttpClientRequest _httpRequest;
 
   List<Cookie> _cookies;
 
   _HttpClientResponse(_HttpIncoming _incoming,
                       _HttpClientRequest this._httpRequest,
                       _HttpClient this._httpClient)
-      : super(_incoming);
+      : super(_incoming) {
+    // Set uri for potential exceptions.
+    _incoming.uri = _httpRequest.uri;
+  }
 
   int get statusCode => _incoming.statusCode;
   String get reasonPhrase => _incoming.reasonPhrase;
 
   X509Certificate get certificate {
     var socket = _httpRequest._httpClientConnection._socket;
     return socket.peerCertificate;
   }
 
   List<Cookie> get cookies {
@@ skipping 214 matching lines @@
   // Used to mark when the body should be written. This is used for HEAD
   // requests and in error handling.
   bool _ignoreBody = false;
   bool _headersWritten = false;
   bool _asGZip = false;
 
   IOSink _headersSink;
   IOSink _dataSink;
 
   final _HttpOutgoing _outgoing;
+  final Uri _uri;
 
   final _HttpHeaders headers;
 
-  _HttpOutboundMessage(String protocolVersion, _HttpOutgoing outgoing)
+  _HttpOutboundMessage(Uri this._uri,
+                       String protocolVersion,
+                       _HttpOutgoing outgoing)
       : _outgoing = outgoing,
         _headersSink = new IOSink(outgoing, encoding: Encoding.ASCII),
         headers = new _HttpHeaders(protocolVersion) {
     _dataSink = new IOSink(new _HttpOutboundConsumer(this));
   }
 
   int get contentLength => headers.contentLength;
   void set contentLength(int contentLength) {
     headers.contentLength = contentLength;
   }
@@ skipping 92 matching lines @@
             return _headersSink.close();
           }
           stream = stream.transform(new _BufferTransformer());
           if (headers.chunkedTransferEncoding) {
             if (_asGZip) {
               stream = stream.transform(new ZLibDeflater(gzip: true, level: 6));
             }
             stream = stream.transform(new _ChunkedTransformer());
           } else if (contentLength >= 0) {
             stream = stream.transform(
-                new _ContentLengthValidator(contentLength));
+                new _ContentLengthValidator(contentLength, _uri));
           }
           return _headersSink.addStream(stream);
         });
   }
 
   Future _close() {
     // TODO(ajohnsen): Currently, contentLength, chunkedTransferEncoding and
     // persistentConnection is not guaranteed to be in sync.
     if (!_headersWritten) {
       if (!_ignoreBody && headers.contentLength == -1) {
         // If no body was written, _ignoreBody is false (it's not a HEAD
         // request) and the content-length is unspecified, set contentLength to
         // 0.
         headers.chunkedTransferEncoding = false;
         headers.contentLength = 0;
       } else if (!_ignoreBody && headers.contentLength > 0) {
         _headersSink.close().catchError((_) {});
         return new Future.error(new HttpException(
             "No content while contentLength was specified to be greater "
-            " than 0: ${headers.contentLength}."));
+            " than 0: ${headers.contentLength}.",
+            uri: _uri));
       }
     }
     return _writeHeaders().then((_) => _headersSink.close());
   }
 
   void _writeHeader();  // TODO(ajohnsen): Better name.
 }
 
 
 class _HttpOutboundConsumer implements StreamConsumer {
@@ skipping 124 matching lines @@
 }
 
 
 class _HttpResponse extends _HttpOutboundMessage<HttpResponse>
     implements HttpResponse {
   int statusCode = 200;
   String _reasonPhrase;
   List<Cookie> _cookies;
   _HttpRequest _httpRequest;
 
-  _HttpResponse(String protocolVersion,
+  _HttpResponse(Uri uri,
+                String protocolVersion,
                 _HttpOutgoing _outgoing,
                 String serverHeader)
-      : super(protocolVersion, _outgoing) {
+      : super(uri, protocolVersion, _outgoing) {
     if (serverHeader != null) headers.set('Server', serverHeader);
   }
 
   List<Cookie> get cookies {
     if (_cookies == null) _cookies = new List<Cookie>();
     return _cookies;
   }
 
   String get reasonPhrase => _findReasonPhrase(statusCode);
   void set reasonPhrase(String reasonPhrase) {
@@ skipping 144 matching lines @@
   Future<HttpClientResponse> _response;
 
   // TODO(ajohnsen): Get default value from client?
   bool _followRedirects = true;
 
   int _maxRedirects = 5;
 
   List<RedirectInfo> _responseRedirects = [];
 
   _HttpClientRequest(_HttpOutgoing outgoing,
-                     Uri this.uri,
+                     Uri uri,
                      String this.method,
                      _Proxy this._proxy,
                      _HttpClient this._httpClient,
                      _HttpClientConnection this._httpClientConnection)
-      : super("1.1", outgoing) {
+      : super(uri, "1.1", outgoing),
+        uri = uri {
     // GET and HEAD have 'content-length: 0' by default.
     if (method == "GET" || method == "HEAD") {
       contentLength = 0;
     }
   }
 
   Future<HttpClientResponse> get done {
     if (_response == null) {
       _response = Future.wait([_responseCompleter.future,
                                super.done])
@@ skipping 179 matching lines @@
 
   static List<int> get _chunk0Length => new Uint8List.fromList(
       const [0x30, _CharCode.CR, _CharCode.LF, _CharCode.CR, _CharCode.LF]);
 }
 
 
 // Transformer that validates the content length.
 class _ContentLengthValidator
     extends StreamEventTransformer<List<int>, List<int>> {
   final int expectedContentLength;
+  final Uri uri;
   int _bytesWritten = 0;
 
-  _ContentLengthValidator(int this.expectedContentLength);
+  _ContentLengthValidator(int this.expectedContentLength, Uri this.uri);
 
   void handleData(List<int> data, EventSink<List<int>> sink) {
     _bytesWritten += data.length;
     if (_bytesWritten > expectedContentLength) {
       sink.addError(new HttpException(
           "Content size exceeds specified contentLength. "
           "$_bytesWritten bytes written while expected "
           "$expectedContentLength. "
-          "[${new String.fromCharCodes(data)}]"));
+          "[${new String.fromCharCodes(data)}]",
+          uri: uri));
       sink.close();
     } else {
       sink.add(data);
     }
   }
 
   void handleDone(EventSink<List<int>> sink) {
     if (_bytesWritten < expectedContentLength) {
       sink.addError(new HttpException(
           "Content size below specified contentLength. "
           " $_bytesWritten bytes written while expected "
-          "$expectedContentLength."));
+          "$expectedContentLength.",
+          uri: uri));
     }
     sink.close();
   }
 }
 
 
 // Extends StreamConsumer as this is an internal type, only used to pipe to.
 class _HttpOutgoing implements StreamConsumer<List<int>> {
   final Completer _doneCompleter = new Completer();
   final StreamConsumer _consumer;
@@ skipping 19 matching lines @@
 class _HttpClientConnection {
   final String key;
   final Socket _socket;
   final bool _proxyTunnel;
   final _HttpParser _httpParser;
   StreamSubscription _subscription;
   final _HttpClient _httpClient;
   bool _dispose = false;
   Timer _idleTimer;
   bool closed = false;
+  Uri _currentUri;
 
   Completer<_HttpIncoming> _nextResponseCompleter;
   Future _streamFuture;
 
   _HttpClientConnection(String this.key,
                         Socket this._socket,
                         _HttpClient this._httpClient,
                         [this._proxyTunnel = false])
       : _httpParser = new _HttpParser.responseParser() {
     _socket.pipe(_httpParser);
 
     // Set up handlers on the parser here, so we are sure to get 'onDone' from
     // the parser.
     _subscription = _httpParser.listen(
         (incoming) {
           // Only handle one incoming response at the time. Keep the
           // stream paused until the response have been processed.
           _subscription.pause();
           // We assume the response is not here, until we have send the request.
           if (_nextResponseCompleter == null) {
-            throw new HttpException("Unexpected response.");
+            throw new HttpException("Unexpected response.", uri: _currentUri);
           }
           _nextResponseCompleter.complete(incoming);
           _nextResponseCompleter = null;
         },
         onError: (error) {
           if (_nextResponseCompleter != null) {
-            _nextResponseCompleter.completeError(error);
+            _nextResponseCompleter.completeError(
+                new HttpException(error.message, uri: _currentUri));
             _nextResponseCompleter = null;
           }
         },
         onDone: () {
           if (_nextResponseCompleter != null) {
             _nextResponseCompleter.completeError(new HttpException(
-                "Connection closed before response was received"));
+                "Connection closed before response was received",
+                uri: _currentUri));
             _nextResponseCompleter = null;
           }
           close();
         });
   }
 
   _HttpClientRequest send(Uri uri, int port, String method, _Proxy proxy) {
     if (closed) {
-      throw new HttpException("Socket closed before request was sent");
+      throw new HttpException(
+          "Socket closed before request was sent", uri: uri);
     }
+    _currentUri = uri;
     // Start with pausing the parser.
     _subscription.pause();
     _ProxyCredentials proxyCreds;  // Credentials used to authorize proxy.
     _SiteCredentials creds;  // Credentials used to authorize this request.
     var outgoing = new _HttpOutgoing(_socket);
     // Create new request object, wrapping the outgoing connection.
     var request = new _HttpClientRequest(outgoing,
                                          uri,
                                          method,
                                          proxy,
@@ skipping 34 matching lines @@
     // data).
     _httpParser.responseToMethod = method;
     _streamFuture = outgoing.done
         .then((s) {
           // Request sent, set up response completer.
           _nextResponseCompleter = new Completer();
 
           // Listen for response.
           _nextResponseCompleter.future
               .then((incoming) {
+                _currentUri = null;
                 incoming.dataDone.then((_) {
                   if (!_dispose &&
                       incoming.headers.persistentConnection &&
                       request.persistentConnection) {
                     // Return connection, now we are done.
                     _httpClient._returnConnection(this);
                     _subscription.resume();
                   } else {
                     destroy();
                   }
@@ skipping 24 matching lines @@
                     var nextnonce = header.parameters["nextnonce"];
                     if (nextnonce != null) creds.nonce = nextnonce;
                   }
                 }
                 request._onIncoming(incoming);
               })
               // If we see a state error, we failed to get the 'first'
               // element.
               .catchError((error) {
                 throw new HttpException(
-                    "Connection closed before data was received");
+                    "Connection closed before data was received", uri);
               }, test: (error) => error is StateError)
               .catchError((error) {
                 // We are done with the socket.
                 destroy();
                 request._onError(error);
               });
 
           // Resume the parser now we have a handler.
           _subscription.resume();
           return s;
@@ skipping 507 matching lines @@
         (incoming) {
           // If the incoming was closed, close the connection.
           incoming.dataDone.then((closing) {
             if (closing) destroy();
           });
           // Only handle one incoming request at the time. Keep the
           // stream paused until the request has been send.
           _subscription.pause();
           _state = _ACTIVE;
           var outgoing = new _HttpOutgoing(_socket);
-          var response = new _HttpResponse(incoming.headers.protocolVersion,
+          var response = new _HttpResponse(incoming.uri,
+                                           incoming.headers.protocolVersion,
                                            outgoing,
                                            _httpServer.serverHeader);
           var request = new _HttpRequest(response, incoming, _httpServer, this);
           _streamFuture = outgoing.done
               .then((_) {
                 if (_state == _DETACHED) return;
                 if (response.persistentConnection &&
                     request.persistentConnection &&
                     incoming.fullBodyRead) {
                   _state = _IDLE;
@@ skipping 584 matching lines @@
   final Uri location;
 }
 
 String _getHttpVersion() {
   var version = Platform.version;
   // Only include major and minor version numbers.
   int index = version.indexOf('.', version.indexOf('.') + 1);
   version = version.substring(0, index);
   return 'Dart/$version (dart:io)';
 }