chrome: Use base::MessageLoop. (Part 3)

chrome/browser/history/history_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 138 matching lines @@
       backend_->Closing();
       backend_ = NULL;
     }
   }
 
   virtual void TearDown() {
     DeleteBackend();
 
     // Make sure we don't have any event pending that could disrupt the next
     // test.
-    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
+    base::MessageLoop::current()->Run();
   }
 
   int64 AddDownload(DownloadItem::DownloadState state, const Time& time) {
     std::vector<GURL> url_chain;
     url_chain.push_back(GURL("foo-url"));
 
     DownloadRow download(base::FilePath(FILE_PATH_LITERAL("foo-path")),
                          base::FilePath(FILE_PATH_LITERAL("foo-path")),
                          url_chain,
                          GURL(std::string()),
                          time,
                          time,
                          0,
                          512,
                          state,
                          content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                          content::DOWNLOAD_INTERRUPT_REASON_NONE,
                          0,
                          0);
     return db_->CreateDownload(download);
   }
 
   base::ScopedTempDir temp_dir_;
 
-  MessageLoopForUI message_loop_;
+  base::MessageLoopForUI message_loop_;
 
   // names of the database files
   base::FilePath history_dir_;
 
   // Created via CreateBackendAndDatabase.
   scoped_refptr<HistoryBackend> backend_;
   scoped_ptr<InMemoryHistoryBackend> in_mem_backend_;
   HistoryDatabase* db_;  // Cached reference to the backend's database.
 };
 
@@ skipping 348 matching lines @@
   CreateBackendAndDatabase();
   std::vector<DownloadRow> results;
   db_->QueryDownloads(&results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(content::DownloadItem::INTERRUPTED, results[0].state);
   EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_CRASH,
             results[0].interrupt_reason);
 
   // Allow the update to propagate, shut down the DB, and confirm that
   // the query updated the on disk database as well.
