Add full filename to sampled-download pings.

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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 48 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/google/zip.h"
 #include "url/gurl.h"
 
 using ::testing::Assign;
 using ::testing::ContainerEq;
 using ::testing::DoAll;
 using ::testing::ElementsAre;
 using ::testing::Invoke;
 using ::testing::Mock;
+using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::_;
 using base::RunLoop;
 using content::BrowserThread;
 
 namespace safe_browsing {
@@ skipping 107 matching lines @@
     run_loop_.Run();
     return fetcher_id_;
   }
 
  private:
   net::TestURLFetcherFactory* factory_;
   int fetcher_id_;
   RunLoop run_loop_;
 };
 
+using NiceMockDownloadItem = NiceMock<content::MockDownloadItem>;
+
 }  // namespace
 
 ACTION_P(SetCertificateContents, contents) {
   arg1->add_certificate_chain()->add_element()->set_certificate(contents);
 }
 
 ACTION_P(SetDosHeaderContents, contents) {
   arg2->mutable_pe_headers()->set_dos_header(contents);
   return true;
 }
@@ skipping 193 matching lines @@
     ClientDownloadResponse response;
     response.set_verdict(verdict);
     response.set_upload(upload_requested);
     factory->SetFakeResponse(
         DownloadProtectionService::GetDownloadRequestUrl(),
         response.SerializeAsString(),
         response_code, status);
   }
 
   void PrepareBasicDownloadItem(
-      content::MockDownloadItem* item,
+      NiceMockDownloadItem* item,
       const std::vector<std::string> url_chain_items,
       const std::string& referrer_url,
       const base::FilePath::StringType& tmp_path_literal,
       const base::FilePath::StringType& final_path_literal) {
     base::FilePath tmp_path = temp_dir_.GetPath().Append(tmp_path_literal);
     base::FilePath final_path = temp_dir_.GetPath().Append(final_path_literal);
 
     PrepareBasicDownloadItemWithFullPaths(item, url_chain_items, referrer_url,
       tmp_path, final_path);
   }
 
   void PrepareBasicDownloadItemWithFullPaths(
-      content::MockDownloadItem* item,
+      NiceMockDownloadItem* item,
       const std::vector<std::string> url_chain_items,
       const std::string& referrer_url,
       const base::FilePath& tmp_full_path,
       const base::FilePath& final_full_path) {
     url_chain_.clear();
     for (std::string item: url_chain_items)
       url_chain_.push_back(GURL(item));
+    if (url_chain_.empty())
+      url_chain_.push_back(GURL());
     referrer_ = GURL(referrer_url);
     tmp_path_ = tmp_full_path;
     final_path_ = final_full_path;
     hash_ = "hash";
 
-    if (url_chain_.size() > 0) {
-      EXPECT_CALL(*item, GetURL()).WillRepeatedly(ReturnRef(url_chain_.back()));
-    } else{
-      GURL empty_url;
-      EXPECT_CALL(*item, GetURL()).WillRepeatedly(ReturnRef(empty_url));
-    }
+    EXPECT_CALL(*item, GetURL()).WillRepeatedly(ReturnRef(url_chain_.back()));
     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, GetTabUrl())
         .WillRepeatedly(ReturnRef(GURL::EmptyGURL()));
     EXPECT_CALL(*item, GetTabReferrerUrl())
         .WillRepeatedly(ReturnRef(GURL::EmptyGURL()));
     EXPECT_CALL(*item, GetHash()).WillRepeatedly(ReturnRef(hash_));
@@ skipping 93 matching lines @@
   content::InProcessUtilityThreadHelper in_process_utility_thread_helper_;
   base::FilePath testdata_path_;
   DownloadProtectionService::ClientDownloadRequestSubscription
       client_download_request_subscription_;
   DownloadProtectionService::PPAPIDownloadRequestSubscription
       ppapi_download_request_subscription_;
   std::unique_ptr<ClientDownloadRequest> last_client_download_request_;
   base::ScopedTempDir profile_dir_;
   std::unique_ptr<TestingProfile> profile_;
   // The following 5 fields are used by PrepareBasicDownloadItem() function to
-  // store attributes of the last download item.
+  // store attributes of the last download item. They can be modified
+  // afterwards and the *item will return the new values.
   std::vector<GURL> url_chain_;
   GURL referrer_;
   base::FilePath tmp_path_;
   base::FilePath final_path_;
   std::string hash_;
   base::ScopedTempDir temp_dir_;
 };
 
 void DownloadProtectionServiceTest::CheckClientDownloadReportCorruptArchive(
     ArchiveType type) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   if (type == ZIP) {
     PrepareBasicDownloadItem(&item, {"http://www.evil.com/a.zip"},  // url_chain
                              "http://www.google.com/",     // referrer
                              FILE_PATH_LITERAL("a.tmp"),   // tmp_path
                              FILE_PATH_LITERAL("a.zip"));  // final_path
   } else if (type == DMG) {
     PrepareBasicDownloadItem(&item, {"http://www.evil.com/a.dmg"},  // url_chain
                              "http://www.google.com/",     // referrer
                              FILE_PATH_LITERAL("a.tmp"),   // tmp_path
                              FILE_PATH_LITERAL("a.dmg"));  // final_path
@@ skipping 17 matching lines @@
       type == ZIP ? ClientDownloadRequest_DownloadType_INVALID_ZIP
       : ClientDownloadRequest_DownloadType_INVALID_MAC_ARCHIVE;
   EXPECT_EQ(expected_type, GetClientDownloadRequest()->download_type());
   ClearClientDownloadRequest();
 
   Mock::VerifyAndClearExpectations(sb_service_.get());
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadInvalidUrl) {
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   {
     PrepareBasicDownloadItem(&item,
                              std::vector<std::string>(),   // empty url_chain
                              "http://www.google.com/",     // referrer
                              FILE_PATH_LITERAL("a.tmp"),   // tmp_path
                              FILE_PATH_LITERAL("a.exe"));  // final_path
     RunLoop run_loop;
     download_service_->CheckClientDownload(
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
@@ skipping 12 matching lines @@
     download_service_->CheckClientDownload(
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
     EXPECT_FALSE(HasClientDownloadRequest());
   }
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadNotABinary) {
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     std::vector<std::string>(),   // empty url_chain
     "http://www.google.com/",     // referrer
     FILE_PATH_LITERAL("a.tmp"),   // tmp_path
     FILE_PATH_LITERAL("a.txt"));  // final_path
   RunLoop run_loop;
   download_service_->CheckClientDownload(
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
   EXPECT_FALSE(HasClientDownloadRequest());
 }
 
 TEST_F(DownloadProtectionServiceTest,
     CheckClientDownloadWhitelistedUrlWithoutSampling) {
   // Response to any requests will be DANGEROUS.
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     std::vector<std::string>(),   // empty url_chain
     "",                           // referrer
     FILE_PATH_LITERAL("a.tmp"),   // tmp_path
     FILE_PATH_LITERAL("a.exe"));  // final_path
 
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
       .Times(4);
   EXPECT_CALL(*binary_feature_extractor_.get(),
@@ skipping 75 matching lines @@
 
 TEST_F(DownloadProtectionServiceTest,
     CheckClientDownloadWhitelistedUrlWithSampling) {
   // Server responses "SAFE" to every requests coming from whitelisted
   // download.
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     std::vector<std::string>(),   // empty url_chain
     "http://www.google.com/",     // referrer
     FILE_PATH_LITERAL("a.tmp"),   // tmp_path
     FILE_PATH_LITERAL("a.exe"));  // final_path
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
       .Times(4);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
@@ skipping 129 matching lines @@
   }
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadSampledFile) {
   // Server response will be discarded.
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
-    &item,
-    std::vector<std::string>(),   // empty url_chain
-    "http://www.google.com/",     // referrer
-    FILE_PATH_LITERAL("a.tmp"),   // tmp_path
-    FILE_PATH_LITERAL("a.foobar_unknown_ype"));  // final_path
+      &item,
+      // Add paths so we can check they are properly removed.
+      {"http://referrer.com/1/2", "http://referrer.com/3/4",
+       "http://download.com/path/a.foobar_unknown_type"},
+      "http://referrer.com/3/4",                    // Referrer
+      FILE_PATH_LITERAL("a.tmp"),                   // tmp_path
+      FILE_PATH_LITERAL("a.foobar_unknown_type"));  // final_path
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
       .Times(1);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(1);
-  url_chain_.push_back(GURL("http://www.whitelist.com/a.foobar_unknown_type"));
 
   // Set ping sample rate to 1.00 so download_service_ will always send a
   // "light" ping for unknown types if allowed.
   SetBinarySamplingProbability(1.0);
 
   {
     // Case (1): is_extended_reporting && is_incognito.
     //           ClientDownloadRequest should NOT be sent.
     SetExtendedReportingPreference(true);
     EXPECT_CALL(item, GetBrowserContext())
@@ skipping 11 matching lines @@
     //           A "light" ClientDownloadRequest should be sent.
     EXPECT_CALL(item, GetBrowserContext())
         .WillRepeatedly(Return(profile_.get()));
     RunLoop run_loop;
     download_service_->CheckClientDownload(
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
     ASSERT_TRUE(HasClientDownloadRequest());
-    // Verify it's a "light" ping, check that URLs don't have paths, and
-    // and verify filename is just an extension.
+
+    // Verify it's a "light" ping, check that URLs don't have paths.
     auto* req = GetClientDownloadRequest();
     EXPECT_EQ(ClientDownloadRequest::SAMPLED_UNSUPPORTED_FILE,
               req->download_type());
     EXPECT_EQ(GURL(req->url()).GetOrigin().spec(), req->url());
     for (auto resource : req->resources()) {
       EXPECT_EQ(GURL(resource.url()).GetOrigin().spec(), resource.url());
       EXPECT_EQ(GURL(resource.referrer()).GetOrigin().spec(),
                 resource.referrer());
     }
-    EXPECT_EQ('.', req->file_basename()[0]);
     ClearClientDownloadRequest();
   }
   {
     // Case (3): !is_extended_reporting && is_incognito.
     //           ClientDownloadRequest should NOT be sent.
     SetExtendedReportingPreference(false);
     EXPECT_CALL(item, GetBrowserContext())
         .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
     RunLoop run_loop;
     download_service_->CheckClientDownload(
@@ skipping 18 matching lines @@
   }
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadFetchFailed) {
   // HTTP request will fail.
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_INTERNAL_SERVER_ERROR,
       net::URLRequestStatus::FAILED);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.evil.com/a.exe"},  // url_chain
     "http://www.google.com/",       // referrer
     FILE_PATH_LITERAL("a.tmp"),     // tmp_path
     FILE_PATH_LITERAL("a.exe"));    // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _));
   EXPECT_CALL(
       *binary_feature_extractor_.get(),
       ExtractImageFeatures(tmp_path_, BinaryFeatureExtractor::kDefaultOptions,
                            _, _));
   RunLoop run_loop;
   download_service_->CheckClientDownload(
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadSuccess) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(&factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(&item, {"http://www.evil.com/a.exe"},  // url_chain
                            "http://www.google.com/",              // referrer
                            FILE_PATH_LITERAL("a.tmp"),            // tmp_path
                            FILE_PATH_LITERAL("a.exe"));           // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
       .Times(8);
@@ skipping 137 matching lines @@
     ClearClientDownloadRequest();
   }
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadHTTPS) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(&item,
                            {"http://www.evil.com/a.exe"},  // url_chain
                            "http://www.google.com/",       // referrer
                            FILE_PATH_LITERAL("a.tmp"),     // tmp_path
                            FILE_PATH_LITERAL("a.exe"));    // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
@@ skipping 12 matching lines @@
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadBlob) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"blob:http://www.evil.com/50b85f60-71e4-11e4-82f8-0800200c9a66"},
     "http://www.google.com/",     // referrer
     FILE_PATH_LITERAL("a.tmp"),   // tmp_path
     FILE_PATH_LITERAL("a.exe"));  // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_)).WillRepeatedly(Return(false));
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
@@ skipping 13 matching lines @@
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadData) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"data:text/html:base64,", "data:text/html:base64,blahblahblah",
      "data:application/octet-stream:base64,blahblah"},  // url_chain
     "data:text/html:base64,foobar",                     // referrer
     FILE_PATH_LITERAL("a.tmp"),                         // tmp_path
     FILE_PATH_LITERAL("a.exe"));                        // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_)).WillRepeatedly(Return(false));
