Don't use base::MessageLoop::{Quit,QuitClosure} in components/

components/history/core/browser/history_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.
 
 // History unit tests come in two flavors:
 //
 // 1. The more complicated style is that the unit test creates a full history
 //    service. This spawns a background thread for the history backend, and
 //    all communication is asynchronous. This is useful for testing more
 //    complicated things or end-to-end behavior.
@@ skipping 35 matching lines @@
 namespace history {
 
 class HistoryServiceTest : public testing::Test {
  public:
   HistoryServiceTest() : query_url_success_(false) {}
 
   ~HistoryServiceTest() override {}
 
   void OnMostVisitedURLsAvailable(const MostVisitedURLList* url_list) {
     most_visited_urls_ = *url_list;
-    base::MessageLoop::current()->Quit();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
  protected:
   friend class BackendDelegate;
 
   // testing::Test
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     history_dir_ = temp_dir_.path().AppendASCII("HistoryServiceTest");
     ASSERT_TRUE(base::CreateDirectory(history_dir_));
     history_service_.reset(new history::HistoryService);
     if (!history_service_->Init(
             std::string(), TestHistoryDatabaseParamsForPath(history_dir_))) {
       history_service_.reset();
       ADD_FAILURE();
     }
   }
 
   void TearDown() override {
     if (history_service_)
       CleanupHistoryService();
 
     // Make sure we don't have any event pending that could disrupt the next
     // test.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::MessageLoop::QuitClosure());
+        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     base::MessageLoop::current()->Run();
   }
 
   void CleanupHistoryService() {
     DCHECK(history_service_);
 
     history_service_->ClearCachedDataForContextID(0);
-    history_service_->SetOnBackendDestroyTask(base::MessageLoop::QuitClosure());
+    history_service_->SetOnBackendDestroyTask(
+        base::MessageLoop::QuitWhenIdleClosure());
     history_service_->Cleanup();
     history_service_.reset();
 
     // Wait for the backend class to terminate before deleting the files and
     // moving to the next test. Note: if this never terminates, somebody is
     // probably leaking a reference to the history backend, so it never calls
     // our destroy task.
     base::MessageLoop::current()->Run();
   }
 
@@ skipping 15 matching lines @@
                       const URLRow& url_row,
                       const VisitVector& visits) {
     query_url_success_ = success;
     if (query_url_success_) {
       query_url_row_ = url_row;
       query_url_visits_ = visits;
     } else {
       query_url_row_ = URLRow();
       query_url_visits_.clear();
     }
-    base::MessageLoop::current()->Quit();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
   // Fills in saved_redirects_ with the redirect information for the given URL,
   // returning true on success. False means the URL was not found.
   void QueryRedirectsFrom(history::HistoryService* history, const GURL& url) {
     history_service_->QueryRedirectsFrom(
         url,
         base::Bind(&HistoryServiceTest::OnRedirectQueryComplete,
                    base::Unretained(this)),
         &tracker_);
     base::MessageLoop::current()->Run();  // Will be exited in *QueryComplete.
   }
 
   // Callback for QueryRedirects.
   void OnRedirectQueryComplete(const history::RedirectList* redirects) {
     saved_redirects_.clear();
     if (!redirects->empty()) {
       saved_redirects_.insert(
           saved_redirects_.end(), redirects->begin(), redirects->end());
     }
-    base::MessageLoop::current()->Quit();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
   base::ScopedTempDir temp_dir_;
 
   base::MessageLoopForUI message_loop_;
 
   MostVisitedURLList most_visited_urls_;
 
   // When non-NULL, this will be deleted on tear down and we will block until
   // the backend thread has completed. This allows tests for the history
@@ skipping 402 matching lines @@
 
   HistoryDBTaskImpl(int* invoke_count, bool* done_invoked)
       : invoke_count_(invoke_count), done_invoked_(done_invoked) {}
 
   bool RunOnDBThread(HistoryBackend* backend, HistoryDatabase* db) override {
     return (++*invoke_count_ == kWantInvokeCount);
   }
 
   void DoneRunOnMainThread() override {
     *done_invoked_ = true;
-    base::MessageLoop::current()->Quit();
+    base::MessageLoop::current()->QuitWhenIdle();
   }
 
   int* invoke_count_;
   bool* done_invoked_;
 
  private:
   ~HistoryDBTaskImpl() override {}
 
   DISALLOW_COPY_AND_ASSIGN(HistoryDBTaskImpl);
 };
@@ skipping 272 matching lines @@
   // Expect two sync changes for deleting processed directives.
   const syncer::SyncChangeList& sync_changes = change_processor.changes();
   ASSERT_EQ(2u, sync_changes.size());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[0].change_type());
   EXPECT_EQ(1, syncer::SyncDataRemote(sync_changes[0].sync_data()).GetId());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[1].change_type());
   EXPECT_EQ(2, syncer::SyncDataRemote(sync_changes[1].sync_data()).GetId());
 }
 
 }  // namespace history