Don't read message-body for HEAD responses.

net/http/http_network_transaction_unittest.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 <math.h>  // ceil
 
 #include "base/compiler_specific.h"
 #include "net/base/client_socket_factory.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
@@ skipping 388 matching lines @@
     MockRead("HTTP/1.1 204 No Content\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
     MockRead(false, net::OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
   EXPECT_EQ(net::OK, out.rv);
   EXPECT_EQ("HTTP/1.1 204 No Content", out.status_line);
   EXPECT_EQ("", out.response_data);
 }
 
+// Do a request using the HEAD method. Verify that we don't try to read the
+// message body (since HEAD has none).
+TEST_F(HttpNetworkTransactionTest, Head) {
+  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  net::HttpRequestInfo request;
+  request.method = "HEAD";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  MockWrite data_writes1[] = {
+    MockWrite("HEAD / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "Content-Length: 0\r\n\r\n"),
+  };
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 404 Not Found\r\n"),
+    MockRead("Server: Blah\r\n"),
+    MockRead("Content-Length: 1234\r\n\r\n"),
+
+    // No response body because the test stops reading here.
+    MockRead(false, net::ERR_UNEXPECTED),  // Should not be reached.
+  };
+
+  MockSocket data1;
+  data1.reads = data_reads1;
+  data1.writes = data_writes1;
+  mock_sockets[0] = &data1;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback1;
+
+  int rv = trans->Start(&request, &callback1);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+
+  rv = callback1.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+
+  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  EXPECT_FALSE(response == NULL);
+
+  // Check that the headers got parsed.
+  EXPECT_TRUE(response->headers != NULL);
+  EXPECT_EQ(1234, response->headers->GetContentLength());
+  EXPECT_EQ("HTTP/1.1 404 Not Found", response->headers->GetStatusLine());
+
+  std::string server_header;
+  void* iter = NULL;
+  bool has_server_header = response->headers->EnumerateHeader(
+      &iter, "Server", &server_header);
+  EXPECT_TRUE(has_server_header);
+  EXPECT_EQ("Blah", server_header);
+
+  // Reading should give EOF right away, since there is no message body
+  // (despite non-zero content-length).
+  std::string response_data;
+  rv = ReadTransaction(trans.get(), &response_data);
+  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ("", response_data);
+}
+
 TEST_F(HttpNetworkTransactionTest, ReuseConnection) {
   scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
   scoped_refptr<net::HttpNetworkSession> session =
       CreateSession(proxy_service.get());
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
@@ skipping 1777 matching lines @@
 
     rv = callback2.WaitForResult();
     EXPECT_EQ(net::OK, rv);
 
     response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }