HTTP retry support.

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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 <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 264 matching lines @@
         "\r\n\r\n";
   }
 
   // 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 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
   // other argument should be NULL.
   void PreconnectErrorResendRequestTest(const MockWrite* write_failure,
                                         const MockRead* read_failure,
                                         bool use_spdy);
 
   SimpleGetHelperResult SimpleGetHelperForData(StaticSocketDataProvider* data[],
                                                size_t data_count) {
@@ skipping 1035 matching lines @@
     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(kExpectedResponseData[i], response_data);
   }
 }
 
+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,
     bool use_spdy) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.foo.com/");
   request.load_flags = 0;
 
   CapturingNetLog net_log;
@@ skipping 181 matching lines @@
 TEST_P(HttpNetworkTransactionTest, SpdyPreconnectErrorEOF) {
   MockRead read_failure(SYNCHRONOUS, OK);  // EOF
   PreconnectErrorResendRequestTest(NULL, &read_failure, true);
 }
 
 TEST_P(HttpNetworkTransactionTest, SpdyPreconnectErrorAsyncEOF) {
   MockRead read_failure(ASYNC, OK);  // EOF
   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";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
 
@@ skipping 10704 matching lines @@
   virtual bool IsConnectionReusable() const OVERRIDE {
     ADD_FAILURE();
     return false;
   }
 
   virtual int64 GetTotalReceivedBytes() const OVERRIDE {
     ADD_FAILURE();
     return 0;
   }
 
+  virtual int64 GetReceivedBodyLength() const OVERRIDE {
+    ADD_FAILURE();
+    return 0;
+  }
+
   virtual bool GetLoadTimingInfo(
       LoadTimingInfo* load_timing_info) const OVERRIDE {
     ADD_FAILURE();
     return false;
   }
 
   virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     ADD_FAILURE();
   }
 
   virtual void GetSSLCertRequestInfo(
       SSLCertRequestInfo* cert_request_info) OVERRIDE {
     ADD_FAILURE();
   }
 
   virtual bool IsSpdyHttpStream() const OVERRIDE {
     ADD_FAILURE();
     return false;
   }
 
   virtual void Drain(HttpNetworkSession* session) OVERRIDE {
     ADD_FAILURE();
   }
 
   virtual void SetPriority(RequestPriority priority) OVERRIDE {
     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_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeStream);
 };
 
 // Fake HttpStreamRequest that simply records calls to SetPriority()
 // and vends FakeStreams with its current priority.
 class FakeStreamRequest : public HttpStreamRequest,
                           public base::SupportsWeakPtr<FakeStreamRequest> {
@@ skipping 900 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 }  // namespace net