Use DownloadItem directly in DownloadProtectionService.

chrome/browser/safe_browsing/download_protection_service_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 "chrome/browser/safe_browsing/download_protection_service.h"
 
 #include <map>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/signature_util.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "chrome/common/zip.h"
-#include "content/public/browser/download_item.h"
+#include "content/public/test/mock_download_item.h"
 #include "content/public/test/test_browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/x509_certificate.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::ContainerEq;
 using ::testing::DoAll;
 using ::testing::ElementsAre;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
+using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::_;
 using content::BrowserThread;
 namespace safe_browsing {
 namespace {
 // A SafeBrowsingDatabaseManager implementation that returns a fixed result for
 // a given URL.
 class MockSafeBrowsingDatabaseManager : public SafeBrowsingDatabaseManager {
  public:
@@ skipping 250 matching lines @@
   DownloadProtectionService* download_service_;
   MessageLoop msg_loop_;
   DownloadProtectionService::DownloadCheckResult result_;
   bool has_result_;
   scoped_ptr<content::TestBrowserThread> io_thread_;
   scoped_ptr<content::TestBrowserThread> ui_thread_;
   base::FilePath testdata_path_;
 };
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadInvalidUrl) {
-  DownloadProtectionService::DownloadInfo info;
+  base::FilePath a_tmp(FILE_PATH_LITERAL("a.tmp"));
+  base::FilePath a_exe(FILE_PATH_LITERAL("a.exe"));
+  std::vector<GURL> url_chain;
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_));
+  EXPECT_CALL(item, RemoveObserver(_));
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_exe));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+  Mock::VerifyAndClearExpectations(&item);
 
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.exe"));
-  info.download_url_chain.push_back(GURL("file://www.google.com/"));
+  url_chain.push_back(GURL("file://www.google.com/"));
+  EXPECT_CALL(item, AddObserver(_));
+  EXPECT_CALL(item, RemoveObserver(_));
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_exe));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadWhitelistedUrl) {
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.exe"));
-  info.download_url_chain.push_back(GURL("http://www.evil.com/bla.exe"));
-  info.download_url_chain.push_back(GURL("http://www.google.com/a.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
+  base::FilePath a_tmp(FILE_PATH_LITERAL("a.tmp"));
+  base::FilePath a_exe(FILE_PATH_LITERAL("a.exe"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/bla.exe"));
+  url_chain.push_back(GURL("http://www.google.com/a.exe"));
+  GURL referrer("http://www.google.com/");
 
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(2);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(2);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_exe));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(GURL("http://www.google.com/a.exe")))
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _)).Times(2);
+  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(2);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 
   // Check that the referrer is matched against the whitelist.