@@ skipping 37 matching lines @@
                                       kExpectedUrl, kExpectedReferrer));
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadZip) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.evil.com/a.zip"},  // url_chain
     "http://www.google.com/",       // referrer
     FILE_PATH_LITERAL("a.tmp"),     // tmp_path
     FILE_PATH_LITERAL("a.zip"));    // final_path
 
   // Write out a zip archive to the temporary file.
   base::ScopedTempDir zip_source_dir;
   ASSERT_TRUE(zip_source_dir.CreateUniqueTempDir());
@@ skipping 111 matching lines @@
 #if defined(OS_MACOSX)
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptDmg) {
   CheckClientDownloadReportCorruptArchive(DMG);
 }
 #endif
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadValidateRequest) {
   net::TestURLFetcherFactory factory;
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.google.com/",
      "http://www.google.com/bla.exe"},  // url_chain
     "http://www.google.com/",           // referrer
     FILE_PATH_LITERAL("bla.tmp"),       // tmp_path
     FILE_PATH_LITERAL("bla.exe"));      // final_path
 
   std::string remote_address = "10.11.12.13";
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(remote_address));
@@ skipping 53 matching lines @@
       base::BindOnce(&DownloadProtectionServiceTest::SendURLFetchComplete,
                      base::Unretained(this), fetcher));
   run_loop.Run();
 }
 
 // Similar to above, but with an unsigned binary.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestNoSignature) {
   net::TestURLFetcherFactory factory;
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.google.com/",
      "ftp://www.google.com/bla.exe"},  // url_chain
     "http://www.google.com/",          // referrer
     FILE_PATH_LITERAL("bla.tmp"),      // tmp_path
     FILE_PATH_LITERAL("bla.exe"));     // final_path
   std::string remote_address = "10.11.12.13";
   EXPECT_CALL(item, GetRemoteAddress()).WillRepeatedly(Return(remote_address));
 
@@ skipping 39 matching lines @@
       base::BindOnce(&DownloadProtectionServiceTest::SendURLFetchComplete,
                      base::Unretained(this), fetcher));
   run_loop.Run();
 }
 
 // Similar to above, but with tab history.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestTabHistory) {
   net::TestURLFetcherFactory factory;
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.google.com/",
      "http://www.google.com/bla.exe"},  // url_chain
     "http://www.google.com/",           // referrer
     FILE_PATH_LITERAL("bla.tmp"),       // tmp_path
     FILE_PATH_LITERAL("bla.exe"));      // final_path
 
   GURL tab_url("http://tab.com/final");
   GURL tab_referrer("http://tab.com/referrer");
@@ skipping 144 matching lines @@
 
 TEST_F(DownloadProtectionServiceTest, TestCheckDownloadUrl) {
   net::TestURLFetcherFactory factory;
 
   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;
+  NiceMockDownloadItem item;
   EXPECT_CALL(item, GetURL()).WillRepeatedly(ReturnRef(url_chain.back()));
   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(),
@@ skipping 43 matching lines @@
         &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                           base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
   }
 }
 
 TEST_F(DownloadProtectionServiceTest, TestDownloadRequestTimeout) {
   net::TestURLFetcherFactory factory;
 
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.evil.com/bla.exe"},  // url_chain
     "http://www.google.com/",         // referrer
     FILE_PATH_LITERAL("a.tmp"),       // tmp_path
     FILE_PATH_LITERAL("a.exe"));      // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
@@ skipping 12 matching lines @@
   // The request should time out because the HTTP request hasn't returned
   // anything yet.
   run_loop.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, TestDownloadItemDestroyed) {
   {
-    content::MockDownloadItem item;
+    NiceMockDownloadItem item;
     PrepareBasicDownloadItem(
       &item,
       {"http://www.evil.com/bla.exe"},  // url_chain
       "http://www.google.com/",         // referrer
       FILE_PATH_LITERAL("a.tmp"),       // tmp_path
       FILE_PATH_LITERAL("a.exe"));      // final_path
     GURL tab_url("http://www.google.com/tab");
     EXPECT_CALL(item, GetTabUrl()).WillRepeatedly(ReturnRef(tab_url));
     EXPECT_CALL(*sb_service_->mock_database_manager(),
                 MatchDownloadWhitelistUrl(_))
@@ skipping 11 matching lines @@
     // notification.
   }
 
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
   EXPECT_FALSE(HasClientDownloadRequest());
 }
 
 TEST_F(DownloadProtectionServiceTest,
        TestDownloadItemDestroyedDuringWhitelistCheck) {
   net::TestURLFetcherFactory factory;
-  std::unique_ptr<content::MockDownloadItem> item(
-      new content::MockDownloadItem);
+  std::unique_ptr<NiceMockDownloadItem> item(new NiceMockDownloadItem);
   PrepareBasicDownloadItem(
     item.get(),
     {"http://www.evil.com/bla.exe"},  // url_chain
     "http://www.google.com/",         // referrer
     FILE_PATH_LITERAL("a.tmp"),       // tmp_path
     FILE_PATH_LITERAL("a.exe"));      // final_path
   GURL tab_url("http://www.google.com/tab");
   EXPECT_CALL(*item, GetTabUrl()).WillRepeatedly(ReturnRef(tab_url));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
@@ skipping 133 matching lines @@
 
   EXPECT_CALL(mock_download_item, GetDangerType())
       .WillOnce(Return(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST));
   EXPECT_CALL(mock_page_navigator, OpenURL(OpenURLParamsWithContextValue("7")));
 
   download_service_->ShowDetailsForDownload(mock_download_item,
                                             &mock_page_navigator);
 }
 
 TEST_F(DownloadProtectionServiceTest, GetAndSetDownloadPingToken) {
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   EXPECT_TRUE(DownloadProtectionService::GetDownloadPingToken(&item).empty());
   std::string token = "download_ping_token";
   DownloadProtectionService::SetDownloadPingToken(&item, token);
   EXPECT_EQ(token, DownloadProtectionService::GetDownloadPingToken(&item));
 
   DownloadProtectionService::SetDownloadPingToken(&item, std::string());
   EXPECT_TRUE(DownloadProtectionService::GetDownloadPingToken(&item).empty());
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_Unsupported) {
@@ skipping 245 matching lines @@
     DownloadProtectionServiceTest::SetUp();
   }
 
   // Hex 64 chars
   const std::string blacklisted_hash_hex_;
   // Binary 32 bytes
   std::string blacklisted_hash_;
 };
 
 TEST_F(DownloadProtectionServiceFlagTest, CheckClientDownloadOverridenByFlag) {
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.evil.com/a.exe"},  // url_chain
     "http://www.google.com/",       // referrer
     FILE_PATH_LITERAL("a.tmp"),     // tmp_path
     FILE_PATH_LITERAL("a.exe"));    // final_path
   EXPECT_CALL(item, GetHash()).WillRepeatedly(ReturnRef(blacklisted_hash_));
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
@@ skipping 10 matching lines @@
 
   EXPECT_FALSE(HasClientDownloadRequest());
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 // Test a real .zip with a real .exe in it, where the .exe is manually
 // blacklisted by hash.
 TEST_F(DownloadProtectionServiceFlagTest,
        CheckClientDownloadZipOverridenByFlag) {
-  content::MockDownloadItem item;
+  NiceMockDownloadItem item;
 
   PrepareBasicDownloadItemWithFullPaths(
       &item, {"http://www.evil.com/a.exe"},  // url_chain
       "http://www.google.com/",              // referrer
       testdata_path_.AppendASCII(
           "zipfile_one_unsigned_binary.zip"),                   // tmp_path
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("a.zip")));  // final_path
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
 
   RunLoop run_loop;
   download_service_->CheckClientDownload(
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
 
   EXPECT_FALSE(HasClientDownloadRequest());
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 }  // namespace safe_browsing