Remove MessageLoop::current()->RunUntilIdle() in components.

components/precache/content/precache_manager_unittest.cc

 // Copyright 2013 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 "components/precache/content/precache_manager.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 142 matching lines @@
       : factory_(nullptr,
                  base::Bind(&TestURLFetcherCallback::CreateURLFetcher,
                             base::Unretained(&url_callback_))) {}
 
   ~PrecacheManagerTest() {
     // precache_manager_'s constructor releases a PrecacheDatabase and deletes
     // it on the DB thread. PrecacheDatabase already has a pending Init call
     // which will assert in debug builds because the directory passed to it is
     // deleted. So manually ensure that the task is run before browser_context_
     // is destructed.
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
  protected:
   void SetUp() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kPrecacheConfigSettingsURL, kConfigURL);
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kPrecacheManifestURLPrefix, kManifestURLPrefix);
     std::unique_ptr<PrecacheDatabase> precache_database(
         new PrecacheDatabase());
     precache_database_ = precache_database.get();
 
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     base::FilePath db_path = scoped_temp_dir_.path().Append(
         base::FilePath(FILE_PATH_LITERAL("precache_database")));
 
     // Make the fetch of the precache configuration settings fail. Precaching
     // should still complete normally in this case.
     factory_.SetFakeResponse(GURL(kConfigURL), "",
                              net::HTTP_INTERNAL_SERVER_ERROR,
                              net::URLRequestStatus::FAILED);
     precache_manager_.reset(
         new PrecacheManagerUnderTest(
             &browser_context_, nullptr /* sync_service */,
             &history_service_, db_path, std::move(precache_database)));
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   // Must be declared first so that it is destroyed last.
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
   base::ScopedTempDir scoped_temp_dir_;
   PrecacheDatabase* precache_database_;
   content::TestBrowserContext browser_context_;
   std::unique_ptr<PrecacheManagerUnderTest> precache_manager_;
   TestURLFetcherCallback url_callback_;
   net::FakeURLFetcherFactory factory_;
   TestPrecacheCompletionCallback precache_callback_;
   testing::NiceMock<MockHistoryService> history_service_;
   base::HistogramTester histograms_;
 };
 
 TEST_F(PrecacheManagerTest, StartAndFinishPrecaching) {
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   MockHistoryService::TopHostsCallback top_hosts_callback;
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .WillOnce(SaveArg<1>(&top_hosts_callback));
 
   factory_.SetFakeResponse(GURL(kGoodManifestURL), "", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(precache_manager_->IsPrecaching());
 
   top_hosts_callback.Run(
       history::TopHostsList(1, std::make_pair("good-manifest.com", 1)));
-  base::MessageLoop::current()->RunUntilIdle();  // For PrecacheFetcher.
+  base::RunLoop().RunUntilIdle();  // For PrecacheFetcher.
   EXPECT_FALSE(precache_manager_->IsPrecaching());
   EXPECT_TRUE(precache_callback_.was_on_done_called());
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 }
 
 TEST_F(PrecacheManagerTest, StartAndFinishPrecachingWithUnfinishedHosts) {
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("evil-manifest.com");
   unfinished_work->set_start_time(base::Time::Now().ToInternalValue());
   precache_database_->SaveUnfinishedWork(std::move(unfinished_work));
 
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   factory_.SetFakeResponse(
       GURL(kEvilManifestURL), "",
       net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   EXPECT_TRUE(precache_manager_->IsPrecaching());
 
-  base::MessageLoop::current()->RunUntilIdle();  // For PrecacheFetcher.
+  base::RunLoop().RunUntilIdle();  // For PrecacheFetcher.
   EXPECT_FALSE(precache_manager_->IsPrecaching());
   EXPECT_TRUE(precache_callback_.was_on_done_called());
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kEvilManifestURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 }
 
 TEST_F(PrecacheManagerTest,
        StartAndCancelPrecachingBeforeUnfinishedWorkRetrieved) {
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   EXPECT_TRUE(precache_manager_->IsPrecaching());
   precache_manager_->CancelPrecaching();
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(precache_callback_.was_on_done_called());
 }
 
 TEST_F(PrecacheManagerTest, StartAndCancelPrecachingBeforeTopHostsCompleted) {
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   MockHistoryService::TopHostsCallback top_hosts_callback;
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .WillOnce(SaveArg<1>(&top_hosts_callback));
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   EXPECT_TRUE(precache_manager_->IsPrecaching());
 
   precache_manager_->CancelPrecaching();
   EXPECT_FALSE(precache_manager_->IsPrecaching());
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   top_hosts_callback.Run(
       history::TopHostsList(1, std::make_pair("starting-url.com", 1)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(precache_manager_->IsPrecaching());
   EXPECT_FALSE(precache_callback_.was_on_done_called());
 }
 
 TEST_F(PrecacheManagerTest, StartAndCancelPrecachingBeforeURLsReceived) {
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   MockHistoryService::TopHostsCallback top_hosts_callback;
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .WillOnce(SaveArg<1>(&top_hosts_callback));
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   EXPECT_TRUE(precache_manager_->IsPrecaching());
 
   precache_manager_->CancelPrecaching();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(precache_manager_->IsPrecaching());
   top_hosts_callback.Run(
       history::TopHostsList(1, std::make_pair("starting-url.com", 1)));
-  base::MessageLoop::current()->RunUntilIdle();  // For PrecacheFetcher.
+  base::RunLoop().RunUntilIdle();  // For PrecacheFetcher.
   EXPECT_FALSE(precache_manager_->IsPrecaching());
   EXPECT_FALSE(precache_callback_.was_on_done_called());
   EXPECT_TRUE(url_callback_.requested_urls().empty());
 }
 
 TEST_F(PrecacheManagerTest, StartAndCancelPrecachingAfterURLsReceived) {
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   PrecacheManifest good_manifest;
   good_manifest.add_resource()->set_url("http://good-resource.com");
 
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .WillOnce(ReturnHosts(
           history::TopHostsList(1, std::make_pair("starting-url.com", 1))));
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
 
   EXPECT_TRUE(precache_manager_->IsPrecaching());
   // Run a task to get unfinished work, and to get hosts.
   for (int i = 0; i < 2; ++i) {
     base::RunLoop run_loop;
     base::MessageLoop::current()->PostTask(FROM_HERE, run_loop.QuitClosure());
     run_loop.Run();
   }
-  //base::MessageLoop::current()->RunUntilIdle();
+  // base::RunLoop().RunUntilIdle();
   precache_manager_->CancelPrecaching();
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
-  base::MessageLoop::current()->RunUntilIdle();  // For PrecacheFetcher.
+  base::RunLoop().RunUntilIdle();  // For PrecacheFetcher.
   EXPECT_FALSE(precache_manager_->IsPrecaching());
   EXPECT_FALSE(precache_callback_.was_on_done_called());
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchWithSizeZero) {
   // Fetches with size 0 should be ignored.
   precache_manager_->RecordStatsForFetch(GURL("http://url.com"), GURL(),
                                         base::TimeDelta(), base::Time(), 0,
                                         false);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."), IsEmpty());
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchWithNonHTTP) {
   // Fetches for URLs with schemes other than HTTP or HTTPS should be ignored.
   precache_manager_->RecordStatsForFetch(GURL("ftp://ftp.com"), GURL(),
                                         base::TimeDelta(), base::Time(), 1000,
                                         false);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."), IsEmpty());
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchWithEmptyURL) {
   // Fetches for empty URLs should be ignored.
   precache_manager_->RecordStatsForFetch(GURL(), GURL(), base::TimeDelta(),
                                         base::Time(), 1000, false);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."), IsEmpty());
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchDuringPrecaching) {
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .WillOnce(ReturnHosts(history::TopHostsList()));
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
 
   EXPECT_TRUE(precache_manager_->IsPrecaching());
   precache_manager_->RecordStatsForFetch(GURL("http://url.com"), GURL(),
                                         base::TimeDelta(), base::Time(), 1000,
                                         false);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   precache_manager_->CancelPrecaching();
 
   // For PrecacheFetcher and RecordURLPrecached.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ElementsAre(Pair("Precache.DownloadedPrecacheMotivated", 1),
                           Pair("Precache.Fetch.PercentCompleted", 1),
                           Pair("Precache.Fetch.ResponseBytes.Network", 1),
                           Pair("Precache.Fetch.ResponseBytes.Total", 1),
                           Pair("Precache.Fetch.TimeToComplete", 1),
                           Pair("Precache.Latency.Prefetch", 1)));
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchHTTP) {
   precache_manager_->RecordStatsForFetch(GURL("http://http-url.com"), GURL(),
                                         base::TimeDelta(), base::Time(), 1000,
                                         false);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ElementsAre(Pair("Precache.DownloadedNonPrecache", 1),
                           Pair("Precache.Latency.NonPrefetch", 1),
                           Pair("Precache.Latency.NonPrefetch.NonTopHosts", 1)));
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchHTTPS) {
   precache_manager_->RecordStatsForFetch(GURL("https://https-url.com"), GURL(),
                                         base::TimeDelta(), base::Time(), 1000,
                                         false);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ElementsAre(Pair("Precache.DownloadedNonPrecache", 1),
                           Pair("Precache.Latency.NonPrefetch", 1),
                           Pair("Precache.Latency.NonPrefetch.NonTopHosts", 1)));
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchInTopHosts) {
   EXPECT_CALL(history_service_,
               HostRankIfAvailable(GURL("http://referrer.com"), _))
       .WillOnce(Invoke(
           [](const GURL& url, const base::Callback<void(int)>& callback) {
             callback.Run(0);
           }));
   precache_manager_->RecordStatsForFetch(
       GURL("http://http-url.com"), GURL("http://referrer.com"),
       base::TimeDelta(), base::Time(), 1000, false);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ElementsAre(Pair("Precache.DownloadedNonPrecache", 1),
                           Pair("Precache.Latency.NonPrefetch", 1),
                           Pair("Precache.Latency.NonPrefetch.TopHosts", 1)));
 }
 
 TEST_F(PrecacheManagerTest, DeleteExpiredPrecacheHistory) {
   // TODO(twifkak): Split this into multiple tests.
   base::HistogramTester::CountsMap expected_histogram_count_map;
@@ skipping 16 matching lines @@
       kCurrentTime - base::TimeDelta::FromDays(59), 1000, false);
   precache_manager_->RecordStatsForFetch(
       GURL("http://yesterday-fetch.com"), GURL(), base::TimeDelta(),
       kCurrentTime - base::TimeDelta::FromDays(1), 1000, false);
   expected_histogram_count_map["Precache.DownloadedPrecacheMotivated"] += 3;
   expected_histogram_count_map["Precache.Fetch.PercentCompleted"]++;
   expected_histogram_count_map["Precache.Fetch.ResponseBytes.Network"]++;
   expected_histogram_count_map["Precache.Fetch.ResponseBytes.Total"]++;
   expected_histogram_count_map["Precache.Fetch.TimeToComplete"]++;
   expected_histogram_count_map["Precache.Latency.Prefetch"] += 3;
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   precache_manager_->CancelPrecaching();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Disable pause-resume.
   precache_database_->DeleteUnfinishedWork();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // For PrecacheFetcher and RecordURLPrecached.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ContainerEq(expected_histogram_count_map));
 
   // The expired precache will be deleted during precaching this time.
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   EXPECT_TRUE(precache_manager_->IsPrecaching());
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // The precache fetcher runs until done, which records these histograms,
   // and then cancels precaching, which records these histograms again.
   // In practice
   expected_histogram_count_map["Precache.Fetch.PercentCompleted"]++;
   expected_histogram_count_map["Precache.Fetch.ResponseBytes.Network"]++;
   expected_histogram_count_map["Precache.Fetch.ResponseBytes.Total"]++;
   // For PrecacheFetcher and RecordURLPrecached.
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   // A fetch for the same URL as the expired precache was served from the cache,
   // but it isn't reported as saved bytes because it had expired in the precache
   // history.
   precache_manager_->RecordStatsForFetch(GURL("http://old-fetch.com"), GURL(),
                                         base::TimeDelta(), kCurrentTime, 1000,
                                         true);
   expected_histogram_count_map["Precache.Fetch.TimeToComplete"]++;
   expected_histogram_count_map["Precache.Latency.NonPrefetch"]++;
   expected_histogram_count_map["Precache.Latency.NonPrefetch.NonTopHosts"]++;
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ContainerEq(expected_histogram_count_map));
 
   // The other precaches should not have expired, so the following fetches from
   // the cache should count as saved bytes.
   precache_manager_->RecordStatsForFetch(GURL("http://recent-fetch.com"), GURL(),
                                         base::TimeDelta(), kCurrentTime, 1000,
                                         true);
   precache_manager_->RecordStatsForFetch(GURL("http://yesterday-fetch.com"),
                                         GURL(), base::TimeDelta(), kCurrentTime,
                                         1000, true);
   expected_histogram_count_map["Precache.Latency.NonPrefetch"] += 2;
   expected_histogram_count_map["Precache.Latency.NonPrefetch.NonTopHosts"] += 2;
   expected_histogram_count_map["Precache.Saved"] += 2;
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ContainerEq(expected_histogram_count_map));
 }
 
 }  // namespace
 
 }  // namespace precache