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

chrome/browser/prerender/prerender_browsertest.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 <deque>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
@@ skipping 174 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(DestructionMessageFilter);
   };
 
   void OnChannelDestroyed() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     EXPECT_FALSE(channel_destroyed_);
     channel_destroyed_ = true;
     if (waiting_for_channel_destruction_) {
       waiting_for_channel_destruction_ = false;
-      MessageLoop::current()->Quit();
+      base::MessageLoop::current()->Quit();
     }
   }
 
   bool channel_destroyed_;
   bool waiting_for_channel_destruction_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelDestructionWatcher);
 };
 
 // PrerenderContents that stops the UI message loop on DidStopLoading().
@@ skipping 17 matching lines @@
         was_hidden_(false),
         was_shown_(false),
         should_be_shown_(expected_final_status == FINAL_STATUS_USED),
         quit_message_loop_on_destruction_(
             expected_final_status != FINAL_STATUS_APP_TERMINATING &&
             expected_final_status != FINAL_STATUS_MAX),
         expected_pending_prerenders_(0),
         prerender_should_wait_for_ready_title_(
             prerender_should_wait_for_ready_title) {
     if (expected_number_of_loads == 0)
-      MessageLoopForUI::current()->Quit();
+      base::MessageLoopForUI::current()->Quit();
   }
 
   virtual ~TestPrerenderContents() {
     if (expected_final_status_ == FINAL_STATUS_MAX) {
       EXPECT_EQ(match_complete_status(), MATCH_COMPLETE_REPLACEMENT);
     } else {
       EXPECT_EQ(expected_final_status_, final_status()) <<
           " when testing URL " << prerender_url().path() <<
           " (Expected: " << NameFromFinalStatus(expected_final_status_) <<
           ", Actual: " << NameFromFinalStatus(final_status()) << ")";
@@ skipping 12 matching lines @@
       EXPECT_TRUE(new_render_view_host_);
 
     EXPECT_EQ(should_be_shown_, was_shown_);
 
     // When the PrerenderContents is destroyed, quit the UI message loop.
     // This happens on navigation to used prerendered pages, and soon
     // after cancellation of unused prerendered pages.
     if (quit_message_loop_on_destruction_) {
       // The message loop may not be running if this is swapped in
       // synchronously on a Navigation.
-      MessageLoop* loop = MessageLoopForUI::current();
+      base::MessageLoop* loop = base::MessageLoopForUI::current();
       if (loop->is_running())
         loop->Quit();
     }
   }
 
   virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE {
     // On quit, it's possible to end up here when render processes are closed
     // before the PrerenderManager is destroyed.  As a result, it's possible to
     // get either FINAL_STATUS_APP_TERMINATING or FINAL_STATUS_RENDERER_CRASHED
     // on quit.
@@ skipping 15 matching lines @@
     if (url.spec() != content::kChromeUICrashURL)
       return PrerenderContents::AddAliasURL(url);
     return true;
   }
 
   virtual void DidStopLoading(RenderViewHost* render_view_host) OVERRIDE {
     PrerenderContents::DidStopLoading(render_view_host);
     ++number_of_loads_;
     if (ShouldRenderPrerenderedPageCorrectly(expected_final_status_) &&
         number_of_loads_ == expected_number_of_loads_) {
-      MessageLoopForUI::current()->Quit();
+      base::MessageLoopForUI::current()->Quit();
     }
   }
 
   virtual void AddPendingPrerender(
       scoped_ptr<PendingPrerenderInfo> pending_prerender_info) OVERRIDE {
     PrerenderContents::AddPendingPrerender(pending_prerender_info.Pass());
     if (expected_pending_prerenders_ > 0 &&
         pending_prerender_count() == expected_pending_prerenders_) {
-      MessageLoop::current()->Quit();
+      base::MessageLoop::current()->Quit();
     }
   }
 
   virtual WebContents* CreateWebContents(
       content::SessionStorageNamespace* session_storage_namespace) OVERRIDE {
     WebContents* web_contents = PrerenderContents::CreateWebContents(
         session_storage_namespace);
     string16 ready_title = ASCIIToUTF16(kReadyTitle);
     if (prerender_should_wait_for_ready_title_)
       ready_title_watcher_.reset(new content::TitleWatcher(
@@ skipping 2077 matching lines @@
 
 // Checks that when the history is cleared, prerendering is cancelled and
 // prerendering history is cleared.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearHistory) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
                    1);
 
   // Post a task to clear the history, and run the message loop until it
   // destroys the prerender.
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ClearBrowsingData, current_browser(),
                  BrowsingDataRemover::REMOVE_HISTORY));
   content::RunMessageLoop();
 
   // Make sure prerender history was cleared.
   EXPECT_EQ(0, GetHistoryLength());
 }
 
 // Checks that when the cache is cleared, prerenders are cancelled but
 // prerendering history is not cleared.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearCache) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
                    1);
 
   // Post a task to clear the cache, and run the message loop until it
   // destroys the prerender.
-  MessageLoop::current()->PostTask(FROM_HERE,
+  base::MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ClearBrowsingData, current_browser(),
                  BrowsingDataRemover::REMOVE_CACHE));
   content::RunMessageLoop();
 
   // Make sure prerender history was not cleared.  Not a vital behavior, but
   // used to compare with PrerenderClearHistory test.
   EXPECT_EQ(1, GetHistoryLength());
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelAll) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_CANCELLED,
                    1);
   // Post a task to cancel all the prerenders.
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&CancelAllPrerenders, GetPrerenderManager()));
   content::RunMessageLoop();
   EXPECT_TRUE(GetPrerenderContents() == NULL);
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderEvents) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_CANCELLED, 1);
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderLoadEventForLinkNumber(0));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
 
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&CancelAllPrerenders, GetPrerenderManager()));
   content::RunMessageLoop();
 
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_FALSE(HadPrerenderEventErrors());
 }
 
 // Cancels the prerender of a page with its own prerender.  The second prerender
 // should never be started.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelPrerenderWithPrerender) {
   PrerenderTestURL("files/prerender/prerender_infinite_a.html",
                    FINAL_STATUS_CANCELLED,
                    1);
   // Post a task to cancel all the prerenders.
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&CancelAllPrerenders, GetPrerenderManager()));
   content::RunMessageLoop();
   EXPECT_TRUE(GetPrerenderContents() == NULL);
 }
 
 // PrerenderBrowserTest.PrerenderEventsNoLoad may pass flakily on regression,
 // so please be aggressive about filing bugs when this test is failing.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderEventsNoLoad) {
   // This should be canceled.
   PrerenderTestURL("files/prerender/prerender_http_auth_container.html",
@@ skipping 304 matching lines @@
 // Checks that non-http/https main page redirects cancel the prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelMainFrameRedirectUnsupportedScheme) {
   GURL url = test_server()->GetURL(
       CreateServerRedirect("invalidscheme://www.google.com/test.html"));
   PrerenderTestURL(url, FINAL_STATUS_UNSUPPORTED_SCHEME, 1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender