Sample 1% url whitelisted PPAPI downloads to ping safe browsing server

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>
 #include <memory>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/sha1.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/safe_browsing/download_feedback_service.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.h"
@@ skipping 31 matching lines @@
 using ::testing::DoAll;
 using ::testing::ElementsAre;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::_;
-using base::MessageLoop;
+using base::RunLoop;
 using content::BrowserThread;
 namespace safe_browsing {
 namespace {
 // A SafeBrowsingDatabaseManager implementation that returns a fixed result for
 // a given URL.
 class MockSafeBrowsingDatabaseManager : public TestSafeBrowsingDatabaseManager {
  public:
   MockSafeBrowsingDatabaseManager() {}
 
   MOCK_METHOD1(MatchDownloadWhitelistUrl, bool(const GURL&));
@@ skipping 94 matching lines @@
   void OnRequestEnd(int fetcher_id) override {}
 
   int WaitForRequest() {
     run_loop_.Run();
     return fetcher_id_;
   }
 
  private:
   net::TestURLFetcherFactory* factory_;
   int fetcher_id_;
-  base::RunLoop run_loop_;
+  RunLoop run_loop_;
 };
 }  // 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 49 matching lines @@
     binary_feature_extractor_ = new StrictMock<MockBinaryFeatureExtractor>();
     ON_CALL(*binary_feature_extractor_, ExtractImageFeatures(_, _, _, _))
         .WillByDefault(Return(true));
     download_service_ = sb_service_->download_protection_service();
     download_service_->binary_feature_extractor_ = binary_feature_extractor_;
     download_service_->SetEnabled(true);
     client_download_request_subscription_ =
         download_service_->RegisterClientDownloadRequestCallback(
             base::Bind(&DownloadProtectionServiceTest::OnClientDownloadRequest,
                        base::Unretained(this)));
-    base::RunLoop().RunUntilIdle();
+    RunLoop().RunUntilIdle();
     has_result_ = false;
 
     base::FilePath source_path;
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &source_path));
     testdata_path_ = source_path
         .AppendASCII("chrome")
         .AppendASCII("test")
         .AppendASCII("data")
         .AppendASCII("safe_browsing")
         .AppendASCII("download_protection");
@@ skipping 67 matching lines @@
       if (archived_binary.file_basename() == file_basename)
         return &archived_binary;
     }
     return nullptr;
   }
 
   // Flushes any pending tasks in the message loops of all threads.
   void FlushThreadMessageLoops() {
     BrowserThread::GetBlockingPool()->FlushForTesting();
     FlushMessageLoop(BrowserThread::IO);
-    base::RunLoop().RunUntilIdle();
+    RunLoop().RunUntilIdle();
   }
 
   // Proxy for private method.
   static void GetCertificateWhitelistStrings(
       const net::X509Certificate& certificate,
       const net::X509Certificate& issuer,
       std::vector<std::string>* whitelist_strings) {
     DownloadProtectionService::GetCertificateWhitelistStrings(
         certificate, issuer, whitelist_strings);
   }
@@ skipping 74 matching lines @@
     EXPECT_CALL(*item, GetTabReferrerUrl())
         .WillRepeatedly(ReturnRef(GURL::EmptyGURL()));
     EXPECT_CALL(*item, GetHash()).WillRepeatedly(ReturnRef(hash_));
     EXPECT_CALL(*item, GetReceivedBytes()).WillRepeatedly(Return(100));
     EXPECT_CALL(*item, HasUserGesture()).WillRepeatedly(Return(true));
     EXPECT_CALL(*item, GetRemoteAddress()).WillRepeatedly(Return(""));
   }
 
  private:
   // Helper functions for FlushThreadMessageLoops.
-  void RunAllPendingAndQuitUI() {
-    base::RunLoop().RunUntilIdle();
+  void RunAllPendingAndQuitUI(base::Closure quit_closure) {
+    RunLoop().RunUntilIdle();
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
+        BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::QuitMessageLoop,
-                   base::Unretained(this)));
+                   base::Unretained(this), quit_closure));
   }
 
-  void QuitMessageLoop() { base::MessageLoop::current()->QuitWhenIdle(); }
+  void QuitMessageLoop(base::Closure quit_closure) { quit_closure.Run(); }
 
-  void PostRunMessageLoopTask(BrowserThread::ID thread) {
+  void PostRunMessageLoopTask(base::Closure quit_closure,
+                              BrowserThread::ID thread) {
     BrowserThread::PostTask(
-        thread,
-        FROM_HERE,
+        thread, FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::RunAllPendingAndQuitUI,
-                   base::Unretained(this)));
+                   base::Unretained(this), quit_closure));
   }
 
   void FlushMessageLoop(BrowserThread::ID thread) {
+    RunLoop run_loop;
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
+        BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::PostRunMessageLoopTask,
-                   base::Unretained(this), thread));
-    base::RunLoop().Run();
+                   base::Unretained(this), run_loop.QuitClosure(), thread));
+    run_loop.Run();
   }
 
   void OnClientDownloadRequest(content::DownloadItem* download,
                                const ClientDownloadRequest* request) {
     if (request)
       last_client_download_request_.reset(new ClientDownloadRequest(*request));
     else
       last_client_download_request_.reset();
   }
 
  public:
   enum ArchiveType { ZIP, DMG };
 
   void CheckDoneCallback(
+      base::Closure quit_closure,
       DownloadProtectionService::DownloadCheckResult result) {
     result_ = result;
     has_result_ = true;
-    MessageLoop::current()->QuitWhenIdle();
+    quit_closure.Run();
   }
 
   void SyncCheckDoneCallback(
       DownloadProtectionService::DownloadCheckResult result) {
     result_ = result;
     has_result_ = true;
   }
 
   void SendURLFetchComplete(net::TestURLFetcher* fetcher) {
     fetcher->delegate()->OnURLFetchComplete(fetcher);
@@ skipping 51 matching lines @@
 
 void DownloadProtectionServiceTest::CheckClientDownloadReportCorruptArchive(
     ArchiveType type,
     bool is_extended_reporting,
     bool is_incognito) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
-  profile_->GetPrefs()->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled,
-                                   is_extended_reporting);
+  SetExtendedReportingPreference(is_extended_reporting);
   content::MockDownloadItem 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
   }
 
   if (is_incognito) {
     EXPECT_CALL(item, GetBrowserContext())
         .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
   } else {
     EXPECT_CALL(item, GetBrowserContext())
         .WillRepeatedly(Return(profile_.get()));
   }
 
   std::string file_contents = "corrupt archive file";
   ASSERT_EQ(static_cast<int>(file_contents.size()), base::WriteFile(
       tmp_path_, file_contents.data(), file_contents.size()));
 
+  RunLoop run_loop;
   download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                        base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   const bool expect_request =
       type == ZIP ? is_extended_reporting && !is_incognito : true;
 
   if (expect_request) {
     ASSERT_TRUE(HasClientDownloadRequest());
     EXPECT_EQ(0, GetClientDownloadRequest()->archived_binary_size());
     EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
     ClientDownloadRequest::DownloadType expected_type =
         type == ZIP ? ClientDownloadRequest_DownloadType_INVALID_ZIP
                     : ClientDownloadRequest_DownloadType_INVALID_MAC_ARCHIVE;
     EXPECT_EQ(expected_type, GetClientDownloadRequest()->download_type());
     ClearClientDownloadRequest();
   } else {
     EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
     EXPECT_FALSE(HasClientDownloadRequest());
   }
 
   Mock::VerifyAndClearExpectations(sb_service_.get());
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadInvalidUrl) {
   content::MockDownloadItem 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
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_FALSE(HasClientDownloadRequest());
-  Mock::VerifyAndClearExpectations(&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()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
+    EXPECT_FALSE(HasClientDownloadRequest());
+    Mock::VerifyAndClearExpectations(&item);
+  }
 
-  PrepareBasicDownloadItem(
-    &item,
-    {"file://www.google.com/"},   // url_chain
-    "http://www.google.com/",     // referrer
-    FILE_PATH_LITERAL("a.tmp"),   // tmp_path
-    FILE_PATH_LITERAL("a.exe"));  // final_path
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_FALSE(HasClientDownloadRequest());
+  {
+    PrepareBasicDownloadItem(&item, {"file://www.google.com/"},  // 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()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
+    EXPECT_FALSE(HasClientDownloadRequest());
+  }
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadNotABinary) {
   content::MockDownloadItem 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)));
-  base::RunLoop().Run();
+      &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,
@@ skipping 16 matching lines @@
 
   // We should not get whilelist checks for other URLs than specified below.
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_)).Times(0);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(GURL("http://www.evil.com/bla.exe")))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(GURL("http://www.google.com/a.exe")))
       .WillRepeatedly(Return(true));
-
-  // With no referrer and just the bad url, should be marked DANGEROUS.
-  url_chain_.push_back(GURL("http://www.evil.com/bla.exe"));
   // Set sample rate to 0 to prevent sampling.
   SetWhitelistedDownloadSampleRate(0);
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
 
-  EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  EXPECT_FALSE(GetClientDownloadRequest()->skipped_url_whitelist());
-  EXPECT_FALSE(GetClientDownloadRequest()->skipped_certificate_whitelist());
-  ClearClientDownloadRequest();
+  {
+    // With no referrer and just the bad url, should be marked DANGEROUS.
+    url_chain_.push_back(GURL("http://www.evil.com/bla.exe"));
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
 
-  // Check that the referrer is not matched against the whitelist.
-  referrer_ = GURL("http://www.google.com/");
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    EXPECT_FALSE(GetClientDownloadRequest()->skipped_url_whitelist());
+    EXPECT_FALSE(GetClientDownloadRequest()->skipped_certificate_whitelist());
+    ClearClientDownloadRequest();
+  }
 
-  EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  EXPECT_FALSE(GetClientDownloadRequest()->skipped_url_whitelist());
-  EXPECT_FALSE(GetClientDownloadRequest()->skipped_certificate_whitelist());
-  ClearClientDownloadRequest();
+  {
+    // Check that the referrer is not matched against the whitelist.
+    referrer_ = GURL("http://www.google.com/");
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
 
-  // Redirect from a site shouldn't be checked either.
-  url_chain_.insert(url_chain_.begin(), GURL("http://www.google.com/redirect"));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    EXPECT_FALSE(GetClientDownloadRequest()->skipped_url_whitelist());
+    EXPECT_FALSE(GetClientDownloadRequest()->skipped_certificate_whitelist());
+    ClearClientDownloadRequest();
+  }
 
-  EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  EXPECT_FALSE(GetClientDownloadRequest()->skipped_url_whitelist());
-  EXPECT_FALSE(GetClientDownloadRequest()->skipped_certificate_whitelist());
-  ClearClientDownloadRequest();
+  {
+    // Redirect from a site shouldn't be checked either.
+    url_chain_.insert(url_chain_.begin(),
+                      GURL("http://www.google.com/redirect"));
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
 
-  // Only if the final url is whitelisted should it be SAFE.
-  url_chain_.push_back(GURL("http://www.google.com/a.exe"));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  // TODO(grt): Make the service produce the request even when the URL is
-  // whitelisted.
-  EXPECT_FALSE(HasClientDownloadRequest());
+    EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    EXPECT_FALSE(GetClientDownloadRequest()->skipped_url_whitelist());
+    EXPECT_FALSE(GetClientDownloadRequest()->skipped_certificate_whitelist());
+    ClearClientDownloadRequest();
+  }
+
+  {
+    // Only if the final url is whitelisted should it be SAFE.
+    url_chain_.push_back(GURL("http://www.google.com/a.exe"));
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    // TODO(grt): Make the service produce the request even when the URL is
+    // whitelisted.
+    EXPECT_FALSE(HasClientDownloadRequest());
+  }
 }
 
 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);
@@ skipping 14 matching lines @@
   // Assume http://www.whitelist.com/a.exe is on the whitelist.
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_)).Times(0);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(GURL("http://www.whitelist.com/a.exe")))
       .WillRepeatedly(Return(true));
   url_chain_.push_back(GURL("http://www.whitelist.com/a.exe"));
   // Set sample rate to 1.00, so download_service_ will always send download
   // pings for whitelisted downloads.
   SetWhitelistedDownloadSampleRate(1.00);
-  // Case (1): is_extended_reporting && is_incognito.
-  //           ClientDownloadRequest should NOT be sent.
-  SetExtendedReportingPreference(true);
-  EXPECT_CALL(item, GetBrowserContext())
-          .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  EXPECT_FALSE(HasClientDownloadRequest());
 
-  // Case (2): is_extended_reporting && !is_incognito.
-  //           ClientDownloadRequest should be sent.
-  EXPECT_CALL(item, GetBrowserContext())
-          .WillRepeatedly(Return(profile_.get()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  EXPECT_TRUE(GetClientDownloadRequest()->skipped_url_whitelist());
-  ClearClientDownloadRequest();
+  {
+    // Case (1): is_extended_reporting && is_incognito.
+    //           ClientDownloadRequest should NOT be sent.
+    SetExtendedReportingPreference(true);
+    EXPECT_CALL(item, GetBrowserContext())
+        .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    EXPECT_FALSE(HasClientDownloadRequest());
+  }
 
-  // Case (3): !is_extended_reporting && is_incognito.
-  //           ClientDownloadRequest should NOT be sent.
-  SetExtendedReportingPreference(false);
-  EXPECT_CALL(item, GetBrowserContext())
-          .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  EXPECT_FALSE(HasClientDownloadRequest());
+  {
+    // Case (2): is_extended_reporting && !is_incognito.
+    //           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::SAFE));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    EXPECT_TRUE(GetClientDownloadRequest()->skipped_url_whitelist());
+    ClearClientDownloadRequest();
+  }
 
-  // Case (4): !is_extended_reporting && !is_incognito.
-  //           ClientDownloadRequest should NOT be sent.
-  EXPECT_CALL(item, GetBrowserContext())
-          .WillRepeatedly(Return(profile_.get()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  EXPECT_FALSE(HasClientDownloadRequest());
+  {
+    // 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(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    EXPECT_FALSE(HasClientDownloadRequest());
+  }
+
+  {
+    // Case (4): !is_extended_reporting && !is_incognito.
+    //           ClientDownloadRequest should NOT 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::SAFE));
+    EXPECT_FALSE(HasClientDownloadRequest());
+  }
 }
 
 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;
   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
   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())
+        .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
+    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());
+  }
 
-  // Case (1): is_extended_reporting && is_incognito.
-  //           ClientDownloadRequest should NOT be sent.
-  SetExtendedReportingPreference(true);
-  EXPECT_CALL(item, GetBrowserContext())
-          .WillRepeatedly(Return(profile_->GetOffTheRecordProfile()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_FALSE(HasClientDownloadRequest());
-
-  // Case (2): is_extended_reporting && !is_incognito.
-  //           A "light" ClientDownloadRequest should be sent.
-  EXPECT_CALL(item, GetBrowserContext())
-          .WillRepeatedly(Return(profile_.get()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  // Verify it's a "light" ping, check that URLs don't have paths, and
-  // and verify filename is just an extension.
-  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());
+  {
+    // Case (2): is_extended_reporting && !is_incognito.
+    //           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));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    // Verify it's a "light" ping, check that URLs don't have paths, and
+    // and verify filename is just an extension.
+    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]);
   }
-  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()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_FALSE(HasClientDownloadRequest());
+  {
+    // 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(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
+    EXPECT_FALSE(HasClientDownloadRequest());
+  }
 
-  // Case (4): !is_extended_reporting && !is_incognito.
-  //           ClientDownloadRequest should NOT be sent.
-  EXPECT_CALL(item, GetBrowserContext())
-          .WillRepeatedly(Return(profile_.get()));
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_FALSE(HasClientDownloadRequest());
+  {
+    // Case (4): !is_extended_reporting && !is_incognito.
+    //           ClientDownloadRequest should NOT 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));
+    EXPECT_FALSE(HasClientDownloadRequest());
+  }
 }
 
 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;
   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)));
-  base::RunLoop().Run();
+      &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;
   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(7);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(7);
-
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
-
-  // Invalid response should result in UNKNOWN.
-  ClientDownloadResponse invalid_response;
-  factory.SetFakeResponse(
-      DownloadProtectionService::GetDownloadRequestUrl(),
-      invalid_response.SerializePartialAsString(),
-      net::HTTP_OK, net::URLRequestStatus::SUCCESS);
-
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
   std::string feedback_ping;
   std::string feedback_response;
-  EXPECT_FALSE(DownloadFeedbackService::GetPingsForDownloadForTesting(
-      item, &feedback_ping, &feedback_response));
+  ClientDownloadResponse expected_response;
 
-  // If the response is dangerous the result should also be marked as dangerous.
-  PrepareResponse(
-      &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  {
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_FALSE(DownloadFeedbackService::GetPingsForDownloadForTesting(
-      item, &feedback_ping, &feedback_response));
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
+  }
 
-  EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
+  {
+    // Invalid response should result in UNKNOWN.
+    ClientDownloadResponse invalid_response;
+    factory.SetFakeResponse(DownloadProtectionService::GetDownloadRequestUrl(),
+                            invalid_response.SerializePartialAsString(),
+                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
-  // If the response is uncommon the result should also be marked as uncommon.
-  PrepareResponse(
-      &factory, ClientDownloadResponse::UNCOMMON, net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+    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_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNCOMMON));
-  EXPECT_TRUE(DownloadFeedbackService::GetPingsForDownloadForTesting(
-      item, &feedback_ping, &feedback_response));
-  ClientDownloadRequest decoded_request;
-  EXPECT_TRUE(decoded_request.ParseFromString(feedback_ping));
-  EXPECT_EQ(url_chain_.back().spec(), decoded_request.url());
-  ClientDownloadResponse expected_response;
-  expected_response.set_verdict(ClientDownloadResponse::UNCOMMON);
-  EXPECT_EQ(expected_response.SerializeAsString(), feedback_response);
-  EXPECT_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
+    EXPECT_FALSE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+        item, &feedback_ping, &feedback_response));
+  }
 
-  // If the response is dangerous_host the result should also be marked as
-  // dangerous_host.
-  PrepareResponse(
-      &factory, ClientDownloadResponse::DANGEROUS_HOST, net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  {
+    // If the response is dangerous the result should also be marked as
+    // dangerous.
+    PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                    net::URLRequestStatus::SUCCESS);
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_FALSE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+        item, &feedback_ping, &feedback_response));
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS_HOST));
-  EXPECT_TRUE(DownloadFeedbackService::GetPingsForDownloadForTesting(
-      item, &feedback_ping, &feedback_response));
-  expected_response.set_verdict(ClientDownloadResponse::DANGEROUS_HOST);
-  EXPECT_EQ(expected_response.SerializeAsString(), feedback_response);
-  EXPECT_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
+  }
 
-  // If the response is POTENTIALLY_UNWANTED the result should also be marked as
-  // POTENTIALLY_UNWANTED.
-  PrepareResponse(
-      &factory, ClientDownloadResponse::POTENTIALLY_UNWANTED, net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  {
+    // If the response is uncommon the result should also be marked as uncommon.
+    PrepareResponse(&factory, ClientDownloadResponse::UNCOMMON, net::HTTP_OK,
+                    net::URLRequestStatus::SUCCESS);
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::UNCOMMON));
+    EXPECT_TRUE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+        item, &feedback_ping, &feedback_response));
+    ClientDownloadRequest decoded_request;
+    EXPECT_TRUE(decoded_request.ParseFromString(feedback_ping));
+    EXPECT_EQ(url_chain_.back().spec(), decoded_request.url());
+    expected_response.set_verdict(ClientDownloadResponse::UNCOMMON);
+    EXPECT_EQ(expected_response.SerializeAsString(), feedback_response);
+    EXPECT_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
+  }
 
-  EXPECT_TRUE(IsResult(DownloadProtectionService::POTENTIALLY_UNWANTED));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
+  {
+    // If the response is dangerous_host the result should also be marked as
+    // dangerous_host.
+    PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS_HOST,
+                    net::HTTP_OK, net::URLRequestStatus::SUCCESS);
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS_HOST));
+    EXPECT_TRUE(DownloadFeedbackService::GetPingsForDownloadForTesting(
+        item, &feedback_ping, &feedback_response));
+    expected_response.set_verdict(ClientDownloadResponse::DANGEROUS_HOST);
+    EXPECT_EQ(expected_response.SerializeAsString(), feedback_response);
+    EXPECT_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
+  }
 
-  // If the response is UNKNOWN the result should also be marked as
-  // UNKNOWN
-  PrepareResponse(
-      &factory, ClientDownloadResponse::UNKNOWN, net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  {
+    // If the response is POTENTIALLY_UNWANTED the result should also be marked
+    // as
+    // POTENTIALLY_UNWANTED.
+    PrepareResponse(&factory, ClientDownloadResponse::POTENTIALLY_UNWANTED,
+                    net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+    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_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::POTENTIALLY_UNWANTED));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
+  }
+
+  {
+    // If the response is UNKNOWN the result should also be marked as
+    // UNKNOWN
+    PrepareResponse(&factory, ClientDownloadResponse::UNKNOWN, net::HTTP_OK,
+                    net::URLRequestStatus::SUCCESS);
+
+    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_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
+  }
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadHTTPS) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
   content::MockDownloadItem 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(1);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(1);
 
+  RunLoop run_loop;
   download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                        base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
   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;
   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_, _))
       .Times(1);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(1);
 
+  RunLoop run_loop;
   download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                        base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadData) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
@@ skipping 10 matching lines @@
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_)).WillRepeatedly(Return(false));
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
       .Times(1);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(1);
 
+  RunLoop run_loop;
   download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                        base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
   ASSERT_TRUE(HasClientDownloadRequest());
   const ClientDownloadRequest& request = *GetClientDownloadRequest();
   const char kExpectedUrl[] =
       "data:application/octet-stream:base64,"
       "ACBF6DFC6F907662F566CA0241DFE8690C48661F440BA1BBD0B86C582845CCC8";
   const char kExpectedRedirect1[] = "data:text/html:base64,";
   const char kExpectedRedirect2[] =
       "data:text/html:base64,"
