Remove calls to deprecated MessageLoop methods in chrome.

chrome/browser/safe_browsing/download_protection_service_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 424 matching lines @@
         .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::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::QuitMessageLoop,
                    base::Unretained(this)));
   }
 
   void QuitMessageLoop() { base::MessageLoop::current()->QuitWhenIdle(); }
 
   void PostRunMessageLoopTask(BrowserThread::ID thread) {
     BrowserThread::PostTask(
         thread,
         FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::RunAllPendingAndQuitUI,
                    base::Unretained(this)));
   }
 
   void FlushMessageLoop(BrowserThread::ID thread) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DownloadProtectionServiceTest::PostRunMessageLoopTask,
                    base::Unretained(this), thread));
-    MessageLoop::current()->Run();
+    base::RunLoop().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();
   }
 
@@ skipping 93 matching lines @@
   }
 
   std::string file_contents = "corrupt zip file";
   ASSERT_EQ(static_cast<int>(file_contents.size()), base::WriteFile(
       tmp_path_, file_contents.data(), file_contents.size()));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   const bool expect_request = is_extended_reporting && !is_incognito;
 
   if (expect_request) {
     ASSERT_TRUE(HasClientDownloadRequest());
     EXPECT_EQ(0, GetClientDownloadRequest()->archived_binary_size());
     EXPECT_TRUE(GetClientDownloadRequest()->has_download_type());
     EXPECT_EQ(ClientDownloadRequest_DownloadType_INVALID_ZIP,
               GetClientDownloadRequest()->download_type());
     ClearClientDownloadRequest();
@@ skipping 12 matching lines @@
   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)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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 25 matching lines @@
       .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)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   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/");
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   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"));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   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"));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  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());
 }
 
 TEST_F(DownloadProtectionServiceTest,
     CheckClientDownloadWhitelistedUrlWithSampling) {
   // Server responses "SAFE" to every requests coming from whitelisted
   // download.
@@ skipping 27 matching lines @@
   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)));
-  MessageLoop::current()->Run();
+  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)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::SAFE));
   EXPECT_TRUE(HasClientDownloadRequest());
   EXPECT_TRUE(GetClientDownloadRequest()->skipped_url_whitelist());
   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)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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()));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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);
@@ skipping 103 matching lines @@
   EXPECT_CALL(*binary_feature_extractor_.get(), CheckSignature(tmp_path_, _));
   EXPECT_CALL(
       *binary_feature_extractor_.get(),
       ExtractImageFeatures(tmp_path_, BinaryFeatureExtractor::kDefaultOptions,
                            _, _));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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;
@@ skipping 11 matching lines @@
       .Times(6);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(6);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  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)));
-  MessageLoop::current()->Run();
+  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));
 
   // If the response is dangerous the result should also be marked as dangerous.
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
   EXPECT_FALSE(DownloadFeedbackService::GetPingsForDownloadForTesting(
       item, &feedback_ping, &feedback_response));
 
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 
   // 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)));
-  MessageLoop::current()->Run();
+  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();
 
   // 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);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  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();
 
   // 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)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_TRUE(IsResult(DownloadProtectionService::POTENTIALLY_UNWANTED));
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadHTTPS) {
   net::FakeURLFetcherFactory factory(NULL);
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
@@ skipping 13 matching lines @@
       .Times(1);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(1);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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,
@@ skipping 13 matching lines @@
       .Times(1);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(1);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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 14 matching lines @@
       .Times(1);
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
       .Times(1);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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 37 matching lines @@
   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)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
   EXPECT_FALSE(HasClientDownloadRequest());
   Mock::VerifyAndClearExpectations(sb_service_.get());
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
 
   // 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));
 
   EXPECT_CALL(*sb_service_->mock_database_manager(),
               MatchDownloadWhitelistUrl(_))
       .WillRepeatedly(Return(false));
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   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());
 
   // If the response is dangerous the result should also be marked as
   // dangerous.
   PrepareResponse(
       &factory, ClientDownloadResponse::DANGEROUS, net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
 
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
   Mock::VerifyAndClearExpectations(binary_feature_extractor_.get());
 
   // 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));
 
   download_service_->CheckClientDownload(
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   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());
 
   // 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));
 
   download_service_->CheckClientDownload(
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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());
 }
 
@@ skipping 40 matching lines @@
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(
                   tmp_path_, BinaryFeatureExtractor::kDefaultOptions, _, _))
               .Times(1);
 
   EXPECT_FALSE(download_service_->IsSupportedDownload(item, final_path_));
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
 }
 
 TEST_F(DownloadProtectionServiceTest, CheckClientDownloadValidateRequest) {
   net::TestURLFetcherFactory factory;
 
   content::MockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
     {"http://www.google.com/",
@@ skipping 52 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));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 }
 
 // Similar to above, but with an unsigned binary.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestNoSignature) {
   net::TestURLFetcherFactory factory;
 
   content::MockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
@@ skipping 39 matching lines @@
                                       "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));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 }
 
 // Similar to above, but with tab history.
 TEST_F(DownloadProtectionServiceTest,
        CheckClientDownloadValidateRequestTabHistory) {
   net::TestURLFetcherFactory factory;
 
   content::MockDownloadItem item;
   PrepareBasicDownloadItem(
     &item,
@@ skipping 67 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));
-    MessageLoop::current()->Run();
+    base::RunLoop().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)
@@ skipping 51 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));
-    MessageLoop::current()->Run();
+    base::RunLoop().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)));
-  MessageLoop::current()->Run();
+  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)));
   download_service_->CheckDownloadUrl(
       item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  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)));
   download_service_->CheckDownloadUrl(
       item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  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_BINARY_MALWARE_URL),
           Return(false)));
   download_service_->CheckDownloadUrl(
       item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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
@@ skipping 11 matching lines @@
                                    _, _));
 
   download_service_->download_request_timeout_ms_ = 10;
   download_service_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
   // The request should time out because the HTTP request hasn't returned
   // anything yet.
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
   EXPECT_TRUE(IsResult(DownloadProtectionService::UNKNOWN));
   EXPECT_TRUE(HasClientDownloadRequest());
   ClearClientDownloadRequest();
 }
 
 TEST_F(DownloadProtectionServiceTest, TestDownloadItemDestroyed) {
   {
     content::MockDownloadItem item;
     PrepareBasicDownloadItem(
       &item,
@@ skipping 47 matching lines @@
   EXPECT_CALL(*binary_feature_extractor_.get(),
               ExtractImageFeatures(tmp_path_,
                                    BinaryFeatureExtractor::kDefaultOptions,
                                    _, _));
 
   download_service_->CheckClientDownload(
       item.get(),
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
 
-  MessageLoop::current()->Run();
+  base::RunLoop().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 155 matching lines @@
   };
 
   for (const auto& test_case : kExpectedResults) {
     factory.ClearFakeResponses();
     PrepareResponse(&factory, test_case.verdict, net::HTTP_OK,
                     net::URLRequestStatus::SUCCESS);
     download_service_->CheckPPAPIDownloadRequest(
         GURL("http://example.com/foo"), default_file_path, alternate_extensions,
         base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                    base::Unretained(this)));
-    MessageLoop::current()->Run();
+    base::RunLoop().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));
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 TEST_F(DownloadProtectionServiceTest, PPAPIDownloadRequest_WhitelistedURL) {
   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(true));
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_TRUE(IsResult(DownloadProtectionService::SAFE));
 }
 
 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));
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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));
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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;
   download_service_->CheckPPAPIDownloadRequest(
       GURL("http://example.com/foo"), default_file_path, alternate_extensions,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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 39 matching lines @@
   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");
   download_service_->CheckPPAPIDownloadRequest(
       kRequestorUrl, default_file_path, alternate_extensions,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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 42 matching lines @@
       .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_->CheckClientDownload(
       &item,
       base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                  base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().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));
 
   download_service_->CheckClientDownload(
       &item, base::Bind(&DownloadProtectionServiceTest::CheckDoneCallback,
                         base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   EXPECT_FALSE(HasClientDownloadRequest());
   // Overriden by flag:
   EXPECT_TRUE(IsResult(DownloadProtectionService::DANGEROUS));
 }
 
 }  // namespace safe_browsing