Don't read message-body for HEAD responses.

net/http/http_network_transaction.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
@@ skipping 34 matching lines @@
       reused_socket_(false),
       using_ssl_(false),
       using_proxy_(false),
       using_tunnel_(false),
       establishing_tunnel_(false),
       request_headers_bytes_sent_(0),
       header_buf_capacity_(0),
       header_buf_len_(0),
       header_buf_body_offset_(-1),
       header_buf_http_offset_(-1),
-      content_length_(-1),  // -1 means unspecified.
-      content_read_(0),
+      response_body_length_(-1),  // -1 means unspecified.
+      response_body_read_(0),
       read_buf_len_(0),
       next_state_(STATE_NONE) {
 #if defined(OS_WIN)
   // TODO(port): Port the SSLConfigService class to Linux and Mac OS X.
   session->ssl_config_service()->GetSSLConfig(&ssl_config_);
 #endif
 }
 
 int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,
                                   CompletionCallback* callback) {
@@ skipping 62 matching lines @@
   // required yet.
   if (auth_identity_[target].source != HttpAuth::IDENT_SRC_NONE) {
     session_->auth_cache()->Add(AuthOrigin(target), auth_handler_[target],
         auth_identity_[target].username, auth_identity_[target].password,
         AuthPath(target));
   }
 
   bool keep_alive = false;
   if (response_.headers->IsKeepAlive()) {
     // If there is a response body of known length, we need to drain it first.
-    if (content_length_ > 0 || chunked_decoder_.get()) {
+    if (response_body_length_ > 0 || chunked_decoder_.get()) {
       next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
       read_buf_ = new IOBuffer(kDrainBodyBufferSize);  // A bit bucket
       read_buf_len_ = kDrainBodyBufferSize;
       return;
     }
-    if (content_length_ == 0)  // No response body to drain.
+    if (response_body_length_ == 0)  // No response body to drain.
       keep_alive = true;
-    // content_length_ is -1 and we're not using chunked encoding.  We don't
-    // know the length of the response body, so we can't reuse this connection
-    // even though the server says it's keep-alive.
+    // response_body_length_ is -1 and we're not using chunked encoding. We
+    // don't know the length of the response body, so we can't reuse this
+    // connection even though the server says it's keep-alive.
   }
 
   // If the auth scheme is connection-based but the proxy/server mistakenly
   // marks the connection as not keep-alive, the auth is going to fail, so log
   // an error message.
   if (!keep_alive && auth_handler_[target]->is_connection_based() &&
       auth_identity_[target].source != HttpAuth::IDENT_SRC_NONE) {
     std::string auth_target(target == HttpAuth::AUTH_PROXY ?
                             "proxy" : "server");
     LOG(ERROR) << "Can't perform " << auth_handler_[target]->scheme()
@@ skipping 629 matching lines @@
 }
 
 int HttpNetworkTransaction::DoReadBody() {
   DCHECK(read_buf_);
   DCHECK(read_buf_len_ > 0);
   DCHECK(connection_.is_initialized());
 
   next_state_ = STATE_READ_BODY_COMPLETE;
 
   // We may have already consumed the indicated content length.
-  if (content_length_ != -1 && content_read_ >= content_length_)
+  if (response_body_length_ != -1 &&
+      response_body_read_ >= response_body_length_)
     return 0;
 
   // We may have some data remaining in the header buffer.
   if (header_buf_.get() && header_buf_body_offset_ < header_buf_len_) {
     int n = std::min(read_buf_len_, header_buf_len_ - header_buf_body_offset_);
     memcpy(read_buf_->data(), header_buf_.get() + header_buf_body_offset_, n);
     header_buf_body_offset_ += n;
     if (header_buf_body_offset_ == header_buf_len_) {
       header_buf_.reset();
       header_buf_capacity_ = 0;
@@ skipping 23 matching lines @@
       next_state_ = STATE_READ_BODY;
       return OK;
     }
   }
 
   bool done = false, keep_alive = false;
   if (result < 0) {
     // Error while reading the socket.
     done = true;
   } else {
-    content_read_ += result;
+    response_body_read_ += result;
     if (unfiltered_eof ||
-        (content_length_ != -1 && content_read_ >= content_length_) ||
+        (response_body_length_ != -1 &&
+         response_body_read_ >= response_body_length_) ||
         (chunked_decoder_.get() && chunked_decoder_->reached_eof())) {
       done = true;
       keep_alive = response_.headers->IsKeepAlive();
       // We can't reuse the connection if we read more than the advertised
       // content length.
       if (unfiltered_eof ||
-          (content_length_ != -1 && content_read_ > content_length_))
+          (response_body_length_ != -1 &&
+           response_body_read_ > response_body_length_))
         keep_alive = false;
     }
   }
 
   // Clean up connection_ if we are done.
   if (done) {
     LogTransactionMetrics();
     if (!keep_alive)
       connection_.set_socket(NULL);
     connection_.Reset();
@@ skipping 32 matching lines @@
       next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
       return OK;
     }
   }
 
   bool done = false, keep_alive = false;
   if (result < 0) {
     // Error while reading the socket.
     done = true;
   } else {
-    content_read_ += result;
+    response_body_read_ += result;
     if (unfiltered_eof ||
-        (content_length_ != -1 && content_read_ >= content_length_) ||
+        (response_body_length_ != -1 &&
+         response_body_read_ >= response_body_length_) ||
         (chunked_decoder_.get() && chunked_decoder_->reached_eof())) {
       done = true;
       keep_alive = response_.headers->IsKeepAlive();
       // We can't reuse the connection if we read more than the advertised
       // content length.
       if (unfiltered_eof ||
-          (content_length_ != -1 && content_read_ > content_length_))
+          (response_body_length_ != -1 &&
+           response_body_read_ > response_body_length_))
         keep_alive = false;
     }
   }
 
   if (done) {
     DidDrainBodyForAuthRestart(keep_alive);
   } else {
     // Keep draining.
     next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
   }
 
   return OK;
 }
 
 void HttpNetworkTransaction::LogTransactionMetrics() const {
   base::TimeDelta duration = base::Time::Now() - response_.request_time;
   if (60 < duration.InMinutes())
     return;
   UMA_HISTOGRAM_LONG_TIMES("Net.Transaction_Latency", duration);
   if (!duration.InMilliseconds())
     return;
   UMA_HISTOGRAM_COUNTS("Net.Transaction_Bandwidth",
-      static_cast<int> (content_read_ / duration.InMilliseconds()));
+      static_cast<int> (response_body_read_ / duration.InMilliseconds()));
 }
 
 int HttpNetworkTransaction::DidReadResponseHeaders() {
   scoped_refptr<HttpResponseHeaders> headers;
   if (has_found_status_line_start()) {
     headers = new HttpResponseHeaders(
         HttpUtil::AssembleRawHeaders(
             header_buf_.get(), header_buf_body_offset_));
   } else {
     // Fabricate a status line to to preserve the HTTP/0.9 version.
@@ skipping 68 matching lines @@
     header_buf_body_offset_ = -1;
     next_state_ = STATE_READ_HEADERS;
     return OK;
   }
 
   response_.headers = headers;
   response_.vary_data.Init(*request_, *response_.headers);
 
   // Figure how to determine EOF:
 
-  // For certain responses, we know the content length is always 0.
+  // For certain responses, we know the content length is always 0. From
+  // RFC 2616 Section 4.3 Message Body:
+  //
+  // For response messages, whether or not a message-body is included with
+  // a message is dependent on both the request method and the response
+  // status code (section 6.1.1). All responses to the HEAD request method
+  // MUST NOT include a message-body, even though the presence of entity-
+  // header fields might lead one to believe they do. All 1xx
+  // (informational), 204 (no content), and 304 (not modified) responses
+  // MUST NOT include a message-body. All other responses do include a
+  // message-body, although it MAY be of zero length.
   switch (response_.headers->response_code()) {
     case 204:  // No Content
     case 205:  // Reset Content
     case 304:  // Not Modified
-      content_length_ = 0;
+      response_body_length_ = 0;
       break;
   }
+  if (request_->method == "HEAD")
+    response_body_length_ = 0;
 
-  if (content_length_ == -1) {
+  if (response_body_length_ == -1) {
     // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
     // Otherwise "Transfer-Encoding: chunked" trumps "Content-Length: N"
     if (response_.headers->GetHttpVersion() >= HttpVersion(1, 1) &&
         response_.headers->HasHeaderValue("Transfer-Encoding", "chunked")) {
       chunked_decoder_.reset(new HttpChunkedDecoder());
     } else {
-      content_length_ = response_.headers->GetContentLength();
-      // If content_length_ is still -1, then we have to wait for the server to
-      // close the connection.
+      response_body_length_ = response_.headers->GetContentLength();
+      // If response_body_length_ is still -1, then we have to wait for the
+      // server to close the connection.
     }
   }
 
   int rv = HandleAuthChallenge();
   if (rv == WILL_RESTART_TRANSACTION)
     return OK;
   if (rv != OK)
     return rv;
 
   if (using_ssl_ && !establishing_tunnel_) {
@@ skipping 74 matching lines @@
   }
   return error;
 }
 
 void HttpNetworkTransaction::ResetStateForRestart() {
   header_buf_.reset();
   header_buf_capacity_ = 0;
   header_buf_len_ = 0;
   header_buf_body_offset_ = -1;
   header_buf_http_offset_ = -1;
-  content_length_ = -1;
-  content_read_ = 0;
+  response_body_length_ = -1;
+  response_body_read_ = 0;
   read_buf_ = NULL;
   read_buf_len_ = 0;
   request_headers_.clear();
   request_headers_bytes_sent_ = 0;
   chunked_decoder_.reset();
   // Reset the scoped_refptr
   response_.headers = NULL;
   response_.auth_challenge = NULL;
 }
 
@@ skipping 293 matching lines @@
   if (target == HttpAuth::AUTH_PROXY) {
     auth_info->host = ASCIIToWide(proxy_info_.proxy_server().host_and_port());
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     auth_info->host = ASCIIToWide(request_->url.host());
   }
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net