Make the download's response headers available in the DownloadItem

content/browser/download/download_item_impl_unittest.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.
 
 #include "content/browser/download/download_item_impl.h"
 
 #include <stdint.h>
 
 #include <deque>
 #include <iterator>
@@ skipping 18 matching lines @@
 #include "content/browser/download/mock_download_file.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/common/content_features.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/web_contents_tester.h"
 #include "crypto/secure_hash.h"
+#include "net/http/http_response_headers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NiceMock;
 using ::testing::Property;
 using ::testing::Return;
 using ::testing::ReturnRefOfCopy;
@@ skipping 221 matching lines @@
 
   DownloadItemImpl* CreateDownloadItemWithCreateInfo(
       std::unique_ptr<DownloadCreateInfo> info) {
     DownloadItemImpl* download =
         new DownloadItemImpl(&delegate_, next_download_id_++, *(info.get()),
                              net::NetLogWithSource());
     allocated_downloads_[download] = base::WrapUnique(download);
     return download;
   }
 
+  // Creates a new net::HttpResponseHeaders object for the |response_code|.
+  scoped_refptr<const net::HttpResponseHeaders> CreateResponseHeaders(
+      int response_code) {
+    return make_scoped_refptr(new net::HttpResponseHeaders(
+        "HTTP/1.1 " + std::to_string(response_code)));
+  }
+
   // This class keeps ownership of the created download item; it will
   // be torn down at the end of the test unless DestroyDownloadItem is
   // called.
   DownloadItemImpl* CreateDownloadItem() {
     create_info_->download_id = ++next_download_id_;
     DownloadItemImpl* download =
         new DownloadItemImpl(&delegate_, create_info_->download_id,
                              *create_info_, net::NetLogWithSource());
     allocated_downloads_[download] = base::WrapUnique(download);
     return download;
@@ skipping 519 matching lines @@
 
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(1, observer.interrupt_count());
   CleanupItem(item, nullptr, DownloadItem::INTERRUPTED);
 }
 
 // If the download attempts to resume and the resumption request fails, the
 // subsequent Start() call shouldn't update the origin state (URL redirect
 // chains, Content-Disposition, download URL, etc..)
 TEST_F(DownloadItemTest, FailedResumptionDoesntUpdateOriginState) {
+  constexpr int kFirstResponseCode = 200;
   const char kContentDisposition[] = "attachment; filename=foo";
   const char kFirstETag[] = "ABC";
   const char kFirstLastModified[] = "Yesterday";
   const char kFirstURL[] = "http://www.example.com/download";
   const char kMimeType[] = "text/css";
+  create_info()->response_headers = CreateResponseHeaders(kFirstResponseCode);
   create_info()->content_disposition = kContentDisposition;
   create_info()->etag = kFirstETag;
   create_info()->last_modified = kFirstLastModified;
   create_info()->url_chain.push_back(GURL(kFirstURL));
   create_info()->mime_type = kMimeType;
 
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
+  ASSERT_TRUE(item->GetResponseHeaders());
+  EXPECT_EQ(kFirstResponseCode, item->GetResponseHeaders()->response_code());
   EXPECT_EQ(kContentDisposition, item->GetContentDisposition());
   EXPECT_EQ(kFirstETag, item->GetETag());
   EXPECT_EQ(kFirstLastModified, item->GetLastModifiedTime());
   EXPECT_EQ(kFirstURL, item->GetURL().spec());
   EXPECT_EQ(kMimeType, item->GetMimeType());
 
   EXPECT_CALL(*mock_delegate(),
               MockResumeInterruptedDownload(
                   AllOf(Property(&DownloadUrlParameters::file_path,
                                  Property(&base::FilePath::value,
                                           kDummyIntermediatePath)),
                         Property(&DownloadUrlParameters::offset, 1)),
                   _));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 1,
       std::unique_ptr<crypto::SecureHash>());
   RunAllPendingInMessageLoops();
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
 
   // Now change the create info. The changes should not cause the DownloadItem
   // to be updated.
+  constexpr int kSecondResponseCode = 418;
   const char kSecondContentDisposition[] = "attachment; filename=bar";
   const char kSecondETag[] = "123";
   const char kSecondLastModified[] = "Today";
   const char kSecondURL[] = "http://example.com/another-download";
   const char kSecondMimeType[] = "text/html";