@@ skipping 23 matching lines @@
       net::URLRequestStatus::SUCCESS);
 
   content::MockDownloadItem 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.  In this case, it
-  // only contains a text file.
+  // Write out a zip archive to the temporary 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()), base::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(), tmp_path_, false));
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
-  EXPECT_FALSE(HasClientDownloadRequest());
-  Mock::VerifyAndClearExpectations(sb_service_.get());
-  Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+  {
+    // In this case, it only contains a text file.
+    ASSERT_EQ(static_cast<int>(file_contents.size()),
+              base::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(), tmp_path_, false));
 
-  // Now check with an executable in the zip file as well.
-  ASSERT_EQ(static_cast<int>(file_contents.size()), base::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(), tmp_path_, false));
+    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());
+    Mock::VerifyAndClearExpectations(sb_service_.get());
+    Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+  }
 
-  EXPECT_CALL(*sb_service_->mock_database_manager(),
-              MatchDownloadWhitelistUrl(_))
-      .WillRepeatedly(Return(false));
+  {
+    // Now check with an executable in the zip file as well.
+    ASSERT_EQ(static_cast<int>(file_contents.size()),
+              base::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(), tmp_path_, false));
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+    EXPECT_CALL(*sb_service_->mock_database_manager(),
+                MatchDownloadWhitelistUrl(_))
+        .WillRepeatedly(Return(false));
 
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  const ClientDownloadRequest& request = *GetClientDownloadRequest();
-  EXPECT_TRUE(request.has_download_type());
-  EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE,
-            request.download_type());
-  EXPECT_EQ(1, request.archived_binary_size());
-  const ClientDownloadRequest_ArchivedBinary* archived_binary =
-      GetRequestArchivedBinary(request, "file.exe");
-  ASSERT_NE(nullptr, archived_binary);
-  EXPECT_EQ(ClientDownloadRequest_DownloadType_WIN_EXECUTABLE,
-            archived_binary->download_type());
-  EXPECT_EQ(static_cast<int64_t>(file_contents.size()),
-            archived_binary->length());
-  ClearClientDownloadRequest();
-  Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
 
-  // If the response is dangerous the result should also be marked as
-  // dangerous.
-  PrepareResponse(
-      &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    const ClientDownloadRequest& request = *GetClientDownloadRequest();
+    EXPECT_TRUE(request.has_download_type());
+    EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE,
+              request.download_type());
+    EXPECT_EQ(1, request.archived_binary_size());
+    const ClientDownloadRequest_ArchivedBinary* archived_binary =
+        GetRequestArchivedBinary(request, "file.exe");
+    ASSERT_NE(nullptr, archived_binary);
+    EXPECT_EQ(ClientDownloadRequest_DownloadType_WIN_EXECUTABLE,
+              archived_binary->download_type());
+    EXPECT_EQ(static_cast<int64_t>(file_contents.size()),
+              archived_binary->length());
+    ClearClientDownloadRequest();
+    Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+  }
 
-  download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    // If the response is dangerous the result should also be marked as
+    // dangerous.
+    PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                    net::URLRequestStatus::SUCCESS);
 
-  EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
-  EXPECT_TRUE(HasClientDownloadRequest());
-  ClearClientDownloadRequest();
-  Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
 
-  // Repeat the test with an archive inside the zip file in addition to the
-  // executable.
-  ASSERT_EQ(static_cast<int>(file_contents.size()),
-            base::WriteFile(
-                zip_source_dir.path().Append(FILE_PATH_LITERAL("file.rar")),
-                file_contents.data(), file_contents.size()));
-  ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
+    EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+    EXPECT_TRUE(HasClientDownloadRequest());
+    ClearClientDownloadRequest();
+    Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+  }
 
-  download_service_->CheckClientDownload(
-      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                        base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    // Repeat the test with an archive inside the zip file in addition to the
+    // executable.
+    ASSERT_EQ(static_cast<int>(file_contents.size()),
+              base::WriteFile(
+                  zip_source_dir.path().Append(FILE_PATH_LITERAL("file.rar")),
+                  file_contents.data(), file_contents.size()));
+    ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
 
-  ASSERT_TRUE(HasClientDownloadRequest());
-  EXPECT_EQ(1, GetClientDownloadRequest()->archived_binary_size());
-  EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
-  EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE,
-            GetClientDownloadRequest()->download_type());
-  ClearClientDownloadRequest();
-  Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
 
-  // Repeat the test with just the archive inside the zip file.
-  ASSERT_TRUE(
-      base::DeleteFile(zip_source_dir.path().AppendASCII("file.exe"), false));
-  ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
+    ASSERT_TRUE(HasClientDownloadRequest());
+    EXPECT_EQ(1, GetClientDownloadRequest()->archived_binary_size());
+    EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
+    EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_EXECUTABLE,
+              GetClientDownloadRequest()->download_type());
+    ClearClientDownloadRequest();
+    Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+  }
 
