Add a boolean data member called_socket_read_ to help...

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/completion_callback.h"
 #include "net/base/ssl_client_socket.h"
@@ skipping 2170 matching lines @@
 
   int rv = trans->Start(&request, &callback1);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(net::ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 
+  // Empty the current queue.  This is necessary because idle sockets are
+  // added to the connection pool asynchronously with a PostTask.
+  MessageLoop::current()->RunAllPending();
+
   // We now check to make sure the TCPClientSocket was not added back to
   // the pool.
   EXPECT_EQ(0, session->connection_pool()->idle_socket_count());
   trans.reset();
+  MessageLoop::current()->RunAllPending();
   // Make sure that the socket didn't get recycled after calling the destructor.
   EXPECT_EQ(0, session->connection_pool()->idle_socket_count());
 }
 
+// Make sure that we recycle a socket after a zero-length response.
+// http://crbug.com/9880
+TEST_F(HttpNetworkTransactionTest, RecycleSocketAfterZeroContentLength) {
+  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
+  scoped_refptr<net::HttpNetworkSession> session(
+      CreateSession(proxy_service.get()));
+
+  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+      session.get(), &mock_socket_factory));
+
+  net::HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/csi?v=3&s=web&action=&"
+                     "tran=undefined&ei=mAXcSeegAo-SMurloeUN&"
+                     "e=17259,18167,19592,19773,19981,20133,20173,20233&"
+                     "rt=prt.2642,ol.2649,xjs.2951");
+  request.load_flags = 0;
+
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.1 204 No Content\r\n"
+             "Content-Length: 0\r\n"
+             "Content-Type: text/html\r\n\r\n"),
+    MockRead("junk"),  // Should not be read!!
+    MockRead(false, net::OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+
+  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  EXPECT_TRUE(response != NULL);
+
+  EXPECT_TRUE(response->headers != NULL);
+  std::string status_line = response->headers->GetStatusLine();
+  EXPECT_EQ("HTTP/1.1 204 No Content", status_line);
+
+  EXPECT_EQ(0, session->connection_pool()->idle_socket_count());
+
+  std::string response_data;
+  rv = ReadTransaction(trans.get(), &response_data);
+  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ("", response_data);
+
+  // Empty the current queue.  This is necessary because idle sockets are
+  // added to the connection pool asynchronously with a PostTask.
+  MessageLoop::current()->RunAllPending();
+
+  // We now check to make sure the socket was added back to the pool.
+  EXPECT_EQ(1, session->connection_pool()->idle_socket_count());
+}
+
 TEST_F(HttpNetworkTransactionTest, ResendRequestOnWriteBodyError) {
   net::HttpRequestInfo request[2];
   // Transaction 1: a GET request that succeeds.  The socket is recycled
   // after use.
   request[0].method = "GET";
   request[0].url = GURL("http://www.google.com/");
   request[0].load_flags = 0;
   // Transaction 2: a POST request.  Reuses the socket kept alive from
   // transaction 1.  The first attempts fails when writing the POST data.
   // This causes the transaction to retry with a new socket.  The second
@@ skipping 596 matching lines @@
   trans->response_body_read_ = 1;
   trans->read_buf_ = new IOBuffer(15);
   trans->read_buf_len_ = 15;
   trans->request_headers_ = "Authorization: NTLM";
   trans->request_headers_bytes_sent_ = 3;
 
   // Setup state in response_
   trans->response_.auth_challenge = new AuthChallengeInfo();
   trans->response_.ssl_info.cert_status = -15;
   trans->response_.response_time = base::Time::Now();
-  trans->response_.was_cached = true; // (Wouldn't ever actually be true...)
+  trans->response_.was_cached = true;  // (Wouldn't ever actually be true...)
 
   { // Setup state for response_.vary_data
     HttpRequestInfo request;
     std::string temp("HTTP/1.1 200 OK\nVary: foo, bar\n\n");
     std::replace(temp.begin(), temp.end(), '\n', '\0');
     scoped_refptr<HttpResponseHeaders> response = new HttpResponseHeaders(temp);
     request.extra_headers = "Foo: 1\nbar: 23";
     EXPECT_TRUE(trans->response_.vary_data.Init(request, *response));
   }
 
@@ skipping 150 matching lines @@
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
 
     EXPECT_FALSE(response == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }
 
 }  // namespace net