-  MessageLoop::current()->RunUntilIdle();
+  base::MessageLoop::current()->RunUntilIdle();
   DeleteBackend();
   {
     sql::Connection db;
     ASSERT_TRUE(db.Open(history_dir_.Append(chrome::kHistoryFilename)));
     sql::Statement statement(db.GetUniqueStatement(
         "Select Count(*) from downloads"));
     EXPECT_TRUE(statement.Step());
     EXPECT_EQ(1, statement.ColumnInt(0));
 
     sql::Statement statement1(db.GetUniqueStatement(
@@ skipping 111 matching lines @@
         redirect_query_success_(false),
         query_url_success_(false) {
   }
 
   virtual ~HistoryTest() {
   }
 
   void OnSegmentUsageAvailable(CancelableRequestProvider::Handle handle,
                                std::vector<PageUsageData*>* data) {
     page_usage_data_.swap(*data);
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   void OnDeleteURLsDone(CancelableRequestProvider::Handle handle) {
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   void OnMostVisitedURLsAvailable(CancelableRequestProvider::Handle handle,
                                   MostVisitedURLList url_list) {
     most_visited_urls_.swap(url_list);
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
  protected:
   friend class BackendDelegate;
 
   // testing::Test
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     history_dir_ = temp_dir_.path().AppendASCII("HistoryTest");
     ASSERT_TRUE(file_util::CreateDirectory(history_dir_));
     history_service_.reset(new HistoryService);
     if (!history_service_->Init(history_dir_, NULL)) {
       history_service_.reset();
       ADD_FAILURE();
     }
   }
 
   virtual void TearDown() {
     if (history_service_.get())
       CleanupHistoryService();
 
     // Make sure we don't have any event pending that could disrupt the next
     // test.
-    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::MessageLoop::QuitClosure());
+    base::MessageLoop::current()->Run();
   }
 
   void CleanupHistoryService() {
     DCHECK(history_service_.get());
 
     history_service_->NotifyRenderProcessHostDestruction(0);
-    history_service_->SetOnBackendDestroyTask(MessageLoop::QuitClosure());
+    history_service_->SetOnBackendDestroyTask(base::MessageLoop::QuitClosure());
     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.
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
   }
 
   // Fills the query_url_row_ and query_url_visits_ structures with the
   // information about the given URL and returns true. If the URL was not
   // found, this will return false and those structures will not be changed.
   bool QueryURL(HistoryService* history, const GURL& url) {
     history_service_->QueryURL(url, true, &consumer_,
                                base::Bind(&HistoryTest::SaveURLAndQuit,
                                           base::Unretained(this)));
-    MessageLoop::current()->Run();  // Will be exited in SaveURLAndQuit.
+    base::MessageLoop::current()->Run();  // Will be exited in SaveURLAndQuit.
     return query_url_success_;
   }
 
   // Callback for HistoryService::QueryURL.
   void SaveURLAndQuit(HistoryService::Handle handle,
                       bool success,
                       const URLRow* url_row,
                       VisitVector* visit_vector) {
     query_url_success_ = success;
     if (query_url_success_) {
       query_url_row_ = *url_row;
       query_url_visits_.swap(*visit_vector);
     } else {
       query_url_row_ = URLRow();
       query_url_visits_.clear();
     }
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   // Fills in saved_redirects_ with the redirect information for the given URL,
   // returning true on success. False means the URL was not found.
   bool QueryRedirectsFrom(HistoryService* history, const GURL& url) {
     history_service_->QueryRedirectsFrom(
         url, &consumer_,
         base::Bind(&HistoryTest::OnRedirectQueryComplete,
                    base::Unretained(this)));
-    MessageLoop::current()->Run();  // Will be exited in *QueryComplete.
+    base::MessageLoop::current()->Run();  // Will be exited in *QueryComplete.
     return redirect_query_success_;
   }
 
   // Callback for QueryRedirects.
   void OnRedirectQueryComplete(HistoryService::Handle handle,
                                GURL url,
                                bool success,
                                history::RedirectList* redirects) {
     redirect_query_success_ = success;
     if (redirect_query_success_)
       saved_redirects_.swap(*redirects);
     else
       saved_redirects_.clear();
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   base::ScopedTempDir temp_dir_;
 
-  MessageLoopForUI message_loop_;
+  base::MessageLoopForUI message_loop_;
 
   // PageUsageData vector to test segments.
   ScopedVector<PageUsageData> page_usage_data_;
 
   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
   // service to use this feature, but other tests to ignore this.
   scoped_ptr<HistoryService> history_service_;
@@ skipping 294 matching lines @@
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
 
   // Make sure a segment was created.
   history_service_->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
   EXPECT_DOUBLE_EQ(3.0, page_usage_data_[0]->GetScore());
 
   // Add a URL which doesn't create a segment.
   const GURL link_url("http://yahoo.com/");
   history_service_->AddPage(
       link_url, base::Time::Now(), scope, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_LINK,
       history::SOURCE_BROWSED, false);
 
   // Query again
   history_service_->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   // Make sure we still have one segment.
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
 
   // Add a page linked from existing_url.
   history_service_->AddPage(
       GURL("http://www.google.com/foo"), base::Time::Now(),
       scope, 3, existing_url, history::RedirectList(),
       content::PAGE_TRANSITION_LINK, history::SOURCE_BROWSED,
       false);
 
   // Query again
   history_service_->QuerySegmentUsageSince(
       &consumer_, Time::Now() - TimeDelta::FromDays(1), 10,
       base::Bind(&HistoryTest::OnSegmentUsageAvailable,
                  base::Unretained(this)));
 
   // Wait for processing.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   // Make sure we still have one segment.
   ASSERT_EQ(1U, page_usage_data_.size());
   EXPECT_TRUE(page_usage_data_[0]->GetURL() == existing_url);
 
   // However, the score should have increased.
   EXPECT_GT(page_usage_data_[0]->GetScore(), 5.0);
 }
 
 TEST_F(HistoryTest, MostVisitedURLs) {
@@ skipping 14 matching lines @@
       history::SOURCE_BROWSED, false);
   history_service_->AddPage(
       url1, base::Time::Now(), scope, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_EQ(2U, most_visited_urls_.size());
   EXPECT_EQ(url0, most_visited_urls_[0].url);
   EXPECT_EQ(url1, most_visited_urls_[1].url);
 
   // Add another page.
   history_service_->AddPage(
       url2, base::Time::Now(), scope, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url0, most_visited_urls_[0].url);
   EXPECT_EQ(url1, most_visited_urls_[1].url);
   EXPECT_EQ(url2, most_visited_urls_[2].url);
 
   // Revisit url2, making it the top URL.
   history_service_->AddPage(
       url2, base::Time::Now(), scope, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url2, most_visited_urls_[0].url);
   EXPECT_EQ(url0, most_visited_urls_[1].url);
   EXPECT_EQ(url1, most_visited_urls_[2].url);
 
   // Revisit url1, making it the top URL.
   history_service_->AddPage(
       url1, base::Time::Now(), scope, 0, GURL(),
       history::RedirectList(), content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_EQ(3U, most_visited_urls_.size());
   EXPECT_EQ(url1, most_visited_urls_[0].url);
   EXPECT_EQ(url2, most_visited_urls_[1].url);
   EXPECT_EQ(url0, most_visited_urls_[2].url);
 
   // Redirects
   history::RedirectList redirects;
   redirects.push_back(url3);
   redirects.push_back(url4);
 
   // Visit url4 using redirects.
   history_service_->AddPage(
       url4, base::Time::Now(), scope, 0, GURL(),
       redirects, content::PAGE_TRANSITION_TYPED,
       history::SOURCE_BROWSED, false);
   history_service_->QueryMostVisitedURLs(
       20, 90, &consumer_,
       base::Bind(
           &HistoryTest::OnMostVisitedURLsAvailable,
           base::Unretained(this)));
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
 
   EXPECT_EQ(4U, most_visited_urls_.size());
   EXPECT_EQ(url1, most_visited_urls_[0].url);
   EXPECT_EQ(url2, most_visited_urls_[1].url);
   EXPECT_EQ(url0, most_visited_urls_[2].url);
   EXPECT_EQ(url3, most_visited_urls_[3].url);
   EXPECT_EQ(2U, most_visited_urls_[3].redirects.size());
 }
 
 // The version of the history database should be current in the "typical
@@ skipping 37 matching lines @@
 
   HistoryDBTaskImpl() : invoke_count(0), done_invoked(false) {}
 
   virtual bool RunOnDBThread(HistoryBackend* backend,
                              HistoryDatabase* db) OVERRIDE {
     return (++invoke_count == kWantInvokeCount);
   }
 
   virtual void DoneRunOnMainThread() OVERRIDE {
     done_invoked = true;
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   int invoke_count;
   bool done_invoked;
 
  private:
   virtual ~HistoryDBTaskImpl() {}
 
   DISALLOW_COPY_AND_ASSIGN(HistoryDBTaskImpl);
 };
 
 // static
 const int HistoryDBTaskImpl::kWantInvokeCount = 2;
 
 }  // namespace
 
 TEST_F(HistoryTest, HistoryDBTask) {
   ASSERT_TRUE(history_service_.get());
   CancelableRequestConsumerT<int, 0> request_consumer;
   scoped_refptr<HistoryDBTaskImpl> task(new HistoryDBTaskImpl());
   history_service_->ScheduleDBTask(task.get(), &request_consumer);
   // Run the message loop. When HistoryDBTaskImpl::DoneRunOnMainThread runs,
   // it will stop the message loop. If the test hangs here, it means
   // DoneRunOnMainThread isn't being invoked correctly.
-  MessageLoop::current()->Run();
+  base::MessageLoop::current()->Run();
   CleanupHistoryService();
   // WARNING: history has now been deleted.
   history_service_.reset();
   ASSERT_EQ(HistoryDBTaskImpl::kWantInvokeCount, task->invoke_count);
   ASSERT_TRUE(task->done_invoked);
 }
 
 TEST_F(HistoryTest, HistoryDBTaskCanceled) {
   ASSERT_TRUE(history_service_.get());
   CancelableRequestConsumerT<int, 0> request_consumer;
@@ skipping 111 matching lines @@
 // of sync changes.
 void CheckDirectiveProcessingResult(
     Time timeout, const TestChangeProcessor* change_processor,
     uint32 num_changes) {
   if (base::Time::Now() > timeout ||
       change_processor->GetChanges().size() >= num_changes) {
     return;
   }
 
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&CheckDirectiveProcessingResult, timeout,
-                 change_processor, num_changes));
+      base::Bind(&CheckDirectiveProcessingResult,
+                 timeout,
+                 change_processor,
+                 num_changes));
 }
 
 // Create a delete directive for a few specific history entries,
 // including ones that don't exist. The expected entries should be
 // deleted.
 TEST_F(HistoryTest, ProcessGlobalIdDeleteDirective) {
   ASSERT_TRUE(history_service_.get());
   const GURL test_url("http://www.google.com/");
   for (int64 i = 1; i <= 20; i++) {
     base::Time t =
@@ skipping 35 matching lines @@
   EXPECT_FALSE(
       history_service_->MergeDataAndStartSyncing(
           syncer::HISTORY_DELETE_DIRECTIVES,
           directives,
           scoped_ptr<syncer::SyncChangeProcessor>(
               new SyncChangeProcessorDelegate(&change_processor)),
           scoped_ptr<syncer::SyncErrorFactory>()).error().IsSet());
 
   // Inject a task to check status and keep message loop filled before directive
   // processing finishes.
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&CheckDirectiveProcessingResult,
                  base::Time::Now() + base::TimeDelta::FromSeconds(10),
-                 &change_processor, 2));
-  MessageLoop::current()->RunUntilIdle();
+                 &change_processor,
+                 2));
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   ASSERT_EQ(5, query_url_row_.visit_count());
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1),
             query_url_visits_[0].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(2),
             query_url_visits_[1].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(11),
             query_url_visits_[2].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(12),
             query_url_visits_[3].visit_time);