-  download_service_->CheckClientDownload(
-      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                        base::Unretained(this)));
-  base::RunLoop().Run();
+  {
+    // Repeat the test with just the archive inside the zip file.
+    ASSERT_TRUE(
+        base::DeleteFile(zip_source_dir.path().AppendASCII("file.exe"), false));
+    ASSERT_TRUE(zip::Zip(zip_source_dir.path(), tmp_path_, false));
 
-  ASSERT_TRUE(HasClientDownloadRequest());
-  EXPECT_EQ(0, GetClientDownloadRequest()->archived_binary_size());
-  EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
-  EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_ARCHIVE,
-            GetClientDownloadRequest()->download_type());
-  ClearClientDownloadRequest();
-  Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+    RunLoop run_loop;
+    download_service_->CheckClientDownload(
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+
+    ASSERT_TRUE(HasClientDownloadRequest());
+    EXPECT_EQ(0, GetClientDownloadRequest()->archived_binary_size());
+    EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
+    EXPECT_EQ(ClientDownloadRequest_DownloadType_ZIPPED_ARCHIVE,
+              GetClientDownloadRequest()->download_type());
+    ClearClientDownloadRequest();
+    Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
+  }
 }
 
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptZipNormal) {
   // !is_extended_reporting && !is_incognito
   CheckClientDownloadReportCorruptArchive(ZIP, false, false);
 }
 
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadReportCorruptZipExtended) {
@@ skipping 45 matching lines @@
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _))
       .WillOnce(SetCertificateContents("dummy cert data"));
   EXPECT_CALL(
       *binary_feature_extractor_.get(),
       ExtractImageFeatures(tmp_path_, BinaryFeatureExtractor::kDefaultOptions,
                            _, _))
       .WillOnce(SetDosHeaderContents("dummy dos header"));
+  RunLoop run_loop;
   download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
+      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                        base::Unretained(this), run_loop.QuitClosure()));
 
   // Run the message loop(s) until SendRequest is called.
   FlushThreadMessageLoops();
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
   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());
@@ skipping 16 matching lines @@
   ASSERT_EQ(1, chain.element_size());
   EXPECT_EQ("dummy cert data", chain.element(0).certificate());
   EXPECT_TRUE(request.has_image_headers());
   const ClientDownloadRequest_ImageHeaders& headers =
       request.image_headers();
   EXPECT_TRUE(headers.has_pe_headers());
   EXPECT_TRUE(headers.pe_headers().has_dos_header());
   EXPECT_EQ("dummy dos header", headers.pe_headers().dos_header());
 
   // Simulate the request finishing.
+
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&DownloadProtectionServiceTest::SendURLFetchComplete,
                  base::Unretained(this), fetcher));
-  base::RunLoop().Run();
+  run_loop.Run();
 }
 
 // Similar to above, but with an unsigned binary.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestNoSignature) {
   net::TestURLFetcherFactory factory;
 
   content::MockDownloadItem 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));
 
   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)));
+      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                        base::Unretained(this), run_loop.QuitClosure()));
 
   // Run the message loop(s) until SendRequest is called.
   FlushThreadMessageLoops();
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
   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(hash_, request.digests().sha256());
   EXPECT_EQ(item.GetReceivedBytes(), 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",
                                       referrer_.spec()));
   EXPECT_TRUE(request.has_signature());
   EXPECT_EQ(0, request.signature().certificate_chain_size());
 
   // Simulate the request finishing.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&DownloadProtectionServiceTest::SendURLFetchComplete,
                  base::Unretained(this), fetcher));
-  base::RunLoop().Run();
+  run_loop.Run();
 }
 
 // Similar to above, but with tab history.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestTabHistory) {
   net::TestURLFetcherFactory factory;
 
   content::MockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
@@ skipping 18 matching lines @@
       .WillRepeatedly(SetCertificateContents("dummy cert data"));
   EXPECT_CALL(
       *binary_feature_extractor_.get(),
       ExtractImageFeatures(tmp_path_, BinaryFeatureExtractor::kDefaultOptions,
                            _, _))
       .WillRepeatedly(SetDosHeaderContents("dummy dos header"));
 
   // First test with no history match for the tab URL.
   {
     TestURLFetcherWatcher fetcher_watcher(&factory);
+    RunLoop run_loop;
     download_service_->CheckClientDownload(
-        &item,
-        base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                   base::Unretained(this)));
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
 
     EXPECT_EQ(0, fetcher_watcher.WaitForRequest());
     EXPECT_TRUE(HasClientDownloadRequest());
     ClearClientDownloadRequest();
     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(hash_, request.digests().sha256());
@@ skipping 25 matching lines @@
         request.image_headers();
     EXPECT_TRUE(headers.has_pe_headers());
     EXPECT_TRUE(headers.pe_headers().has_dos_header());
     EXPECT_EQ("dummy dos header", headers.pe_headers().dos_header());
 
     // Simulate the request finishing.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::SendURLFetchComplete,
                    base::Unretained(this), fetcher));
-    base::RunLoop().Run();
+    run_loop.Run();
   }
 
   // Now try with a history match.
   {
     history::RedirectList redirects;
     redirects.push_back(GURL("http://tab.com/ref1"));
     redirects.push_back(GURL("http://tab.com/ref2"));
     redirects.push_back(tab_url);
     HistoryServiceFactory::GetForProfile(profile_.get(),
                                          ServiceAccessType::EXPLICIT_ACCESS)
         ->AddPage(tab_url,
                   base::Time::Now(),
                   reinterpret_cast<history::ContextID>(1),
                   0,
                   GURL(),
                   redirects,
                   ui::PAGE_TRANSITION_TYPED,
                   history::SOURCE_BROWSED,
                   false);
 
     TestURLFetcherWatcher fetcher_watcher(&factory);
+    RunLoop run_loop;
     download_service_->CheckClientDownload(
-        &item,
-        base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                   base::Unretained(this)));
+        &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                          base::Unretained(this), run_loop.QuitClosure()));
+
     EXPECT_EQ(0, fetcher_watcher.WaitForRequest());
     EXPECT_TRUE(HasClientDownloadRequest());
     ClearClientDownloadRequest();
     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(hash_, request.digests().sha256());
     EXPECT_EQ(item.GetReceivedBytes(), request.length());
@@ skipping 26 matching lines @@
     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.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::SendURLFetchComplete,
                    base::Unretained(this), fetcher));
-    base::RunLoop().Run();
+    run_loop.Run();
   }
 }
 
 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;
   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(url_chain), NotNull()))
-      .WillOnce(Return(true));
-  download_service_->CheckDownloadUrl(
-      item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_.get());
+  {
+    // 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(url_chain), NotNull()))
+        .WillOnce(Return(true));
+    RunLoop run_loop;
+    download_service_->CheckDownloadUrl(
+        item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                         base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    Mock::VerifyAndClearExpectations(sb_service_.get());
+  }
 
-  EXPECT_CALL(*sb_service_->mock_database_manager(),
-              CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
-      .WillOnce(DoAll(CheckDownloadUrlDone(SB_THREAT_TYPE_SAFE),
-                      Return(false)));
-  download_service_->CheckDownloadUrl(
-      item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_.get());
+  {
+    EXPECT_CALL(*sb_service_->mock_database_manager(),
+                CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
+        .WillOnce(
+            DoAll(CheckDownloadUrlDone(SB_THREAT_TYPE_SAFE), Return(false)));
+    RunLoop run_loop;
+    download_service_->CheckDownloadUrl(
+        item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                         base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    Mock::VerifyAndClearExpectations(sb_service_.get());
+  }
 
-  EXPECT_CALL(*sb_service_->mock_database_manager(),
-              CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
-      .WillOnce(DoAll(
-          CheckDownloadUrlDone(SB_THREAT_TYPE_URL_MALWARE),
-          Return(false)));
-  download_service_->CheckDownloadUrl(
-      item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
-  Mock::VerifyAndClearExpectations(sb_service_.get());
+  {
+    EXPECT_CALL(*sb_service_->mock_database_manager(),
+                CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
+        .WillOnce(DoAll(CheckDownloadUrlDone(SB_THREAT_TYPE_URL_MALWARE),
+                        Return(false)));
+    RunLoop run_loop;
+    download_service_->CheckDownloadUrl(
+        item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                         base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
+    Mock::VerifyAndClearExpectations(sb_service_.get());
+  }
 
-  EXPECT_CALL(*sb_service_->mock_database_manager(),
-              CheckDownloadUrl(ContainerEq(url_chain),
-                               NotNull()))
-      .WillOnce(DoAll(
-          CheckDownloadUrlDone(SB_THREAT_TYPE_BINARY_MALWARE_URL),
-          Return(false)));
-  download_service_->CheckDownloadUrl(
-      item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
-  EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+  {
+    EXPECT_CALL(*sb_service_->mock_database_manager(),
+                CheckDownloadUrl(ContainerEq(url_chain), NotNull()))
+        .WillOnce(DoAll(CheckDownloadUrlDone(SB_THREAT_TYPE_BINARY_MALWARE_URL),
+                        Return(false)));
+    RunLoop run_loop;
+    download_service_->CheckDownloadUrl(
+        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;
   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));
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _));
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(tmp_path_,
                                    BinaryFeatureExtractor::kDefaultOptions,
                                    _, _));
 
   download_service_->download_request_timeout_ms_ = 10;
+  RunLoop run_loop;
   download_service_->CheckClientDownload(
-      &item,
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
+      &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                        base::Unretained(this), run_loop.QuitClosure()));
 
   // The request should time out because the HTTP request hasn't returned
   // anything yet.
-  base::RunLoop().Run();
+  run_loop.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, TestDownloadItemDestroyed) {
   {
     content::MockDownloadItem item;
     PrepareBasicDownloadItem(
       &item,
@@ skipping 42 matching lines @@
       .WillRepeatedly(Invoke([&item](const GURL&) {
         item.reset();
         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.get(),
-      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
+      item.get(), base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                             base::Unretained(this), run_loop.QuitClosure()));
 
-  base::RunLoop().Run();
+  run_loop.Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
   EXPECT_FALSE(HasClientDownloadRequest());
 }
 
 TEST_F(DownloadProtectionServiceTest, GetCertificateWhitelistStrings) {
   // We'll pass this cert in as the "issuer", even though it isn't really
   // used to sign the certs below.  GetCertificateWhitelistStirngs doesn't care
   // about this.
   scoped_refptr<net::X509Certificate> issuer_cert(
       ReadTestCertificate("issuer.pem"));
@@ skipping 120 matching lines @@
   EXPECT_EQ(token, DownloadProtectionService::GetDownloadPingToken(&item));
 
   DownloadProtectionService::SetDownloadPingToken(&item, std::string());
   EXPECT_TRUE(DownloadProtectionService::GetDownloadPingToken(&item).empty());
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_Unsupported) {
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.txt"));
   std::vector<base::FilePath::StringType> alternate_extensions{
       FILE_PATH_LITERAL(".tmp"), FILE_PATH_LITERAL(".asdfasdf")};
+  SetExtendedReportingPreference(false);
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::SyncCheckDoneCallback,
                  base::Unretained(this)));
   ASSERT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_SupportedDefault) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   EXPECT_CALL(*sb_service_->mock_database_manager(),
@@ skipping 10 matching lines @@
        DownloadProtectionService::DANGEROUS_HOST},
       {ClientDownloadResponse::POTENTIALLY_UNWANTED,
        DownloadProtectionService::POTENTIALLY_UNWANTED},
       {ClientDownloadResponse::UNKNOWN, DownloadProtectionService::UNKNOWN},
   };
 
   for (const auto& test_case : kExpectedResults) {
     factory.ClearFakeResponses();
     PrepareResponse(&factory, test_case.verdict, net::HTTP_OK,
                     net::URLRequestStatus::SUCCESS);
+    SetExtendedReportingPreference(false);
+    RunLoop run_loop;
     download_service_->CheckPPAPIDownloadRequest(
         GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+        profile_.get(),
         base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                   base::Unretained(this)));
-    base::RunLoop().Run();
+                   base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
     ASSERT_TRUE(IsResult(test_case.expected_result));
   }
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_SupportedAlternate) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.txt"));
   std::vector<base::FilePath::StringType> alternate_extensions{
       FILE_PATH_LITERAL(".tmp"), FILE_PATH_LITERAL(".crx")};
   PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
+  SetExtendedReportingPreference(false);
+  RunLoop run_loop;
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
-TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_WhitelistedURL) {
+TEST_F(DownloadProtectionServiceTest,
+       PPAPIDownloadRequest_WhitelistedURLNotExtendedReporting) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
+  // Configs "server" side response to DANGEROUS, in case a request is send out.
+  PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(true));
+  SetExtendedReportingPreference(false);
+  // Sets the sample rate to 1.00.
+  SetWhitelistedDownloadSampleRate(1.00);
+  RunLoop run_loop;
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
+  // Result should be SAFE, since download matches whitelist but user is not in
+  // extended reporting group (a.k.a no request sents out).
   ASSERT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
+TEST_F(DownloadProtectionServiceTest,
+       PPAPIDownloadRequest_WhitelistedURLIncognito) {
+  net::FakeURLFetcherFactory factory(nullptr);
+  base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
+  std::vector<base::FilePath::StringType> alternate_extensions;
+  // Configs "server" side response to DANGEROUS, in case a request is send out.
+  PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
+  EXPECT_CALL(*sb_service_->mock_database_manager(),
+              MatchDownloadWhitelistUrl(_))
+      .WillRepeatedly(Return(true));
+  SetExtendedReportingPreference(true);
+  RunLoop run_loop;
+  download_service_->CheckPPAPIDownloadRequest(
+      GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_->GetOffTheRecordProfile(),
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
+
+  // Result should still be SAFE, since download matches whitelist and user is
+  // in incognito mode.
+  ASSERT_TRUE(IsResult(DownloadProtectionService::SAFE));
+}
+
+TEST_F(DownloadProtectionServiceTest,
+       PPAPIDownloadRequest_SampleWhitelistedURL) {
+  net::FakeURLFetcherFactory factory(nullptr);
+  base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
+  std::vector<base::FilePath::StringType> alternate_extensions;
+  // Configs "server" side response to DANGEROUS.
+  PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
+                  net::URLRequestStatus::SUCCESS);
+  EXPECT_CALL(*sb_service_->mock_database_manager(),
+              MatchDownloadWhitelistUrl(_))
+      .WillRepeatedly(Return(true));
+  // Sets the sample rate to 1.00 to trigger ClientDownloadRequest.
+  SetWhitelistedDownloadSampleRate(1.00);
+  SetExtendedReportingPreference(true);
+  RunLoop run_loop;
+  download_service_->CheckPPAPIDownloadRequest(
+      GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
+      base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
+
+  // Result should be Dangerous, since we will sample this download and ping SB
+  // Server (server returns DANGEROUS verdict).
+  ASSERT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
+}
+
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_FetchFailed) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   PrepareResponse(&factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
                   net::URLRequestStatus::FAILED);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
+  SetExtendedReportingPreference(false);
+  RunLoop run_loop;
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_InvalidResponse) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   factory.SetFakeResponse(DownloadProtectionService::GetDownloadRequestUrl(),
                           "Hello world!", net::HTTP_OK,
                           net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
+  SetExtendedReportingPreference(false);
+  RunLoop run_loop;
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_Timeout) {
   net::FakeURLFetcherFactory factory(nullptr);
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions;
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   PrepareResponse(&factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   download_service_->download_request_timeout_ms_ = 0;
+  SetExtendedReportingPreference(false);
+  RunLoop run_loop;
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
+      profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 namespace {
 
 std::unique_ptr<net::FakeURLFetcher> FakeURLFetcherCreatorFunc(
     std::string* upload_data_receiver,
     const GURL& url,
     net::URLFetcherDelegate* delegate,
@@ skipping 35 matching lines @@
   base::FilePath default_file_path(FILE_PATH_LITERAL("/foo/bar/test.crx"));
   std::vector<base::FilePath::StringType> alternate_extensions{
       FILE_PATH_LITERAL(".txt"), FILE_PATH_LITERAL(".abc"),
       FILE_PATH_LITERAL(""), FILE_PATH_LITERAL(".sdF")};
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
   PrepareResponse(&factory, ClientDownloadResponse::SAFE, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   const GURL kRequestorUrl("http://example.com/foo");
+  SetExtendedReportingPreference(false);
+  RunLoop run_loop;
   download_service_->CheckPPAPIDownloadRequest(
-      kRequestorUrl, default_file_path, alternate_extensions,
+      kRequestorUrl, default_file_path, alternate_extensions, profile_.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
-                 base::Unretained(this)));
-  base::RunLoop().Run();
+                 base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   ASSERT_FALSE(upload_data.empty());
 
   ClientDownloadRequest request;
   ASSERT_TRUE(request.ParseFromString(upload_data));
 
   EXPECT_EQ(ClientDownloadRequest::PPAPI_SAVE_REQUEST, request.download_type());
   EXPECT_EQ(kRequestorUrl.spec(), request.url());
   EXPECT_EQ("test.crx", request.file_basename());
   ASSERT_EQ(3, request.alternate_extensions_size());
@@ skipping 38 matching lines @@
     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));
   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)));
-  base::RunLoop().Run();
+      &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));
 }
 
 // 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;
 
   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_.path().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)));
-  base::RunLoop().Run();
+                        base::Unretained(this), run_loop.QuitClosure()));
+  run_loop.Run();
 
   EXPECT_FALSE(HasClientDownloadRequest());
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 }  // namespace safe_browsing