[Merge M51][Downloads] Set the Referrer header for resumed requests.

content/browser/download/download_browsertest.cc

 // Copyright (c) 2012 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.
 
 // This file contains download browser tests that are known to be runnable
 // in a pure content context.  Over time tests should be migrated here.
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
@@ skipping 1033 matching lines @@
   // Characterization risk: The next portion of the test examines the requests
   // that were sent out while downloading our resource. These requests
   // correspond to the requests that were generated by the browser and the
   // downloads system and may change as implementation details change.
   TestDownloadRequestHandler::CompletedRequests requests;
   request_handler.GetCompletedRequestInfo(&requests);
 
   ASSERT_EQ(2u, requests.size());
 
   // The first request only transferrs bytes up until the interruption point.
-  EXPECT_EQ(interruption.offset, requests[0].transferred_byte_count);
+  EXPECT_EQ(interruption.offset, requests[0]->transferred_byte_count);
 
   // The next request should only have transferred the remainder of the
   // resource.
   EXPECT_EQ(parameters.size - interruption.offset,
-            requests[1].transferred_byte_count);
+            requests[1]->transferred_byte_count);
 
   std::string value;
-  ASSERT_TRUE(requests[1].request_headers.GetHeader(
+  ASSERT_TRUE(requests[1]->request_headers.GetHeader(
       net::HttpRequestHeaders::kIfRange, &value));
   EXPECT_EQ(parameters.etag, value);
 
-  ASSERT_TRUE(requests[1].request_headers.GetHeader(
+  ASSERT_TRUE(requests[1]->request_headers.GetHeader(
       net::HttpRequestHeaders::kRange, &value));
   EXPECT_EQ(base::StringPrintf("bytes=%" PRId64 "-", interruption.offset),
             value);
 }
 
 // Resumption should only attempt to contact the final URL if the download has a
 // URL chain.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RedirectBeforeResume) {
   TestDownloadRequestHandler request_handler_1(
       GURL("http://example.com/first-url"));
@@ skipping 94 matching lines @@
   // that were sent out while downloading our resource. These requests
   // correspond to the requests that were generated by the browser and the
   // downloads system and may change as implementation details change.
   TestDownloadRequestHandler::CompletedRequests requests;
   request_handler.GetCompletedRequestInfo(&requests);
 
   ASSERT_EQ(3u, requests.size());
 
   // None of the request should have transferred the entire resource. The
   // redirect response shows up as a response with 0 bytes transferred.
-  EXPECT_GT(parameters.size, requests[0].transferred_byte_count);
-  EXPECT_EQ(0, requests[1].transferred_byte_count);
-  EXPECT_GT(parameters.size, requests[2].transferred_byte_count);
+  EXPECT_GT(parameters.size, requests[0]->transferred_byte_count);
+  EXPECT_EQ(0, requests[1]->transferred_byte_count);
+  EXPECT_GT(parameters.size, requests[2]->transferred_byte_count);
 }
 
 // If the server response for the resumption request specifies a bad range (i.e.
 // not the range that was requested or an invalid or missing Content-Range
 // header), then the download should be marked as interrupted again without
 // discarding the partial state.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, BadRangeHeader) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
@@ skipping 49 matching lines @@
   // Characterization risk: The next portion of the test examines the requests
   // that were sent out while downloading our resource. These requests
   // correspond to the requests that were generated by the browser and the
   // downloads system and may change as implementation details change.
   TestDownloadRequestHandler::CompletedRequests requests;
   request_handler.GetCompletedRequestInfo(&requests);
 
   ASSERT_EQ(5u, requests.size());
 
   // None of the request should have transferred the entire resource.
-  EXPECT_GT(parameters.size, requests[0].transferred_byte_count);
-  EXPECT_EQ(0, requests[1].transferred_byte_count);
-  EXPECT_EQ(0, requests[2].transferred_byte_count);
-  EXPECT_EQ(0, requests[3].transferred_byte_count);
-  EXPECT_GT(parameters.size, requests[4].transferred_byte_count);
+  EXPECT_GT(parameters.size, requests[0]->transferred_byte_count);
+  EXPECT_EQ(0, requests[1]->transferred_byte_count);
+  EXPECT_EQ(0, requests[2]->transferred_byte_count);
+  EXPECT_EQ(0, requests[3]->transferred_byte_count);
+  EXPECT_GT(parameters.size, requests[4]->transferred_byte_count);
 }
 
 // A partial resumption results in an HTTP 200 response. I.e. the server ignored
 // the range request and sent the entire resource instead. For If-Range requests
 // (as opposed to If-Match), the behavior for a precondition failure is also to
 // respond with a 200. So this test case covers both validation failure and
 // ignoring the range request.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RestartIfNotPartialResponse) {
   const int kOriginalPatternGeneratorSeed = 1;
   const int kNewPatternGeneratorSeed = 2;
@@ skipping 32 matching lines @@
   // response without restarting. On the network, we should deterministically
   // see two requests:
   // * The original request which transfers upto our interruption point.
   // * The resumption attempt, which receives the entire entity.
   TestDownloadRequestHandler::CompletedRequests requests;
   request_handler.GetCompletedRequestInfo(&requests);
 
   ASSERT_EQ(2u, requests.size());
 
   // The first request only transfers data up to the interruption point.
-  EXPECT_EQ(interruption.offset, requests[0].transferred_byte_count);
+  EXPECT_EQ(interruption.offset, requests[0]->transferred_byte_count);
 
   // The second request transfers the entire response.
-  EXPECT_EQ(parameters.size, requests[1].transferred_byte_count);
+  EXPECT_EQ(parameters.size, requests[1]->transferred_byte_count);
 
   std::string value;
-  ASSERT_TRUE(requests[1].request_headers.GetHeader(
+  ASSERT_TRUE(requests[1]->request_headers.GetHeader(
       net::HttpRequestHeaders::kIfRange, &value));
   EXPECT_EQ(parameters.etag, value);
 
-  ASSERT_TRUE(requests[1].request_headers.GetHeader(
+  ASSERT_TRUE(requests[1]->request_headers.GetHeader(
       net::HttpRequestHeaders::kRange, &value));
   EXPECT_EQ(base::StringPrintf("bytes=%" PRId64 "-", interruption.offset),
             value);
 }
 
 // Confirm we restart if we don't have a verifier.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RestartIfNoETag) {
   const int kOriginalPatternGeneratorSeed = 1;
   const int kNewPatternGeneratorSeed = 2;
 
@@ skipping 21 matching lines @@
   ASSERT_NO_FATAL_FAILURE(
       ReadAndVerifyFileContents(kNewPatternGeneratorSeed, parameters.size,
                                 download->GetTargetFilePath()));
 
   TestDownloadRequestHandler::CompletedRequests requests;
   request_handler.GetCompletedRequestInfo(&requests);
 
   // Neither If-Range nor Range headers should be present in the second request.
   ASSERT_EQ(2u, requests.size());
   std::string value;
-  EXPECT_FALSE(requests[1].request_headers.GetHeader(
+  EXPECT_FALSE(requests[1]->request_headers.GetHeader(
       net::HttpRequestHeaders::kIfRange, &value));
-  EXPECT_FALSE(requests[1].request_headers.GetHeader(
+  EXPECT_FALSE(requests[1]->request_headers.GetHeader(
       net::HttpRequestHeaders::kRange, &value));
 }
 
 // Partial file goes missing before the download is resumed. The download should
 // restart.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, RestartIfNoPartialFile) {
   TestDownloadRequestHandler::Parameters parameters =
       TestDownloadRequestHandler::Parameters::WithSingleInterruption();
 
   TestDownloadRequestHandler request_handler;
@@ skipping 483 matching lines @@
   //
   // The second request reads the entire entity.
   //
   // N.b. we can't make any assumptions about how many bytes are transferred by
   // the first request since response data will be bufferred until DownloadFile
   // is done initializing.
   //
   // TODO(asanka): Ideally we'll check that the intermediate file matches
   // expectations prior to issuing the first resumption request.
   ASSERT_EQ(2u, completed_requests.size());
-  EXPECT_EQ(parameters.size, completed_requests[1].transferred_byte_count);
+  EXPECT_EQ(parameters.size, completed_requests[1]->transferred_byte_count);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeRestoredDownload_NoHash) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
   std::vector<GURL> url_chain;
@@ skipping 39 matching lines @@
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There's only one network request issued, and that is for the remainder of
   // the file.
   ASSERT_EQ(1u, completed_requests.size());
   EXPECT_EQ(parameters.size - kIntermediateSize,
-            completed_requests[0].transferred_byte_count);
+            completed_requests[0]->transferred_byte_count);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        ResumeRestoredDownload_EtagMismatch) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
@@ skipping 40 matching lines @@
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There's only one network request issued. The If-Range header allows the
   // server to respond with the entire entity in one go. The existing contents
   // of the file should be discarded, and overwritten by the new contents.
   ASSERT_EQ(1u, completed_requests.size());
-  EXPECT_EQ(parameters.size, completed_requests[0].transferred_byte_count);
+  EXPECT_EQ(parameters.size, completed_requests[0]->transferred_byte_count);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadContentTest,
                        ResumeRestoredDownload_CorrectHash) {
   TestDownloadRequestHandler request_handler;
   TestDownloadRequestHandler::Parameters parameters;
   request_handler.StartServing(parameters);
 
   base::FilePath intermediate_file_path =
       GetDownloadDirectory().AppendASCII("intermediate");
@@ skipping 45 matching lines @@
                             parameters.size,
                             download->GetTargetFilePath());
 
   TestDownloadRequestHandler::CompletedRequests completed_requests;
   request_handler.GetCompletedRequestInfo(&completed_requests);
 
   // There's only one network request issued, and that is for the remainder of
   // the file.
   ASSERT_EQ(1u, completed_requests.size());
   EXPECT_EQ(parameters.size - kIntermediateSize,
-            completed_requests[0].transferred_byte_count);
+            completed_requests[0]->transferred_byte_count);
 
   // SHA-256 hash of the entire 102400 bytes in the target file.
   static const uint8_t kFullHash[] = {
       0xa7, 0x44, 0x49, 0x86, 0x24, 0xc6, 0x84, 0x6c, 0x89, 0xdf, 0xd8,
       0xec, 0xa0, 0xe0, 0x61, 0x12, 0xdc, 0x80, 0x13, 0xf2, 0x83, 0x49,
       0xa9, 0x14, 0x52, 0x32, 0xf0, 0x95, 0x20, 0xca, 0x5b, 0x30};
   EXPECT_EQ(std::string(std::begin(kFullHash), std::end(kFullHash)),
             download->GetHash());
 }
 
@@ skipping 64 matching lines @@
   //
   // The second request reads the entire entity.
   //
   // N.b. we can't make any assumptions about how many bytes are transferred by
   // the first request since response data will be bufferred until DownloadFile
   // is done initializing.
   //
   // TODO(asanka): Ideally we'll check that the intermediate file matches
   // expectations prior to issuing the first resumption request.
   ASSERT_EQ(2u, completed_requests.size());
-  EXPECT_EQ(parameters.size, completed_requests[1].transferred_byte_count);
+  EXPECT_EQ(parameters.size, completed_requests[1]->transferred_byte_count);
 
   // SHA-256 hash of the entire 102400 bytes in the target file.
   static const uint8_t kFullHash[] = {
       0xa7, 0x44, 0x49, 0x86, 0x24, 0xc6, 0x84, 0x6c, 0x89, 0xdf, 0xd8,
       0xec, 0xa0, 0xe0, 0x61, 0x12, 0xdc, 0x80, 0x13, 0xf2, 0x83, 0x49,
       0xa9, 0x14, 0x52, 0x32, 0xf0, 0x95, 0x20, 0xca, 0x5b, 0x30};
   EXPECT_EQ(std::string(std::begin(kFullHash), std::end(kFullHash)),
             download->GetHash());
 }
 
@@ skipping 61 matching lines @@
   //
   // The second request reads the entire entity.
   //
   // N.b. we can't make any assumptions about how many bytes are transferred by
   // the first request since response data will be bufferred until DownloadFile
   // is done initializing.
   //
   // TODO(asanka): Ideally we'll check that the intermediate file matches
   // expectations prior to issuing the first resumption request.
   ASSERT_EQ(2u, completed_requests.size());
-  EXPECT_EQ(parameters.size, completed_requests[1].transferred_byte_count);
+  EXPECT_EQ(parameters.size, completed_requests[1]->transferred_byte_count);
+}
+
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, ResumeRestoredDownload_LongFile) {
+  // These numbers are sufficiently large that the intermediate file won't be
+  // read in a single Read().
+  const int kFileSize = 1024 * 1024;
+  const int kIntermediateSize = kFileSize / 2 + 111;
+
+  TestDownloadRequestHandler request_handler;
+  TestDownloadRequestHandler::Parameters parameters;
+  parameters.size = kFileSize;
+  request_handler.StartServing(parameters);
+
+  base::FilePath intermediate_file_path =
+      GetDownloadDirectory().AppendASCII("intermediate");
+  std::vector<GURL> url_chain;
+
+  // Size of file is slightly longer than the size known to DownloadItem.
+  std::vector<char> buffer(kIntermediateSize + 100);
+  request_handler.GetPatternBytes(
+      parameters.pattern_generator_seed, 0, buffer.size(), buffer.data());
+  ASSERT_EQ(
+      kIntermediateSize + 100,
+      base::WriteFile(intermediate_file_path, buffer.data(), buffer.size()));
+  url_chain.push_back(request_handler.url());
+
+  DownloadItem* download = DownloadManagerForShell(shell())->CreateDownloadItem(
+      "F7FB1F59-7DE1-4845-AFDB-8A688F70F583",
+      1,
+      intermediate_file_path,
+      base::FilePath(),
+      url_chain,
+      GURL(),
+      GURL(),
+      GURL(),
+      "application/octet-stream",
+      "application/octet-stream",
+      base::Time::Now(),
+      base::Time(),
+      parameters.etag,
+      std::string(),
+      kIntermediateSize,
+      parameters.size,
+      std::string(),
+      DownloadItem::INTERRUPTED,
+      DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
+      DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED,
+      false);
+
+  download->Resume();
+  WaitForCompletion(download);
+
+  EXPECT_FALSE(base::PathExists(intermediate_file_path));
+  ReadAndVerifyFileContents(parameters.pattern_generator_seed,
+                            parameters.size,
+                            download->GetTargetFilePath());
+
+  TestDownloadRequestHandler::CompletedRequests completed_requests;
+  request_handler.GetCompletedRequestInfo(&completed_requests);
+
+  // There should be only one request. The intermediate file should be truncated
+  // to the expected size, and the request should be issued for the remainder.
+  //
+  // TODO(asanka): Ideally we'll check that the intermediate file matches
+  // expectations prior to issuing the first resumption request.
+  ASSERT_EQ(1u, completed_requests.size());
+  EXPECT_EQ(parameters.size - kIntermediateSize,
+            completed_requests[0]->transferred_byte_count);
+}
+
+// Test that the referrer header is set correctly for a download that's resumed
+// partially.
+IN_PROC_BROWSER_TEST_F(DownloadContentTest, ReferrerForPartialResumption) {
+  TestDownloadRequestHandler request_handler;
+  TestDownloadRequestHandler::Parameters parameters =
+      TestDownloadRequestHandler::Parameters::WithSingleInterruption();
+  request_handler.StartServing(parameters);
+
+  ASSERT_TRUE(embedded_test_server()->Start());
+  GURL document_url = embedded_test_server()->GetURL(
+      std::string("/download/download-link.html?dl=")
+          .append(request_handler.url().spec()));
+
+  DownloadItem* download = StartDownloadAndReturnItem(shell(), document_url);
+  WaitForInterrupt(download);
+
+  download->Resume();
+  WaitForCompletion(download);
+
+  ASSERT_EQ(parameters.size, download->GetReceivedBytes());
+  ASSERT_EQ(parameters.size, download->GetTotalBytes());
+  ASSERT_NO_FATAL_FAILURE(ReadAndVerifyFileContents(
+      parameters.pattern_generator_seed, parameters.size,
+      download->GetTargetFilePath()));
+
+  TestDownloadRequestHandler::CompletedRequests requests;
+  request_handler.GetCompletedRequestInfo(&requests);
+
+  ASSERT_GE(2u, requests.size());
+  EXPECT_EQ(document_url.spec(), requests.back()->referrer);
 }
 
 // Check that the cookie policy is correctly updated when downloading a file
 // that redirects cross origin.
 IN_PROC_BROWSER_TEST_F(DownloadContentTest, CookiePolicy) {
   net::EmbeddedTestServer origin_one;
   net::EmbeddedTestServer origin_two;
   ASSERT_TRUE(origin_one.Start());
   ASSERT_TRUE(origin_two.Start());
 
@@ skipping 233 matching lines @@
 
   std::vector<DownloadItem*> downloads;
   DownloadManagerForShell(shell())->GetAllDownloads(&downloads);
   ASSERT_EQ(1u, downloads.size());
 
   EXPECT_EQ(FILE_PATH_LITERAL("Jumboshrimp.txt"),
             downloads[0]->GetTargetFilePath().BaseName().value());
 }
 
 }  // namespace content