Re-implement support for client redirects.

sdk/lib/io/http_impl.dart

 // Copyright (c) 2012, 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.
 
 
 class _HttpIncomingConnection extends StreamController<List<int>> {
   final Function _pause;
   final Function _resume;
   bool _ignore = false;
   final SignalCompleter _dataCompleter = new SignalCompleter();
   final SignalCompleter _messageCompleter = new SignalCompleter();
 
   // Common properties.
-  _HttpHeaders headers;
-  int contentLength;
+  final _HttpHeaders headers;
   bool upgraded = false;
 
   // ClientResponse properties.
   int statusCode;
   String reasonPhrase;
 
   // Request properties.
   String method;
   Uri uri;
 
-  _HttpIncomingConnection(void this._pause(),
+  _HttpIncomingConnection(_HttpHeaders this.headers,
+                          void this._pause(),
                           void this._resume())
       : super.singleSubscription() {
     _pause();
   }
 
   // Is completed once all data have been received.
   Signal get dataDone => _dataCompleter.signal;
 
   // Is completed once the message have been handled.
   Signal get messageHandled => _messageCompleter.signal;
 
   void onPauseStateChange() {
     if (isPaused) {
       _pause();
     } else {
-      _reasume();
+      _resume();
     }
   }
 
   void onSubscriptionStateChange() {
     if (hasSubscribers) {
       _resume();
     } else {
       _ignore = true;
     }
   }
@@ skipping 56 matching lines @@
     return _queryParameters;
   }
 
   Uri get uri => _incomingConnection.uri;
 
   String get method => _incomingConnection.method;
 }
 
 
 class _HttpClientResponse extends _HttpIncoming implements HttpClientResponse {
-  _HttpClientResponse(_HttpIncomingConnection _incomingConnection)
+  List<RedirectInfo> get redirects => _httpRequest._responseRedirects;
+
+  // The HttpClient this response belongs to.
+  final _HttpClient _httpClient;
+
+  // The HttpClientRequest of this response.
+  final _HttpClientRequest _httpRequest;
+
+  _HttpClientResponse(_HttpIncomingConnection _incomingConnection,
+                      _HttpClientRequest this._httpRequest,
+                      _HttpClient this._httpClient)
       : super(_incomingConnection);
 
   int get statusCode => _incomingConnection.statusCode;
   String get reasonPhrase => _incomingConnection.reasonPhrase;
 
+  bool get isRedirect {
+    if (_httpRequest.method == "GET" || _httpRequest.method == "HEAD") {
+      return statusCode == HttpStatus.MOVED_PERMANENTLY ||
+             statusCode == HttpStatus.FOUND ||
+             statusCode == HttpStatus.SEE_OTHER ||
+             statusCode == HttpStatus.TEMPORARY_REDIRECT;
+    } else if (_httpRequest.method == "POST") {
+      return statusCode == HttpStatus.SEE_OTHER;
+    }
+    return false;
+  }
+
+  Future<HttpClientResponse> redirect([String method,
+                                       Uri url,
+                                       bool followLoops]) {
+    if (method == null) {
+      // Set method as defined by RFC 2616 section 10.3.4.
+      if (statusCode == HttpStatus.SEE_OTHER && _httpRequest.method == "POST") {
+        method = "GET";
+      } else {
+        method = _httpRequest.method;
+      }
+    }
+    if (url == null) {
+      String location = headers.value(HttpHeaders.LOCATION);
+      if (location == null) {
+        throw new StateError("Response has no Location header for redirect");
+      }
+      url = new Uri.fromString(location);
+    }
+    if (followLoops != true) {
+      for (var redirect in redirects) {
+        if (redirect.location == url) {
+          return new Future.immediateError(
+              new RedirectLoopException(redirects));
+        }
+      }
+    }
+    return _httpClient.openUrl(method, url)
+      .then((request) {
+        // Only follow redirects if initial request did.
+        request.followRedirects = _httpRequest.followRedirects;
+        // Allow the same number of redirects.
+        request.maxRedirects = _httpRequest.maxRedirects;
+        // Copy headers.
+        for (var header in _httpRequest.headers._headers.keys) {
+          if (header != HttpHeaders.HOST.toLowerCase()) {
+            request.headers.set(header, _httpRequest.headers[header]);
+          }
+        }
+        request.headers.contentLength = 0;
+        request._responseRedirects.addAll(this.redirects);
+        request._responseRedirects.add(new _RedirectInfo(statusCode,
+                                                         method,
+                                                         url));
+        return request.close();
+      });
+  }
+
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {void onError(AsyncError error),
                                         void onDone(),
                                         bool unsubscribeOnError}) {
     return _incomingConnection.listen(
               onData,
               onError: onError,
               onDone: onDone,
               unsubscribeOnError: unsubscribeOnError);
   }