@@ skipping 46 matching lines @@
   EXPECT_FALSE(
       history_service_->MergeDataAndStartSyncing(
           syncer::HISTORY_DELETE_DIRECTIVES,
           directives,
           scoped_ptr<syncer::SyncChangeProcessor>(
               new SyncChangeProcessorDelegate(&change_processor)),
           scoped_ptr<syncer::SyncErrorFactory>()).error().IsSet());
 
   // Inject a task to check status and keep message loop filled before
   // directive processing finishes.
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&CheckDirectiveProcessingResult,
                  base::Time::Now() + base::TimeDelta::FromSeconds(10),
-                 &change_processor, 2));
-  MessageLoop::current()->RunUntilIdle();
+                 &change_processor,
+                 2));
+  base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   ASSERT_EQ(3, query_url_row_.visit_count());
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1),
             query_url_visits_[0].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(6),
             query_url_visits_[1].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(7),
             query_url_visits_[2].visit_time);
 
   // Expect two sync changes for deleting processed directives.
@@ skipping 68 matching lines @@
   std::vector<PageUsageData*> results;
   db_->QuerySegmentUsage(segment_time, 10, &results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(url, results[0]->GetURL());
   EXPECT_EQ(segment_id, results[0]->GetID());
   EXPECT_EQ(title, results[0]->GetTitle());
   STLDeleteElements(&results);
 }
 
 }  // namespace history