Retry requests on reused sockets that receive ERR_EMPTY_RESPONSE.

net/http/http_network_transaction_unittest.cc

Index: net/http/http_network_transaction_unittest.cc
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 0703350ab2ffb399cb8bc3915ff7d8cc9753d890..487d03479baa99005f1366a8aa5d9e5146f46efa 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -45,6 +45,7 @@
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream.h"
 #include "net/http/http_stream_factory.h"
+#include "net/http/http_stream_factory_test_util.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_info.h"
@@ -283,6 +284,13 @@ class HttpNetworkTransactionTest
   void KeepAliveConnectionResendRequestTest(const MockWrite* write_failure,
                                             const MockRead* read_failure);
 
+  // Either |write_failure| specifies a write failure or |read_failure|
+  // specifies a read failure when using a reused socket.  In either case, the
+  // failure should cause the network transaction to resend the request, and the
+  // other argument should be NULL.
+  void PreconnectMissResendRequestTest(const MockWrite* write_failure,
+                                       const MockRead* read_failure);
+
   SimpleGetHelperResult SimpleGetHelperForData(StaticSocketDataProvider* data[],
                                                size_t data_count) {
     SimpleGetHelperResult out;
@@ -1298,6 +1306,94 @@ void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
   }
 }
 
+void HttpNetworkTransactionTest::PreconnectMissResendRequestTest(

[mmenke, 2014/03/14 16:38:06]

Not sure if "PreconnectMiss" is quite the right name for these.

Maybe "PreconnectErrorResendRequestTest" (And similar changes for the test
names)

[davidben, 2014/03/14 18:35:03]

Done.

+    const MockWrite* write_failure,
+    const MockRead* read_failure) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.foo.com/");
+  request.load_flags = 0;
+
+  CapturingNetLog net_log;
+  session_deps_.net_log = &net_log;
+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+
+  // Swap out the HttpStreamFactory.
+  HttpNetworkSessionPeer peer(session.get());
+  MockHttpStreamFactoryImplForPreconnect* mock_factory =
+      new MockHttpStreamFactoryImplForPreconnect(session.get(), false);
+  peer.SetHttpStreamFactory(scoped_ptr<HttpStreamFactory>(mock_factory));
+
+  // Written data for successfully sending a request.
+  MockWrite data1_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.foo.com\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+  };
+
+  // Read results for the first request.
+  MockRead data1_reads[] = {
+    MockRead(ASYNC, OK),
+  };
+
+  if (write_failure) {
+    ASSERT_TRUE(!read_failure);

[mmenke, 2014/03/14 16:38:06]

Hrm...ASSERT_FALSE?  Guess this was just copied from the others, and should
stick with being consistent

[davidben, 2014/03/14 18:35:03]

Eh. Flipped both of them.

+    data1_writes[0] = *write_failure;
+  } else {
+    ASSERT_TRUE(read_failure);
+    data1_reads[0] = *read_failure;
+  }
+
+  StaticSocketDataProvider data1(data1_reads, arraysize(data1_reads),
+                                 data1_writes, arraysize(data1_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data1);
+
+  MockRead data2_reads[] = {
+    MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
+    MockRead("hello"),
+    MockRead(ASYNC, OK),
+  };
+  StaticSocketDataProvider data2(data2_reads, arraysize(data2_reads), NULL, 0);
+  session_deps_.socket_factory->AddSocketDataProvider(&data2);
+
+  // Preconnect a socket.
+  net::SSLConfig ssl_config;
+  session->ssl_config_service()->GetSSLConfig(&ssl_config);
+  if (session->http_stream_factory()->has_next_protos())
+    ssl_config.next_protos = session->http_stream_factory()->next_protos();
+  session->http_stream_factory()->PreconnectStreams(
+      1, request, DEFAULT_PRIORITY, ssl_config, ssl_config);
+  mock_factory->WaitForPreconnects();
+  EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
+
+  // Make the request.
+  TestCompletionCallback callback;
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+
+  LoadTimingInfo load_timing_info;
+  EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
+  TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
+
+  const HttpResponseInfo* response = trans->GetResponseInfo();
+  ASSERT_TRUE(response != NULL);
+
+  EXPECT_TRUE(response->headers.get() != NULL);
+  EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+
+  std::string response_data;
+  rv = ReadTransaction(trans.get(), &response_data);
+  EXPECT_EQ(OK, rv);
+  EXPECT_EQ("hello", response_data);
+}
+
 TEST_P(HttpNetworkTransactionTest,
        KeepAliveConnectionNotConnectedOnWrite) {
   MockWrite write_failure(ASYNC, ERR_SOCKET_NOT_CONNECTED);
@@ -1314,6 +1410,22 @@ TEST_P(HttpNetworkTransactionTest, KeepAliveConnectionEOF) {
   KeepAliveConnectionResendRequestTest(NULL, &read_failure);
 }
 
+TEST_P(HttpNetworkTransactionTest,
+       PreconnectMissNotConnectedOnWrite) {
+  MockWrite write_failure(ASYNC, ERR_SOCKET_NOT_CONNECTED);
+  PreconnectMissResendRequestTest(&write_failure, NULL);
+}
+
+TEST_P(HttpNetworkTransactionTest, PreconnectMissReset) {
+  MockRead read_failure(ASYNC, ERR_CONNECTION_RESET);
+  PreconnectMissResendRequestTest(NULL, &read_failure);
+}
+
+TEST_P(HttpNetworkTransactionTest, PreconnectMissEOF) {
+  MockRead read_failure(SYNCHRONOUS, OK);  // EOF
+  PreconnectMissResendRequestTest(NULL, &read_failure);
+}
+
 TEST_P(HttpNetworkTransactionTest, NonKeepAliveConnectionReset) {
   HttpRequestInfo request;
   request.method = "GET";