@@ skipping 88 matching lines @@
 
     // Write headers.
     headers._write(this);
     writeCRLF();
   }
 }
 
 
 class _HttpClientRequest extends _HttpOutgoing<HttpClientRequest>
     implements HttpClientRequest {
-  _HttpClientRequest(Uri this.uri,
+  final String method;
+  final Uri uri;
+  final List<Cookie> cookies = new List<Cookie>();
+
+  // The HttpClient this request belongs to.
+  final _HttpClient _httpClient;
+
+  final Completer<HttpClientResponse> _responseCompleter
+      = new Completer<HttpClientResponse>();
+
+
+  // TODO(ajohnsen): Get default value from client?
+  bool _followRedirects = true;
+
+  int _maxRedirects = 5;
+
+  List<RedirectInfo> _responseRedirects = [];
+
+  _HttpClientRequest(_HttpOutgoingConnection outgoing,
+                     Uri this.uri,
                      String this.method,
-                     _HttpOutgoingConnection outgoing)
+                     _HttpClient this._httpClient)
       : super("1.1", outgoing) {
     // GET and HEAD have 'content-length: 0' by default.
     if (method == "GET" || method == "HEAD") {
       contentLength = 0;
     }
   }
 
+  Future<HttpClientResponse> get response => _responseCompleter.future;
+
   Future<HttpClientResponse> close() {
     super.close();
     return response;
   }
 
+  int get maxRedirects => _maxRedirects;
+  void set maxRedirects(int maxRedirects) {
+    if (_headersWritten) throw new StateError("Request already sent");
+    _maxRedirects = maxRedirects;
+  }
+
+  bool get followRedirects => _followRedirects;
+  void set followRedirects(bool followRedirects) {
+    if (_headersWritten) throw new StateError("Request already sent");
+    _followRedirects = followRedirects;
+  }
+
   void _onIncoming(_HttpIncomingConnection incoming) {
-    // TODO(ajohnsen): Handle redirect and auth.
-    _responseCompleter.complete(new _HttpClientResponse(incoming));
+    // TODO(ajohnsen): Handle auth.
+    var response = new _HttpClientResponse(incoming,
+                                           this,
+                                          _httpClient);
+
+    Future<HttpClientResponse> future;
+
+    if (followRedirects &&
+        response.isRedirect) {
+      if (response.redirects.length < maxRedirects) {
+        // Redirect
+        future = response.redirect();
+      } else {
+        // End with exception, too many redirects.
+        future = new Future.immediateError(
+            new RedirectLimitExceededException(response.redirects));
+      }
+    } else {
+      future = new Future<HttpClientResponse>.immediate(response);
+    }
+
+    future.then(
+        _responseCompleter.complete,
+        onError: (e) {
+          _responseCompleter.completeError(e.error, e.stackTrace);
+        });
   }
 
   void _onError(AsyncError error) {
     _responseCompleter.completeError(error.error, error.stackTrace);
   }
 
   void _writeHeader() {
     writeSP() => add([_CharCode.SP]);
     writeCRLF() => add([_CharCode.CR, _CharCode.LF]);
 
@@ skipping 30 matching lines @@
       }
       headers.add("cookie", sb.toString());
     }
 
     headers._finalize();
 
     // Write headers.
     headers._write(this);
     writeCRLF();
   }
