HTTP retry support.

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 8c078c4c1f158797ad4d8715d780b02e902750ca..f508a9cffa1b0c565dea8594c597b5f54868434a 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -282,6 +282,20 @@ class HttpNetworkTransactionTest
   void KeepAliveConnectionResendRequestTest(const MockWrite* write_failure,
                                             const MockRead* read_failure);
 
+  // Test behaviour of retries when a request can be retried automatically.
+  void PartialDataRetryTest(int expected_status,
+                            const char* expected_response_data,
+                            MockRead read1[],
+                            size_t read1_count,
+                            MockRead read2[],
+                            size_t read2_count,
+                            MockRead read3[] = NULL,
+                            size_t read3_count = 0,
+                            MockRead read4[] = NULL,
+                            size_t read4_count = 0,
+                            MockRead read5[] = NULL,
+                            size_t read5_count = 0);

[mmenke, 2014/07/23 20:17:43]

While the Google style guide does technically allow default arguments in limited
situations, including this one, I believe, we generally avoid their use, and use
vectors instead.

+
   // 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
@@ -1337,6 +1351,91 @@ void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
   }
 }
 
+void HttpNetworkTransactionTest::PartialDataRetryTest(
+    int expected_status,
+    const char* expected_response_data,
+    MockRead read1[],
+    size_t read1_count,
+    MockRead read2[],
+    size_t read2_count,
+    MockRead read3[],
+    size_t read3_count,
+    MockRead read4[],
+    size_t read4_count,
+    MockRead read5[],
+    size_t read5_count) {
+  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;

[mmenke, 2014/07/23 20:17:42]

nit:  Don't need these two lines (A lot of tests set up a NetLog unnecessarily).

[jonnyr, 2014/07/25 13:42:00]

Done, but meant that I also had to remove TestLoadTimingNotReused. Should not be
important for this test though.

+  scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
+
+  // Written data for successfully sending both requests.
+  MockWrite data1_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.foo.com\r\n"
+              "Connection: keep-alive\r\n\r\n")
+  };
+
+  StaticSocketDataProvider data1(read1, read1_count,
+      data1_writes, arraysize(data1_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data1);
+
+  StaticSocketDataProvider data2(read2, read2_count, NULL, 0);

[mmenke, 2014/07/23 20:17:43]

Hrm...Only checking the write of the first request?

[jonnyr, 2014/07/25 13:42:00]

Yes, I need to see if I can verify that the retry request is correct somehow.
That is currently not done.

+  if (read2)
+    session_deps_.socket_factory->AddSocketDataProvider(&data2);
+
+  StaticSocketDataProvider data3(read3, read3_count, NULL, 0);
+  if (read3)
+    session_deps_.socket_factory->AddSocketDataProvider(&data3);
+
+  StaticSocketDataProvider data4(read4, read4_count, NULL, 0);
+  if (read4)
+    session_deps_.socket_factory->AddSocketDataProvider(&data4);
+
+  StaticSocketDataProvider data5(read5, read5_count, NULL, 0);
+  if (read5)
+    session_deps_.socket_factory->AddSocketDataProvider(&data5);
+
+  uint32 first_socket_log_id = NetLog::Source::kInvalidId;
+  for (int i = 0; i < 1; ++i) {

[mmenke, 2014/07/23 20:17:43]

This loop isn't needed.

[jonnyr, 2014/07/25 13:41:59]

Done.

+    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);
+    if (i == 0) {
+      first_socket_log_id = load_timing_info.socket_log_id;
+    } else {
+      // The second request should be using a new socket.
+      EXPECT_NE(first_socket_log_id, load_timing_info.socket_log_id);
+    }
+
+    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(expected_status, rv);
+    EXPECT_EQ(expected_response_data, response_data);
+  }
+}
+
 void HttpNetworkTransactionTest::PreconnectErrorResendRequestTest(
     const MockWrite* write_failure,
     const MockRead* read_failure,
@@ -1538,6 +1637,497 @@ TEST_P(HttpNetworkTransactionTest, SpdyPreconnectErrorAsyncEOF) {
   PreconnectErrorResendRequestTest(NULL, &read_failure, true);
 }
 
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryInHeader) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"),
+    MockRead("Content-Lengt"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"),
+    MockRead("Content-Length: 2\r\n\r\n"),
+    MockRead("AA"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "AA", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryInBodySingleRead) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"),
+    MockRead("Cache-Control: max-age=100\r\n"),
+    MockRead("Content-Length: 2\r\n\r\n"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"),
+    MockRead("Cache-Control: max-age=100\r\n"),

[mmenke, 2014/07/23 20:17:43]

I don't believe this test should have the max age header - that's checked in the
next one.

[jonnyr, 2014/07/25 13:41:59]

This test checks full header without any body data for border cases. Name of
test now changed to indicate that.

+    MockRead("Content-Length: 2\r\n\r\nAB"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "AB", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryMaxAgeSuccess) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"),
+    MockRead("Cache-Control: max-age=100\r\n"),
+    MockRead("Content-Length: 2\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"),
+    MockRead("Cache-Control: max-age=100\r\n"),
+    MockRead("Content-Length: 2\r\n\r\nAC"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "AC", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryInBodyPragmaNoCache) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Pragma: no-cache\r\n"\

[mmenke, 2014/07/23 20:17:43]

Backslashes aren't needed at the end of these lines.

[jonnyr, 2014/07/25 13:42:00]

Done.

+             "Content-Length: 2\r\n\r\n"),
+    MockRead("A"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\nPragma: no-cache\r\n"),

[mmenke, 2014/07/23 20:17:43]

Pragma: no-cache should be on its own line (Or did you intend to remove it? 
Think that might be for the best, since it's the first request's header that
matters)

Actually...we shouldn't even read from this socket again, so there probably
shouldn't be a data_reads2.  That ensures that we hard fail if we try to create
another socket, I believe.

[jonnyr, 2014/07/25 13:42:00]

Done.

+    MockRead("Content-Length: 2\r\n\r\n"),
+    MockRead("AD"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_CONNECTION_RESET, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryCacheControlNoCache) {

[mmenke, 2014/07/23 20:17:43]

How's this different from the previous test?

[jonnyr, 2014/07/25 13:42:00]

It is not different anymore. Earlier it went through two different codepaths.
Removed now.

+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: no-cache\r\n"),
+    MockRead("Content-Length: 2\r\n\r\nO"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: no-cache\r\n"),
+    MockRead("Content-Length: 2\r\n\r\nOK"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_CONNECTION_RESET, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryMaxAgeFail) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=-1\r\n"),
+    MockRead("Content-Length: 2\r\n\r\n"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {

[mmenke, 2014/07/23 20:17:43]

Again, shouldn't be a second read when we don't use it (Not going to mention
this for the other tests it applies to).

[jonnyr, 2014/07/25 13:42:00]

Done.

+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=-1\r\n"),
+    MockRead("Content-Length: 2\r\n\r\nAE"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_CONNECTION_RESET, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryAlmostExpired) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Date: Wed,14 Dec 2011 15:50:00 GMT\r\n"),
+    MockRead("Expires: Wed,14 Dec 2011 15:50:59 GMT\r\n"),
+    MockRead("Content-Length: 2\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Date: Wed,14 Dec 2011 15:50:00 GMT\r\n"),
+    MockRead("Expires: Wed,14 Dec 2011 15:50:59 GMT\r\n"),
+    MockRead("Content-Length: 2\r\n\r\nAF"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_CONNECTION_RESET, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryInBodyMultipleReads) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Content-Length: 2\r\n"),
+    MockRead("Cache-Control: max-age=100\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Content-Length: 2\r\n"),
+    MockRead("Cache-Control: max-age=100\r\n\r\nA"),
+    MockRead("G"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "AG", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryInLargeBody) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 400\r\n\r\n"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\

[mmenke, 2014/07/23 20:17:43]

All these backslashes aren't needed.

[jonnyr, 2014/07/25 13:42:00]

Done.

+             "0123456789012345678901234567890123456789012345678901234567890"),

[mmenke, 2014/07/23 20:17:43]

Suggest splitting this up into multiple reads, in both cases (And maybe divide
up the body reads a bit differently in the two sets of reads).

[jonnyr, 2014/07/25 13:41:59]

Done.

+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 400\r\n\r\n"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "012345678901234567890123456789012345678901234567890123456789"\
+             "0123456789012345678901234567890123456789"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK,
+      "0123456789012345678901234567890123456789012345678901234567890123456789"\
+      "0123456789012345678901234567890123456789012345678901234567890123456789"\
+      "0123456789012345678901234567890123456789012345678901234567890123456789"\
+      "0123456789012345678901234567890123456789012345678901234567890123456789"\
+      "0123456789012345678901234567890123456789012345678901234567890123456789"\
+      "01234567890123456789012345678901234567890123456789",

[mmenke, 2014/07/23 20:17:42]

For sanity, should use the same number of characters per line here as in the
above body strings.

[jonnyr, 2014/07/25 13:42:00]

Done.

+      data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryInBodyRangeMultipleReads) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C58\r\n"\
+             "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n"\
+             "Expires: Tue, 15 Nov 1994 09:12:31 GMT\r\n"\
+             "Last-Modified: Wed, 14 Dec 2011 15:50:59 GMT\r\n"\
+             "Accept-Ranges: bytes\r\n"\
+             "Content-Length: 3\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 206 Partial Content\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C58\r\n"\
+             "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n"\
+             "Expires: Tue, 15 Nov 1994 09:12:31 GMT\r\n"\
+             "Last-Modified: Wed, 14 Dec 2011 15:50:59 GMT\r\n"\
+             "Content-Length: 2\r\n"\
+             "Content-Range: bytes 1-2/3\r\n\r\n"),

[mmenke, 2014/07/23 20:17:43]

Should definitely check the second set of request headers in this test.

[jonnyr, 2014/07/25 13:42:00]

Agreed.

+    MockRead("HA"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "AHA", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryInBodyRangeSingleRead) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C58\r\n"\
+             "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n"\
+             "Expires: Tue, 15 Nov 1994 09:12:31 GMT\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:59 GMT\r\n"\
+             "Accept-Ranges: bytes\r\n"\
+             "Content-Length: 3\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 206 Partial Content\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C58\r\n"\
+             "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n"\
+             "Expires: Tue, 15 Nov 1994 09:12:31 GMT\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:59 GMT\r\n"\
+             "Accept-Ranges: bytes\r\n"\
+             "Content-Length: 2\r\n"\
+             "Content-Range: bytes 1-2/3\r\n\r\nIA"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "AIA", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryChunked) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Transfer-Encoding: chunked\r\n"\
+             "Cache-Control: max-age=100\r\n\r\n"),
+    MockRead("2\r\n"),
+    MockRead("A"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Transfer-Encoding: chunked\r\n"\
+             "Cache-Control: max-age=100\r\n\r\n"),
+    MockRead("2\r\n"),
+    MockRead("AJ\r\n"),
+    MockRead("2\r\n"),
+    MockRead("AJ\r\n"),
+    MockRead("0\r\n\r\n"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "AJAJ", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryChangedContentNormal) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 2\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 2\r\n\r\nOC"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_RETRY_HASH_MISMATCH, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryChangedContentChunked) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Transfer-Encoding: chunked\r\n"\
+             "Cache-Control: max-age=100\r\n\r\n"),
+    MockRead("1\r\n"),
+    MockRead("A\r\n"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Transfer-Encoding: chunked\r\n"\
+             "Cache-Control: max-age=100\r\n\r\n"),
+    MockRead("1\r\n"),
+    MockRead("B\r\n"),
+    MockRead("1\r\nJ\r\n"),
+    MockRead("0\r\n\r\n"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_RETRY_HASH_MISMATCH, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryTwoTimes) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 3\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 3\r\n\r\nAB"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads3[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 3\r\n\r\nABC"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "ABC", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2), data_reads3, arraysize(data_reads3));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryFourTimes) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 5\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 5\r\n\r\nAB"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads3[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 5\r\n\r\nABC"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads4[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 5\r\n\r\nABCD"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads5[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 5\r\n\r\nABCDE"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "ABCDE", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2), data_reads3, arraysize(data_reads3),
+      data_reads4, arraysize(data_reads4), data_reads5, arraysize(data_reads5));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetrySmallerContent) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 5\r\n\r\nAB"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Len"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads3[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 5\r\n\r\nABCDE"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "ABCDE", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2), data_reads3, arraysize(data_reads3));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryContentLengthChange) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 2\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Cache-Control: max-age=100\r\n"\
+             "Content-Length: 3\r\n\r\nABC"),
+    MockRead(ASYNC, OK),
+  };
+  PartialDataRetryTest(ERR_RETRY_CONTENT_UPDATED, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryEtagOK) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C58\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:59 GMT\r\n"\
+             "Content-Length: 2\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C58\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:59 GMT\r\n"\
+             "Content-Length: 2\r\n\r\nA1"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(OK, "A1", data_reads1, arraysize(data_reads1),
+      data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryLastModifiedChanged) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:50 GMT\r\n"\
+             "Content-Length: 2\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:59 GMT\r\n"\
+             "Content-Length: 2\r\n\r\nA1"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_RETRY_CONTENT_UPDATED, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
+TEST_P(HttpNetworkTransactionTest, PartialDataRetryEtagChange) {
+  MockRead data_reads1[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C58\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:59 GMT\r\n"\
+             "Content-Length: 2\r\n\r\nA"),
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  MockRead data_reads2[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"\
+             "ETag: A023EF02BD589BC472A2D6774EAE3C59\r\n"\
+             "Last-Modified: Wed,14 Dec 2011 15:50:59 GMT\r\n"\
+             "Content-Length: 2\r\n\r\nA1"),
+    MockRead(ASYNC, OK),
+  };
+
+  PartialDataRetryTest(ERR_RETRY_CONTENT_UPDATED, "", data_reads1,
+      arraysize(data_reads1), data_reads2, arraysize(data_reads2));
+}
+
 TEST_P(HttpNetworkTransactionTest, NonKeepAliveConnectionReset) {
   HttpRequestInfo request;
   request.method = "GET";
@@ -12262,6 +12852,11 @@ class FakeStream : public HttpStreamBase,
     return 0;
   }
 
+  virtual int64 GetReceivedBodyLength() const OVERRIDE {
+    ADD_FAILURE();
+    return 0;
+  }
+
   virtual bool GetLoadTimingInfo(
       LoadTimingInfo* load_timing_info) const OVERRIDE {
     ADD_FAILURE();
@@ -12290,6 +12885,15 @@ class FakeStream : public HttpStreamBase,
     priority_ = priority;
   }
 
+  virtual void SetRestartInfo(int64 read_offset, const void* hash,
+    size_t hash_length) {
+    ADD_FAILURE();
+  }
+
+  virtual void GetHash(void* output, size_t len) {
+    ADD_FAILURE();
+  }
+
  private:
   RequestPriority priority_;