+  create_info()->response_headers = CreateResponseHeaders(kSecondResponseCode);
   create_info()->content_disposition = kSecondContentDisposition;
   create_info()->etag = kSecondETag;
   create_info()->last_modified = kSecondLastModified;
   create_info()->url_chain.clear();
   create_info()->url_chain.push_back(GURL(kSecondURL));
   create_info()->mime_type = kSecondMimeType;
   create_info()->result = DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED;
   create_info()->save_info->file_path = base::FilePath(kDummyIntermediatePath);
   create_info()->save_info->offset = 1;
 
   // Calling Start() with a response indicating failure shouldn't cause a target
   // update, nor should it result in discarding the intermediate file.
   DownloadTargetCallback target_callback;
   download_file = CallDownloadItemStart(item, &target_callback);
   ASSERT_FALSE(target_callback.is_null());
   target_callback.Run(base::FilePath(kDummyTargetPath),
                       DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                       DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                       base::FilePath(kDummyIntermediatePath),
                       DOWNLOAD_INTERRUPT_REASON_NONE);
   RunAllPendingInMessageLoops();
 
+  ASSERT_TRUE(item->GetResponseHeaders());
+  EXPECT_EQ(kFirstResponseCode, item->GetResponseHeaders()->response_code());
   EXPECT_EQ(kContentDisposition, item->GetContentDisposition());
   EXPECT_EQ(kFirstETag, item->GetETag());
   EXPECT_EQ(kFirstLastModified, item->GetLastModifiedTime());
   EXPECT_EQ(kFirstURL, item->GetURL().spec());
   EXPECT_EQ(kMimeType, item->GetMimeType());
   EXPECT_EQ(DownloadItem::INTERRUPTED, item->GetState());
   EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED, item->GetLastReason());
   EXPECT_EQ(kDummyIntermediatePath, item->GetFullPath().value());
   EXPECT_EQ(1, item->GetReceivedBytes());
 }
 
 // If the download resumption request succeeds, the origin state should be
 // updated.
 TEST_F(DownloadItemTest, SucceededResumptionUpdatesOriginState) {
+  constexpr int kFirstResponseCode = 200;
   const char kContentDisposition[] = "attachment; filename=foo";
   const char kFirstETag[] = "ABC";
   const char kFirstLastModified[] = "Yesterday";
   const char kFirstURL[] = "http://www.example.com/download";
   const char kMimeType[] = "text/css";
+  create_info()->response_headers = CreateResponseHeaders(kFirstResponseCode);
   create_info()->content_disposition = kContentDisposition;
   create_info()->etag = kFirstETag;
   create_info()->last_modified = kFirstLastModified;
   create_info()->url_chain.push_back(GURL(kFirstURL));
   create_info()->mime_type = kMimeType;
 
   DownloadItemImpl* item = CreateDownloadItem();
   MockDownloadFile* download_file =
       DoIntermediateRename(item, DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS);
   EXPECT_CALL(*mock_delegate(), MockResumeInterruptedDownload(_, _));
   EXPECT_CALL(*download_file, Detach());
   item->DestinationObserverAsWeakPtr()->DestinationError(
       DOWNLOAD_INTERRUPT_REASON_FILE_TRANSIENT_ERROR, 0,
       std::unique_ptr<crypto::SecureHash>());
   RunAllPendingInMessageLoops();
   EXPECT_EQ(DownloadItem::IN_PROGRESS, item->GetState());
 
   // Now change the create info. The changes should not cause the DownloadItem
   // to be updated.
+  constexpr int kSecondResponseCode = 201;
   const char kSecondContentDisposition[] = "attachment; filename=bar";
   const char kSecondETag[] = "123";
   const char kSecondLastModified[] = "Today";
   const char kSecondURL[] = "http://example.com/another-download";
   const char kSecondMimeType[] = "text/html";
+  create_info()->response_headers = CreateResponseHeaders(kSecondResponseCode);
   create_info()->content_disposition = kSecondContentDisposition;
   create_info()->etag = kSecondETag;
   create_info()->last_modified = kSecondLastModified;
   create_info()->url_chain.clear();
   create_info()->url_chain.push_back(GURL(kSecondURL));
   create_info()->mime_type = kSecondMimeType;
 
   DownloadTargetCallback target_callback;
   download_file = CallDownloadItemStart(item, &target_callback);
 
+  ASSERT_TRUE(item->GetResponseHeaders());
+  EXPECT_EQ(kSecondResponseCode, item->GetResponseHeaders()->response_code());
   EXPECT_EQ(kSecondContentDisposition, item->GetContentDisposition());
   EXPECT_EQ(kSecondETag, item->GetETag());
   EXPECT_EQ(kSecondLastModified, item->GetLastModifiedTime());
   EXPECT_EQ(kSecondURL, item->GetURL().spec());
   EXPECT_EQ(kSecondMimeType, item->GetMimeType());
 
   CleanupItem(item, download_file, DownloadItem::IN_PROGRESS);
 }
 
 // Ensure when strong validators changed on resumption, the received
@@ skipping 1326 matching lines @@
 
   item_->Cancel(true);
   RunAllPendingInMessageLoops();
 }
 
 TEST(MockDownloadItem, Compiles) {
   MockDownloadItem mock_item;
 }
 
 }  // namespace content