-
-  Future<HttpClientResponse> get response => _responseCompleter.future;
-
-  final String method;
-  final Uri uri;
-  final List<Cookie> cookies = new List<Cookie>();
-  final Completer<HttpClientResponse> _responseCompleter
-      = new Completer<HttpClientResponse>();
 }
 
 
 // Transformer that transforms data to HTTP Chunked Encoding.
 class _ChunkedTransformer extends StreamController<List<int>>
     implements StreamTransformer<List<int>, List<int>> {
   _ChunkedTransformer() : super.singleSubscription();
 
   Stream<List<int>> bind(Stream<List<int>> stream) {
     var subscription = stream.listen(
@@ skipping 134 matching lines @@
 class _HttpClient implements HttpClient {
   // TODO(ajohnsen): Use eviction timeout.
   static const int DEFAULT_EVICTION_TIMEOUT = 60000;
 
   Future<HttpClientRequest> open(String method,
                                  String host,
                                  int port,
                                  String path) {
     // TODO(sgjesse): The path set here can contain both query and
     // fragment. They should be cracked and set correctly.
-    return _open(method, new Uri.fromComponents(
+    return _openUrl(method, new Uri.fromComponents(
         scheme: "http", domain: host, port: port, path: path));
   }
 
   Future<HttpClientRequest> openUrl(String method, Uri url) {
     return _openUrl(method, url);
   }
 
   Future<HttpClientRequest> get(String host,
                                 int port,
                                 String path) {
     return open("get", host, port, path);
   }
 
   Future<HttpClientRequest> getUrl(Uri url) {
-    return _open("get", url);
+    return _openUrl("get", url);
   }
 
   Future<HttpClientRequest> post(String host,
                                  int port,
                                  String path) {
     return open("post", host, port, path);
   }
 
   Future<HttpClientRequest> postUrl(Uri url) {
-    return _open("post", url);
+    return _openUrl("post", url);
   }
 
   void close() {
     for (var queue in _idleConnections.values) {
       for (var connection in queue) {
         connection.destroy();
       }
     }
     _idleConnections.clear();
     for (var connection in _activeConnections) {
       connection.destroy();
     }
     _activeConnections.clear();
   }
 
-  Future<HttpClientRequest> _open(String method,
-                                  Uri uri,
-                                  [_HttpClientConnection connection]) {
+  Future<HttpClientRequest> _openUrl(String method,
+                                     Uri uri,
+                                     [_HttpClientConnection connection]) {
     if (method == null) {
       throw new ArgumentError(method);
     }
     // TODO(ajohnsen): Handle HTTPS.
     if (uri.domain.isEmpty || uri.scheme != "http") {
       throw new ArgumentError("Unsupported scheme '${uri.scheme}' in $uri");
     }
 
     // TODO(ajohnsen): Proxy?
     Future future;
+    int port = uri.port;
+    if (port == 0) port = HttpClient.DEFAULT_HTTP_PORT;
     if (connection == null) {
-      int port = uri.port;
-      if (port == 0) port = HttpClient.DEFAULT_HTTP_PORT;
       future = _getConnection(uri.domain, port);
     } else {
       future = new Future.immediate(connection);
     }
 
     return future.then((_HttpClientConnection connection) {
           onDone() {
             // Called when the connection request/response sequence has ended.
             _returnConnection(connection);
           }
           // Create new internal outgoing connection.
           var outgoing = new _HttpOutgoingConnection();
           // Create new request object, wrapping the outgoing connection.
-          var request = new _HttpClientRequest(
-              uri, method.toUpperCase(), outgoing);
+          var request = new _HttpClientRequest(outgoing,
+                                               uri,
+                                               method.toUpperCase(),
+                                               this);
+          request.headers.host = uri.domain;
+          request.headers.port = port;
           // Start sending the request (lazy, delayed until the user provides
           // data).
           connection.sendRequest(outgoing, onDone)
               .then((incoming) {
                 // The full request have been sent and a response is received
                 // containing status-code, headers and etc.
                 request._onIncoming(incoming);
               })
               .catchError((error) {
                 // An error occoured before the http-header was parsed. This
@@ skipping 363 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }