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 330 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 78 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;
         }, onError: (e) {
           destroy();
         });

[Bill Hesse, 2013/07/05 12:57:45]

If _currentUri is used to pass the URI to other methods, both synchronously and
asynchronously, then it should be set to null or INVALID when the connection is
done with this particular request.

If it is only used synchronously, then set it to null when we return.

[Anders Johnsen, 2013/08/20 05:46:31]

Done.

     return request;
   }
 
   Future<Socket> detachSocket() {
     return _streamFuture.then(
         (_) => new _DetachedSocket(_socket, _httpParser.detachIncoming()));
   }
 
   void destroy() {
     closed = true;
@@ skipping 494 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)';
 }