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

chrome/browser/history/top_sites_likely_impl_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 41 matching lines @@
 class WaitForHistoryTask : public HistoryDBTask {
  public:
   WaitForHistoryTask() {}
 
   virtual bool RunOnDBThread(HistoryBackend* backend,
                              HistoryDatabase* db) OVERRIDE {
     return true;
   }
 
   virtual void DoneRunOnMainThread() OVERRIDE {
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
  private:
   virtual ~WaitForHistoryTask() {}
 
   DISALLOW_COPY_AND_ASSIGN(WaitForHistoryTask);
 };
 
 // Used for querying top sites. Either runs sequentially, or runs a nested
 // nested message loop until the response is complete. The later is used when
 // TopSites is queried before it finishes loading.
 class TopSitesQuerier {
  public:
   TopSitesQuerier()
       : weak_ptr_factory_(this),
         number_of_callbacks_(0),
         waiting_(false) {}
 
   // Queries top sites. If |wait| is true a nested message loop is run until the
   // callback is notified.
   void QueryTopSites(TopSitesLikelyImpl* top_sites, bool wait) {
     int start_number_of_callbacks = number_of_callbacks_;
     top_sites->GetMostVisitedURLs(
         base::Bind(&TopSitesQuerier::OnTopSitesAvailable,
                    weak_ptr_factory_.GetWeakPtr()));
     if (wait && start_number_of_callbacks == number_of_callbacks_) {
       waiting_ = true;
-      MessageLoop::current()->Run();
+      base::MessageLoop::current()->Run();
     }
   }
 
   void CancelRequest() {
     weak_ptr_factory_.InvalidateWeakPtrs();
   }
 
   void set_urls(const MostVisitedURLList& urls) { urls_ = urls; }
   const MostVisitedURLList& urls() const { return urls_; }
 
   int number_of_callbacks() const { return number_of_callbacks_; }
 
  private:
   // Callback for TopSitesLikelyImpl::GetMostVisitedURLs.
   void OnTopSitesAvailable(const history::MostVisitedURLList& data) {
     urls_ = data;
     number_of_callbacks_++;
     if (waiting_) {
-      MessageLoop::current()->Quit();
+      base::MessageLoop::current()->Quit();
       waiting_ = false;
     }
   }
 
   base::WeakPtrFactory<TopSitesQuerier> weak_ptr_factory_;
   MostVisitedURLList urls_;
   int number_of_callbacks_;
   bool waiting_;
 
   DISALLOW_COPY_AND_ASSIGN(TopSitesQuerier);
@@ skipping 66 matching lines @@
   void RefreshTopSitesAndRecreate() {
     StartQueryForMostVisited();
     WaitForHistory();
     RecreateTopSitesAndBlock();
   }
 
   // Blocks the caller until history processes a task. This is useful if you
   // need to wait until you know history has processed a task.
   void WaitForHistory() {
     history_service()->ScheduleDBTask(new WaitForHistoryTask(), &consumer_);
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
   }
 
   // Waits for top sites to finish processing a task. This is useful if you need
   // to wait until top sites finishes processing a task.
   void WaitForTopSites() {
     top_sites()->backend_->DoEmptyRequest(
         base::Bind(&TopSitesLikelyImplTest::QuitCallback,
                    base::Unretained(this)),
         &cancelable_task_tracker_);
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
   }
 
   TopSitesLikelyImpl* top_sites() {
     return static_cast<TopSitesLikelyImpl*>(profile_->GetTopSites());
   }
   CancelableRequestConsumer* consumer() { return &consumer_; }
   TestingProfile* profile() {return profile_.get();}
   HistoryService* history_service() {
     return HistoryServiceFactory::GetForProfile(profile_.get(),
                                                 Profile::EXPLICIT_ACCESS);
@@ skipping 16 matching lines @@
     }
   }
 
   // Used for callbacks from history.
   void EmptyCallback() {
   }
 
   // Quit the current message loop when invoked. Useful when running a nested
   // message loop.
   void QuitCallback() {
-    MessageLoop::current()->Quit();
+    base::MessageLoop::current()->Quit();
   }
 
   // Adds a page to history.
   void AddPageToHistory(const GURL& url) {
     RedirectList redirects;
     redirects.push_back(url);
     history_service()->AddPage(
         url, base::Time::Now(), static_cast<void*>(this), 0, GURL(),
         redirects, content::PAGE_TRANSITION_TYPED, history::SOURCE_BROWSED,
         false);
@@ skipping 67 matching lines @@
     return top_sites()->GetUpdateDelay();
   }
 
   bool IsTopSitesLoaded() { return top_sites()->loaded_; }
 
   bool AddPrepopulatedPages(MostVisitedURLList* urls) {
     return top_sites()->AddPrepopulatedPages(urls);
   }
 
  private:
-  MessageLoopForUI message_loop_;
+  base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
   scoped_ptr<TestingProfile> profile_;
 
   // To cancel HistoryService tasks.
   CancelableRequestConsumer consumer_;
 
   // To cancel TopSitesBackend tasks.
   CancelableTaskTracker cancelable_task_tracker_;
 
@@ skipping 917 matching lines @@
       chrome::NOTIFICATION_TOP_SITES_LOADED,
       content::Source<Profile>(profile()));
   profile()->CreateTopSites();
   HistoryServiceFactory::GetForProfile(
       profile(), Profile::EXPLICIT_ACCESS)->UnloadBackend();
   profile()->BlockUntilHistoryProcessesPendingRequests();
   observer.Wait();
 }
 
 }  // namespace history