Support using the HEAD request in the HTTP library

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 558 matching lines @@
 
 class _HttpRequestResponseBase {
   final int START = 0;
   final int HEADER_SENT = 1;
   final int DONE = 2;
   final int UPGRADED = 3;
 
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _headers = new _HttpHeaders() {
     _state = START;
+    _headResponse = false;
   }
 
   int get contentLength() => _contentLength;
   HttpHeaders get headers() => _headers;
 
   bool get persistentConnection() {
     List<String> connection = headers[HttpHeaders.CONNECTION];
     if (_protocolVersion == "1.1") {
       if (connection == null) return true;
       return !headers[HttpHeaders.CONNECTION].some(
@@ skipping 13 matching lines @@
     headers.remove(HttpHeaders.CONNECTION, "keep-alive");
     if (_protocolVersion == "1.1" && !persistentConnection) {
       headers.add(HttpHeaders.CONNECTION, "close");
     } else if (_protocolVersion == "1.0" && persistentConnection) {
       headers.add(HttpHeaders.CONNECTION, "keep-alive");
     }
   }
 
 
   bool _write(List<int> data, bool copyBuffer) {
+    if (_headResponse) return;
     _ensureHeadersSent();
     bool allWritten = true;
     if (data.length > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(data.length);
         _writeCRLF();
         _httpConnection._write(data, copyBuffer);
         allWritten = _writeCRLF();
       } else {
         _updateContentLength(data.length);
         allWritten = _httpConnection._write(data, copyBuffer);
       }
     }
     return allWritten;
   }
 
   bool _writeList(List<int> data, int offset, int count) {
+    if (_headResponse) return;
     _ensureHeadersSent();
     bool allWritten = true;
     if (count > 0) {
       if (_contentLength < 0) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(count);
         _writeCRLF();
         _httpConnection._writeFrom(data, offset, count);
         allWritten = _writeCRLF();
       } else {
         _updateContentLength(count);
         allWritten = _httpConnection._writeFrom(data, offset, count);
       }
     }
     return allWritten;
   }
 
   bool _writeDone() {
     bool allWritten = true;
     if (_contentLength < 0) {
       // Terminate the content if transfer encoding is chunked.
       allWritten = _httpConnection._write(_Const.END_CHUNKED);
     } else {
-      if (_bodyBytesWritten < _contentLength) {
+      if (!_headResponse && _bodyBytesWritten < _contentLength) {
         throw new HttpException("Sending less than specified content length");
       }
-      assert(_bodyBytesWritten == _contentLength);
+      assert(_headResponse || _bodyBytesWritten == _contentLength);
     }
     if (!persistentConnection) _httpConnection._close();
     return allWritten;
   }
 
   bool _writeHeaders() {
     _headers._mutable = false;
     _headers._write(_httpConnection);
     // Terminate header.
     return _writeCRLF();
@@ skipping 31 matching lines @@
   }
 
   void _updateContentLength(int bytes) {
     if (_bodyBytesWritten + bytes > _contentLength) {
       throw new HttpException("Writing more than specified content length");
     }
     _bodyBytesWritten += bytes;
   }
 
   int _state;
+  bool _headResponse;
 
   _HttpConnectionBase _httpConnection;
   _HttpHeaders _headers;
   List<Cookie> _cookies;
   String _protocolVersion = "1.1";
 
   // Length of the content body. If this is set to -1 (default value)
   // when starting to send data chunked transfer encoding will be
   // used.
   int _contentLength = -1;
@@ skipping 339 matching lines @@
         _headers.add("set-cookie", cookie);
       });
     }
 
     // Write headers.
     bool allWritten = _writeHeaders();
     _state = HEADER_SENT;
     return allWritten;
   }
 
-  // Response status code.
-  int _statusCode;
-  String _reasonPhrase;
+  int _statusCode;  // Response status code.
+  String _reasonPhrase;  // Response reason phrase.
   _HttpOutputStream _outputStream;
   Function _streamErrorHandler;
 }
 
 
 class _HttpInputStream extends _BaseDataInputStream implements InputStream {
   _HttpInputStream(_HttpRequestResponseBase this._requestOrResponse) {
     _checkScheduleCallbacks();
   }
 
@@ skipping 229 matching lines @@
     }
   }
 
   void _onRequestStart(String method, String uri, String version) {
     // Create new request and response objects for this request.
     _request = new _HttpRequest(this);
     _response = new _HttpResponse(this);
     _request._onRequestStart(method, uri, version);
     _request._protocolVersion = version;
     _response._protocolVersion = version;
+    _response._headResponse = method == "HEAD";
   }
 
   void _onResponseStart(int statusCode, String reasonPhrase, String version) {
     // TODO(sgjesse): Error handling.
   }
 
   void _onHeaderReceived(String name, String value) {
     _request._onHeaderReceived(name, value);
   }
 
@@ skipping 147 matching lines @@
 }
 
 
 class _HttpClientRequest
     extends _HttpRequestResponseBase implements HttpClientRequest {
   _HttpClientRequest(String this._method,
                      String this._uri,
                      _HttpClientConnection connection)
       : super(connection) {
     _connection = connection;
-    // Default GET requests to have no content.
-    if (_method == "GET") {
+    // Default GET and HEAD requests to have no content.
+    if (_method == "GET" || _method == "HEAD") {
       _contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) {
     if (_state >= HEADER_SENT) throw new HttpException("Header already sent");
     _contentLength = contentLength;
   }
 
   List<Cookie> get cookies() {
@@ skipping 130 matching lines @@
     // 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);
+    if (name == "content-length") {
+      _contentLength = Math.parseInt(value);
+    }
   }
 
   void _onHeadersComplete() {
     _headers._mutable = false;
     _buffer = new _BufferList();
     if (isRedirect && _connection.followRedirects) {
       if (_connection._redirects == null ||
           _connection._redirects.length < _connection.maxRedirects) {
         // Check the location header.
         List<String> location = headers[HttpHeaders.LOCATION];
@@ skipping 73 matching lines @@
       (method, uri, version) => _onRequestStart(method, uri, version);
     _httpParser.responseStart =
       (statusCode, reasonPhrase, version) =>
       _onResponseStart(statusCode, reasonPhrase, version);
     _httpParser.headerReceived =
         (name, value) => _onHeaderReceived(name, value);
     _httpParser.headersComplete = () => _onHeadersComplete();
     _httpParser.dataReceived = (data) => _onDataReceived(data);
     _httpParser.dataEnd = (closed) => _onDataEnd(closed);
     _httpParser.error = (e) => _onError(e);
-    // Tell the HTTP parser the method it is expecting a response to.
-    _httpParser.responseToMethod = _method;
   }
 
   void _responseDone() {
     if (_closing) {
       if (_socket != null) {
         _socket.close();
       }
     } else {
       _client._returnSocketConnection(_socketConn);
     }
     _socket = null;
     _socketConn = null;
   }
 
   HttpClientRequest open(String method, String uri) {
     _method = method;
+    // Tell the HTTP parser the method it is expecting a response to.
+    _httpParser.responseToMethod = method;
     _request = new _HttpClientRequest(method, uri, this);
     _response = new _HttpClientResponse(this);
     return _request;
   }
 
   DetachedSocket detachSocket() {
     return _detachSocket();
   }
 
   void _onConnectionClosed(e) {
@@ skipping 335 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;
 }