Add redirect support to the HTTP client

runtime/bin/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 _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 1130 matching lines @@
 class _HttpClientResponse
     extends _HttpRequestResponseBase implements HttpClientResponse {
   _HttpClientResponse(_HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
   }
 
   int get statusCode() => _statusCode;
   String get reasonPhrase() => _reasonPhrase;
 
+  bool get isRedirect() {
+    return statusCode == HttpStatus.MOVED_PERMANENTLY ||
+           statusCode == HttpStatus.FOUND ||
+           statusCode == HttpStatus.SEE_OTHER ||
+           statusCode == HttpStatus.TEMPORARY_REDIRECT;
+  }
+
   InputStream get inputStream() {
     if (_inputStream == null) {
       _inputStream = new _HttpInputStream(this);
     }
     return _inputStream;
   }
 
   void _onRequestStart(String method, String uri, String version) {
     // TODO(sgjesse): Error handling
   }
 
   void _onResponseStart(int statusCode, String reasonPhrase, String version) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
   }
 
   void _onHeaderReceived(String name, String value) {
     _headers.add(name, value);
   }
 
   void _onHeadersComplete() {
     _headers._mutable = false;
     _buffer = new _BufferList();
-    if (_connection._onResponse != null) {
+    if (isRedirect && _connection.followRedirects) {
+      if (_connection._redirects == null ||
+          _connection._redirects.length < _connection.maxRedirects) {
+        // Check the location header.
+        List<String> location = headers[HttpHeaders.LOCATION];
+        if (location == null || location.length > 1) {
+           throw new RedirectException("Invalid redirect",
+                                       _connection._redirects);
+        }
+        // Check for redirect loop
+        if (_connection._redirects != null) {
+          Uri redirectUrl = new Uri.fromString(location[0]);
+          for (int i = 0; i < _connection._redirects.length; i++) {
+            if (_connection._redirects[i].location.toString() ==
+                redirectUrl.toString()) {
+              throw new RedirectLoop(_connection._redirects);
+            }
+          }
+        }
+        // Drain body and redirect.
+        inputStream.onData = inputStream.read;
+        inputStream.onClosed = _connection.redirect;
+      } else {
+        throw new RedirectLimitExceeded(_connection._redirects);
+      }
+    } else if (_connection._onResponse != null) {
       _connection._onResponse(this);
     }
   }
 
   void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
 
   void _onDataEnd() {
+    _connection._responseDone();
     if (_inputStream != null) _inputStream._closeReceived();
-    _connection._responseDone();
   }
 
   // Delegate functions for the HttpInputStream implementation.
   int _streamAvailable() {
     return _buffer.length;
   }
 
   List<int> _streamRead(int bytesToRead) {
     return _buffer.readBytes(bytesToRead);
   }
@@ skipping 118 matching lines @@
   }
 
   void set onResponse(void handler(HttpClientResponse response)) {
     _onResponse = handler;
   }
 
   void set onError(void callback(e)) {
     _onErrorCallback = callback;
   }
 
+  void redirect([String method, Uri url]) {
+    if (_socketConn != null) {
+      throw new HttpException("Cannot redirect with body data pending");
+    }
+    if (method == null) method = _method;
+    if (url == null) {
+      url = new Uri.fromString(_response.headers.value(HttpHeaders.LOCATION));
+    }
+    if (_redirects == null) {
+      _redirects = new List<_RedirectInfo>();
+    }
+    _redirects.add(new _RedirectInfo(_response.statusCode, method, url));
+    _request = null;
+    _response = null;
+    // Open redirect URL using the same connection instance.
+    _client._openUrl(method, url, this);
+  }
+
+  List<RedirectInfo> get redirects() => _redirects;
+
   Function _onRequest;
   Function _onResponse;
   Function _onErrorCallback;
 
   _HttpClient _client;
   _SocketConnection _socketConn;
   HttpClientRequest _request;
   HttpClientResponse _response;
   String _method;
 
+  // Redirect handling
+  bool followRedirects = true;
+  int maxRedirects = 5;
+  List<_RedirectInfo> _redirects;
+
   // Callbacks.
   var requestReceived;
 }
 
 
 // Class for holding keep-alive sockets in the cache for the HTTP
 // client together with the connection information.
 class _SocketConnection {
   _SocketConnection(String this._host,
                     int this._port,
@@ skipping 19 matching lines @@
 
 class _HttpClient implements HttpClient {
   static final int DEFAULT_EVICTION_TIMEOUT = 60000;
 
   _HttpClient() : _openSockets = new Map(),
                   _activeSockets = new Set(),
                   _shutdown = false;
 
   HttpClientConnection open(
       String method, String host, int port, String path) {
+    _open(method, host, port, path);
+  }
+
+  HttpClientConnection _open(String method,
+                             String host,
+                             int port,
+                             String path,
+                             [_HttpClientConnection connection]) {
     if (_shutdown) throw new HttpException("HttpClient shutdown");
     if (method == null || host == null || port == null || path == null) {
       throw new IllegalArgumentException(null);
     }
-    return _prepareHttpClientConnection(host, port, method, path);
+    return _prepareHttpClientConnection(host, port, method, path, connection);
   }
 
   HttpClientConnection openUrl(String method, Uri url) {
+    _openUrl(method, url);
+  }
+
+  HttpClientConnection _openUrl(String method,
+                                Uri url,
+                                [_HttpClientConnection connection]) {
     if (url.scheme != "http") {
       throw new HttpException("Unsupported URL scheme ${url.scheme}");
     }
     if (url.userInfo != "") {
       throw new HttpException("Unsupported user info ${url.userInfo}");
     }
     int port = url.port == 0 ? HttpClient.DEFAULT_HTTP_PORT : url.port;
     String path;
     if (url.query != "") {
       if (url.fragment != "") {
         path = "${url.path}?${url.query}#${url.fragment}";
       } else {
         path = "${url.path}?${url.query}";
       }
     } else {
       path = url.path;
     }
-    return open(method, url.domain, port, path);
+    return _open(method, url.domain, port, path, connection);
   }
 
   HttpClientConnection get(String host, int port, String path) {
-    return open("GET", host, port, path);
+    return _open("GET", host, port, path);
   }
 
-  HttpClientConnection getUrl(Uri url) => openUrl("GET", url);
+  HttpClientConnection getUrl(Uri url) => _openUrl("GET", url);
 
   HttpClientConnection post(String host, int port, String path) {
-    return open("POST", host, port, path);
+    return _open("POST", host, port, path);
   }
 
-  HttpClientConnection postUrl(Uri url) => openUrl("POST", url);
+  HttpClientConnection postUrl(Uri url) => _openUrl("POST", url);
 
   void shutdown() {
      _openSockets.forEach((String key, Queue<_SocketConnection> connections) {
        while (!connections.isEmpty()) {
          _SocketConnection socketConn = connections.removeFirst();
          socketConn._socket.close();
        }
      });
      _activeSockets.forEach((_SocketConnection socketConn) {
        socketConn._socket.close();
      });
      if (_evictionTimer != null) {
        _evictionTimer.cancel();
      }
      _shutdown = true;
   }
 
   String _connectionKey(String host, int port) {
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
-      String host, int port, String method, String path) {
+    String host,
+    int port,
+    String method,
+    String path,
+    [_HttpClientConnection connection]) {
 
     void _connectionOpened(_SocketConnection socketConn,
                            _HttpClientConnection connection) {
       connection._connectionEstablished(socketConn);
       HttpClientRequest request = connection.open(method, path);
       request.headers.host = host;
       request.headers.port = port;
       if (connection._onRequest != null) {
         connection._onRequest(request);
       } else {
         request.outputStream.close();
       }
     }
 
-    _HttpClientConnection connection = new _HttpClientConnection(this);
+    // Create a new connection if we are not re-using an existing one.
+    if (connection == null) {
+      connection = new _HttpClientConnection(this);
+    }
 
     // If there are active connections for this key get the first one
     // otherwise create a new one.
     Queue socketConnections = _openSockets[_connectionKey(host, port)];
     if (socketConnections == null || socketConnections.isEmpty()) {
       Socket socket = new Socket(host, port);
       // Until the connection is established handle connection errors
       // here as the HttpClientConnection object is not yet associated
       // with the socket.
       socket.onError = (e) {
@@ skipping 82 matching lines @@
 }
 
 
 class _DetachedSocket implements DetachedSocket {
   _DetachedSocket(this._socket, this._unparsedData);
   Socket get socket() => _socket;
   List<int> get unparsedData() => _unparsedData;
   Socket _socket;
   List<int> _unparsedData;
 }
+
+
+class _RedirectInfo implements RedirectInfo {
+  const _RedirectInfo(int this.statusCode,
+                      String this.method,
+                      Uri this.location);
+  final int statusCode;
+  final String method;
+  final Uri location;
+}