-  info.download_url_chain.pop_back();
-  info.referrer_url = GURL("http://www.google.com/a.exe");
+  url_chain.pop_back();
+  referrer = GURL("http://www.google.com/a.exe");
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadFetchFailed) {
   net::FakeURLFetcherFactory factory(NULL);
   // HTTP request will fail.
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(), "", false);
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.exe"));
-  info.download_url_chain.push_back(GURL("http://www.evil.com/a.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
+  base::FilePath a_tmp(FILE_PATH_LITERAL("a.tmp"));
+  base::FilePath a_exe(FILE_PATH_LITERAL("a.exe"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/a.exe"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_));
+  EXPECT_CALL(item, RemoveObserver(_));
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_exe));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _));
+  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _));
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadSuccess) {
   ClientDownloadResponse response;
   response.set_verdict(ClientDownloadResponse::SAFE);
   net::FakeURLFetcherFactory factory(NULL);
   // Empty response means SAFE.
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.exe"));
-  info.download_url_chain.push_back(GURL("http://www.evil.com/a.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
+  base::FilePath a_tmp(FILE_PATH_LITERAL("a.tmp"));
+  base::FilePath a_exe(FILE_PATH_LITERAL("a.exe"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/a.exe"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(5);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(5);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_exe));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _)).Times(5);
+  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(5);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 
   // Invalid response should be safe too.
   response.Clear();
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializePartialAsString(),
       true);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 
   // If the response is dangerous the result should also be marked as dangerous.
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
 
   // If the response is uncommon the result should also be marked as uncommon.
   response.set_verdict(ClientDownloadResponse::UNCOMMON);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNCOMMON));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
 
   // If the response is dangerous_host the result should also be marked as
   // dangerous_host.
   response.set_verdict(ClientDownloadResponse::DANGEROUS_HOST);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS_HOST));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadHTTPS) {
   ClientDownloadResponse response;
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   net::FakeURLFetcherFactory factory(NULL);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.exe"));
-  info.download_url_chain.push_back(GURL("https://www.evil.com/a.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
+  base::FilePath a_tmp(FILE_PATH_LITERAL("a.tmp"));
+  base::FilePath a_exe(FILE_PATH_LITERAL("a.exe"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/a.exe"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(1);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(1);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_exe));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _)).Times(1);
+  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(1);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadZip) {
   ClientDownloadResponse response;
   response.set_verdict(ClientDownloadResponse::SAFE);
   net::FakeURLFetcherFactory factory(NULL);
   // Empty response means SAFE.
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   base::ScopedTempDir download_dir;
   ASSERT_TRUE(download_dir.CreateUniqueTempDir());
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = download_dir.path().Append(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.zip"));
-  info.download_url_chain.push_back(GURL("http://www.evil.com/a.zip"));
-  info.referrer_url = GURL("http://www.google.com/");
+  base::FilePath a_tmp(download_dir.path().Append(FILE_PATH_LITERAL("a.tmp")));
+  base::FilePath a_zip(FILE_PATH_LITERAL("a.zip"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/a.zip"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(3);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(3);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_zip));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   // Write out a zip archive to the temporary file.  In this case, it
   // only contains a text file.
   base::ScopedTempDir zip_source_dir;
   ASSERT_TRUE(zip_source_dir.CreateUniqueTempDir());
   std::string file_contents = "dummy file";
   ASSERT_EQ(static_cast<int>(file_contents.size()), file_util::WriteFile(
       zip_source_dir.path().Append(FILE_PATH_LITERAL("file.txt")),
       file_contents.data(), file_contents.size()));
-  ASSERT_TRUE(zip::Zip(zip_source_dir.path(), info.local_file, false));
+  ASSERT_TRUE(zip::Zip(zip_source_dir.path(), a_tmp, false));
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   Mock::VerifyAndClearExpectations(sb_service_);
   Mock::VerifyAndClearExpectations(signature_util_);
 
   // Now check with an executable in the zip file as well.
   ASSERT_EQ(static_cast<int>(file_contents.size()), file_util::WriteFile(
       zip_source_dir.path().Append(FILE_PATH_LITERAL("file.exe")),
       file_contents.data(), file_contents.size()));
-  ASSERT_TRUE(zip::Zip(zip_source_dir.path(), info.local_file, false));
+  ASSERT_TRUE(zip::Zip(zip_source_dir.path(), a_tmp, false));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   Mock::VerifyAndClearExpectations(signature_util_);
 
   // If the response is dangerous the result should also be marked as
   // dangerous.
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
 #if defined(OS_WIN)
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 #else
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 #endif
   Mock::VerifyAndClearExpectations(signature_util_);
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadCorruptZip) {
   base::ScopedTempDir download_dir;
   ASSERT_TRUE(download_dir.CreateUniqueTempDir());
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = download_dir.path().Append(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.zip"));
-  info.download_url_chain.push_back(GURL("http://www.evil.com/a.zip"));
-  info.referrer_url = GURL("http://www.google.com/");
+  base::FilePath a_tmp(download_dir.path().Append(FILE_PATH_LITERAL("a.tmp")));
+  base::FilePath a_zip(FILE_PATH_LITERAL("a.zip"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/a.zip"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(1);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(1);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_zip));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   std::string file_contents = "corrupt zip file";
   ASSERT_EQ(static_cast<int>(file_contents.size()), file_util::WriteFile(
-      download_dir.path().Append(FILE_PATH_LITERAL("a.tmp")),
-      file_contents.data(), file_contents.size()));
+      a_tmp, file_contents.data(), file_contents.size()));
 
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   Mock::VerifyAndClearExpectations(sb_service_);
   Mock::VerifyAndClearExpectations(signature_util_);
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientCrxDownloadSuccess) {
   ClientDownloadResponse response;
   // Even if the server verdict is dangerous we should return SAFE because
   // DownloadProtectionService::IsSupportedDownload() will return false
   // for crx downloads.
   response.set_verdict(ClientDownloadResponse::DANGEROUS);
   net::FakeURLFetcherFactory factory(NULL);
   // Empty response means SAFE.
   factory.SetFakeResponse(
       DownloadProtectionService::GetDownloadRequestUrl(),
       response.SerializeAsString(),
       true);
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.crx"));
-  info.download_url_chain.push_back(GURL("http://www.evil.com/a.crx"));
-  info.referrer_url = GURL("http://www.google.com/");
+  base::FilePath a_tmp(FILE_PATH_LITERAL("a.tmp"));
+  base::FilePath a_crx(FILE_PATH_LITERAL("a.crx"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/a.crx"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(1);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(1);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(a_tmp));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(a_crx));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _)).Times(1);
+  EXPECT_CALL(*signature_util_, CheckSignature(a_tmp, _)).Times(1);
 
-  EXPECT_FALSE(download_service_->IsSupportedDownload(info));
+  EXPECT_FALSE(download_service_->IsSupportedDownload(item, a_crx));
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadValidateRequest) {
   net::TestURLFetcherFactory factory;
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("bla.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("bla.exe"));
-  info.download_url_chain.push_back(GURL("http://www.google.com/"));
-  info.download_url_chain.push_back(GURL("http://www.google.com/bla.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
-  info.sha256_hash = "hash";
-  info.total_bytes = 100;
-  info.user_initiated = true;
-  info.remote_address = "10.11.12.13";
+  base::FilePath tmp_path(FILE_PATH_LITERAL("bla.tmp"));
+  base::FilePath final_path(FILE_PATH_LITERAL("bla.exe"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.google.com/"));
+  url_chain.push_back(GURL("http://www.google.com/bla.exe"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+  std::string remote_address = "10.11.12.13";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(1);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(1);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(tmp_path));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(final_path));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(remote_address));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _))
+  EXPECT_CALL(*signature_util_, CheckSignature(tmp_path, _))
       .WillOnce(SetCertificateContents("dummy cert data"));
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
 #if !defined(OS_WIN)
   // SendRequest is not called.  Wait for FinishRequest to call our callback.
   msg_loop_.Run();
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   EXPECT_EQ(NULL, fetcher);
 #else
   // Run the message loop(s) until SendRequest is called.
   FlushThreadMessageLoops();
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   ClientDownloadRequest request;
   EXPECT_TRUE(request.ParseFromString(fetcher->upload_data()));
   EXPECT_EQ("http://www.google.com/bla.exe", request.url());
-  EXPECT_EQ(info.sha256_hash, request.digests().sha256());
-  EXPECT_EQ(info.total_bytes, request.length());
-  EXPECT_EQ(info.user_initiated, request.user_initiated());
-  EXPECT_TRUE(RequestContainsServerIp(request, info.remote_address));
+  EXPECT_EQ(hash, request.digests().sha256());
+  EXPECT_EQ(item.GetTotalBytes(), request.length());
+  EXPECT_EQ(item.HasUserGesture(), request.user_initiated());
+  EXPECT_TRUE(RequestContainsServerIp(request, remote_address));
   EXPECT_EQ(2, request.resources_size());
   EXPECT_TRUE(RequestContainsResource(request,
                                       ClientDownloadRequest::DOWNLOAD_REDIRECT,
                                       "http://www.google.com/", ""));
   EXPECT_TRUE(RequestContainsResource(request,
                                       ClientDownloadRequest::DOWNLOAD_URL,
                                       "http://www.google.com/bla.exe",
-                                      info.referrer_url.spec()));
+                                      referrer.spec()));
   EXPECT_TRUE(request.has_signature());
   ASSERT_EQ(1, request.signature().certificate_chain_size());
   const ClientDownloadRequest_CertificateChain& chain =
       request.signature().certificate_chain(0);
   ASSERT_EQ(1, chain.element_size());
   EXPECT_EQ("dummy cert data", chain.element(0).certificate());
 
   // Simulate the request finishing.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&DownloadProtectionServiceTest::SendURLFetchComplete,
                  base::Unretained(this), fetcher));
   msg_loop_.Run();
 #endif
 }
 
 // Similar to above, but with an unsigned binary.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestNoSignature) {
   net::TestURLFetcherFactory factory;
 
-  DownloadProtectionService::DownloadInfo info;
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("bla.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("bla.exe"));
-  info.download_url_chain.push_back(GURL("http://www.google.com/"));
-  info.download_url_chain.push_back(GURL("ftp://www.google.com/bla.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
-  info.sha256_hash = "hash";
-  info.total_bytes = 100;
-  info.user_initiated = false;
+  base::FilePath tmp_path(FILE_PATH_LITERAL("bla.tmp"));
+  base::FilePath final_path(FILE_PATH_LITERAL("bla.exe"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.google.com/"));
+  url_chain.push_back(GURL("ftp://www.google.com/bla.exe"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+  std::string remote_address = "10.11.12.13";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(1);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(1);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(tmp_path));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(final_path));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(remote_address));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _));
+  EXPECT_CALL(*signature_util_, CheckSignature(tmp_path, _));
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
 #if !defined(OS_WIN)
   // SendRequest is not called.  Wait for FinishRequest to call our callback.
   msg_loop_.Run();
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   EXPECT_EQ(NULL, fetcher);
 #else
   // Run the message loop(s) until SendRequest is called.
   FlushThreadMessageLoops();
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   ClientDownloadRequest request;
   EXPECT_TRUE(request.ParseFromString(fetcher->upload_data()));
   EXPECT_EQ("ftp://www.google.com/bla.exe", request.url());
-  EXPECT_EQ(info.sha256_hash, request.digests().sha256());
-  EXPECT_EQ(info.total_bytes, request.length());
-  EXPECT_EQ(info.user_initiated, request.user_initiated());
+  EXPECT_EQ(hash, request.digests().sha256());
+  EXPECT_EQ(item.GetTotalBytes(), request.length());
+  EXPECT_EQ(item.HasUserGesture(), request.user_initiated());
   EXPECT_EQ(2, request.resources_size());
   EXPECT_TRUE(RequestContainsResource(request,
                                       ClientDownloadRequest::DOWNLOAD_REDIRECT,
                                       "http://www.google.com/", ""));
   EXPECT_TRUE(RequestContainsResource(request,
                                       ClientDownloadRequest::DOWNLOAD_URL,
                                       "ftp://www.google.com/bla.exe",
-                                      info.referrer_url.spec()));
+                                      referrer.spec()));
   EXPECT_TRUE(request.has_signature());
   EXPECT_EQ(0, request.signature().certificate_chain_size());
 
   // Simulate the request finishing.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&DownloadProtectionServiceTest::SendURLFetchComplete,
                  base::Unretained(this), fetcher));
   msg_loop_.Run();
 #endif
 }
 
 TEST_F(DownloadProtectionServiceTest, TestCheckDownloadUrl) {
-  DownloadProtectionService::DownloadInfo info;
-  info.download_url_chain.push_back(GURL("http://www.google.com/"));
-  info.download_url_chain.push_back(GURL("http://www.google.com/bla.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.google.com/"));
+  url_chain.push_back(GURL("http://www.google.com/bla.exe"));
+  GURL referrer("http://www.google.com/");
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
 
   // CheckDownloadURL returns immediately which means the client object callback
   // will never be called.  Nevertheless the callback provided to
   // CheckClientDownload must still be called.
   EXPECT_CALL(*sb_service_->mock_database_manager(),
-              CheckDownloadUrl(ContainerEq(info.download_url_chain),
-                               NotNull()))
+              CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
       .WillOnce(Return(true));
   download_service_->CheckDownloadUrl(
-      info,
+      item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   Mock::VerifyAndClearExpectations(sb_service_);
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
-              CheckDownloadUrl(ContainerEq(info.download_url_chain),
-                               NotNull()))
+              CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
       .WillOnce(DoAll(CheckDownloadUrlDone(SB_THREAT_TYPE_SAFE),
                       Return(false)));
   download_service_->CheckDownloadUrl(
-      info,
+      item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   Mock::VerifyAndClearExpectations(sb_service_);
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
-              CheckDownloadUrl(ContainerEq(info.download_url_chain),
-                               NotNull()))
+              CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
       .WillOnce(DoAll(
           CheckDownloadUrlDone(SB_THREAT_TYPE_URL_MALWARE),
           Return(false)));
   download_service_->CheckDownloadUrl(
-      info,
+      item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   Mock::VerifyAndClearExpectations(sb_service_);
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
-              CheckDownloadUrl(ContainerEq(info.download_url_chain),
+              CheckDownloadUrl(ContainerEq(url_chain),
                                NotNull()))
       .WillOnce(DoAll(
           CheckDownloadUrlDone(SB_THREAT_TYPE_BINARY_MALWARE_URL),
           Return(false)));
   download_service_->CheckDownloadUrl(
-      info,
+      item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 TEST_F(DownloadProtectionServiceTest, TestDownloadRequestTimeout) {
   net::TestURLFetcherFactory factory;
 
-  DownloadProtectionService::DownloadInfo info;
-  info.download_url_chain.push_back(GURL("http://www.evil.com/bla.exe"));
-  info.referrer_url = GURL("http://www.google.com/");
-  info.local_file = base::FilePath(FILE_PATH_LITERAL("a.tmp"));
-  info.target_file = base::FilePath(FILE_PATH_LITERAL("a.exe"));
+  std::vector<GURL> url_chain;
+  url_chain.push_back(GURL("http://www.evil.com/bla.exe"));
+  GURL referrer("http://www.google.com/");
+  base::FilePath tmp_path(FILE_PATH_LITERAL("a.tmp"));
+  base::FilePath final_path(FILE_PATH_LITERAL("a.exe"));
+  std::string hash = "hash";
+
+  content::MockDownloadItem item;
+  EXPECT_CALL(item, AddObserver(_)).Times(1);
+  EXPECT_CALL(item, RemoveObserver(_)).Times(1);
+  EXPECT_CALL(item, GetFullPath()).WillRepeatedly(ReturnRef(tmp_path));
+  EXPECT_CALL(item, GetTargetFilePath()).WillRepeatedly(ReturnRef(final_path));
+  EXPECT_CALL(item, GetUrlChain()).WillRepeatedly(ReturnRef(url_chain));
+  EXPECT_CALL(item, GetReferrerUrl()).WillRepeatedly(ReturnRef(referrer));
+  EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(hash));
+  EXPECT_CALL(item, GetTotalBytes()).WillRepeatedly(Return(100));
+  EXPECT_CALL(item, HasUserGesture()).WillRepeatedly(Return(true));
+  EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(""));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
-  EXPECT_CALL(*signature_util_, CheckSignature(info.local_file, _));
+  EXPECT_CALL(*signature_util_, CheckSignature(tmp_path, _));
 
   download_service_->download_request_timeout_ms_ = 10;
   download_service_->CheckClientDownload(
-      info,
+      &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
   // The request should time out because the HTTP request hasn't returned
   // anything yet.
   msg_loop_.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, GetCertificateWhitelistStrings) {
@@ skipping 67 matching lines @@
   GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre(cert_base + "/OU=unit"));
 
   cert = ReadTestCertificate("test_c.pem");
   ASSERT_TRUE(cert.get());
   whitelist_strings.clear();
   GetCertificateWhitelistStrings(*cert, *issuer_cert, &whitelist_strings);
   EXPECT_THAT(whitelist_strings, ElementsAre());
 }
 }  // namespace safe_browsing