Replace most of Browser::GetSelectedTabContents calls into Browser::GetSelectedWebContents. I've ...

chrome/test/base/ui_test_utils.cc

 // Copyright (c) 2011 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 "chrome/test/base/ui_test_utils.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 286 matching lines @@
     NOTREACHED();
     return;
   }
   content::BrowserThread::PostTask(thread_id, FROM_HERE,
       base::Bind(&RunAllPendingMessageAndSendQuit, current_thread_id));
 
   ui_test_utils::RunMessageLoop();
 }
 
 bool GetCurrentTabTitle(const Browser* browser, string16* title) {
-  TabContents* tab_contents = browser->GetSelectedTabContents();
-  if (!tab_contents)
+  WebContents* web_contents = browser->GetSelectedWebContents();
+  if (!web_contents)
     return false;
-  NavigationEntry* last_entry = tab_contents->GetController().GetActiveEntry();
+  NavigationEntry* last_entry = web_contents->GetController().GetActiveEntry();
   if (!last_entry)
     return false;
   title->assign(last_entry->GetTitleForDisplay(""));
   return true;
 }
 
 void WaitForNavigations(NavigationController* controller,
                         int number_of_navigations) {
   TestNavigationObserver observer(
       content::Source<NavigationController>(controller), NULL,
@@ skipping 10 matching lines @@
                   content::Source<content::WebContentsDelegate>(browser));
 }
 
 void WaitForBrowserActionUpdated(ExtensionAction* browser_action) {
   TestNotificationObserver observer;
   RegisterAndWait(&observer,
                   chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
                   content::Source<ExtensionAction>(browser_action));
 }
 
-void WaitForLoadStop(TabContents* tab) {
+void WaitForLoadStop(WebContents* tab) {
   WindowedNotificationObserver load_stop_observer(
       content::NOTIFICATION_LOAD_STOP,
       content::Source<NavigationController>(&tab->GetController()));
   // In many cases, the load may have finished before we get here.  Only wait if
   // the tab still has a pending navigation.
   if (!tab->IsLoading())
     return;
   load_stop_observer.Wait();
 }
 
@@ skipping 12 matching lines @@
     // The new browser should never be in |excluded_browsers|.
     DCHECK(!ContainsKey(excluded_browsers, new_browser));
   }
   return new_browser;
 }
 
 void OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser::OpenURLOffTheRecord(profile, url);
   Browser* browser = BrowserList::FindTabbedBrowser(
       profile->GetOffTheRecordProfile(), false);
-  WaitForNavigations(&browser->GetSelectedTabContents()->GetController(), 1);
+  WaitForNavigations(&browser->GetSelectedWebContents()->GetController(), 1);
 }
 
 void NavigateToURL(browser::NavigateParams* params) {
   TestNavigationObserver observer(
       content::NotificationService::AllSources(), NULL, 1);
   browser::Navigate(params);
   observer.WaitForObservation(
       base::Bind(&ui_test_utils::RunMessageLoop),
       base::Bind(&MessageLoop::Quit,
                  base::Unretained(MessageLoopForUI::current())));
 
 }
 
 void NavigateToURL(Browser* browser, const GURL& url) {
   NavigateToURLWithDisposition(browser, url, CURRENT_TAB,
                                BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 // Navigates the specified tab (via |disposition|) of |browser| to |url|,
 // blocking until the |number_of_navigations| specified complete.
 // |disposition| indicates what tab the download occurs in, and
 // |browser_test_flags| controls what to wait for before continuing.
 static void NavigateToURLWithDispositionBlockUntilNavigationsComplete(
     Browser* browser,
     const GURL& url,
     int number_of_navigations,
     WindowOpenDisposition disposition,
     int browser_test_flags) {
-  if (disposition == CURRENT_TAB && browser->GetSelectedTabContents())
-    WaitForLoadStop(browser->GetSelectedTabContents());
+  if (disposition == CURRENT_TAB && browser->GetSelectedWebContents())
+    WaitForLoadStop(browser->GetSelectedWebContents());
   TestNavigationObserver same_tab_observer(
       content::Source<NavigationController>(
-          &browser->GetSelectedTabContents()->GetController()),
+          &browser->GetSelectedWebContents()->GetController()),
       NULL,
       number_of_navigations);
 
   std::set<Browser*> initial_browsers;
   for (std::vector<Browser*>::const_iterator iter = BrowserList::begin();
        iter != BrowserList::end();
        ++iter) {
     initial_browsers.insert(*iter);
   }
 
   WindowedNotificationObserver tab_added_observer(
       content::NOTIFICATION_TAB_ADDED,
       content::NotificationService::AllSources());
 
   browser->OpenURL(OpenURLParams(
       url, Referrer(), disposition, content::PAGE_TRANSITION_TYPED, false));
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_BROWSER)
     browser = WaitForBrowserNotInSet(initial_browsers);
   if (browser_test_flags & BROWSER_TEST_WAIT_FOR_TAB)
     tab_added_observer.Wait();
   if (!(browser_test_flags & BROWSER_TEST_WAIT_FOR_NAVIGATION)) {
     // Some other flag caused the wait prior to this.
     return;
   }
-  TabContents* tab_contents = NULL;
+  WebContents* web_contents = NULL;
   if (disposition == NEW_BACKGROUND_TAB) {
     // We've opened up a new tab, but not selected it.
-    tab_contents = browser->GetTabContentsAt(browser->active_index() + 1);
-    EXPECT_TRUE(tab_contents != NULL)
+    web_contents = browser->GetTabContentsAt(browser->active_index() + 1);
+    EXPECT_TRUE(web_contents != NULL)
         << " Unable to wait for navigation to \"" << url.spec()
         << "\" because the new tab is not available yet";
     return;
   } else if ((disposition == CURRENT_TAB) ||
       (disposition == NEW_FOREGROUND_TAB) ||
       (disposition == SINGLETON_TAB)) {
     // The currently selected tab is the right one.
-    tab_contents = browser->GetSelectedTabContents();
+    web_contents = browser->GetSelectedWebContents();
   }
   if (disposition == CURRENT_TAB) {
     same_tab_observer.WaitForObservation(
         base::Bind(&ui_test_utils::RunMessageLoop),
         base::Bind(&MessageLoop::Quit,
                    base::Unretained(MessageLoopForUI::current())));
     return;
-  } else if (tab_contents) {
-    NavigationController* controller = &tab_contents->GetController();
+  } else if (web_contents) {
+    NavigationController* controller = &web_contents->GetController();
     WaitForNavigations(controller, number_of_navigations);
     return;
   }
-  EXPECT_TRUE(NULL != tab_contents) << " Unable to wait for navigation to \""
+  EXPECT_TRUE(NULL != web_contents) << " Unable to wait for navigation to \""
                                     << url.spec() << "\""
                                     << " because we can't get the tab contents";
 }
 
 void NavigateToURLWithDisposition(Browser* browser,
                                   const GURL& url,
                                   WindowOpenDisposition disposition,
                                   int browser_test_flags) {
   NavigateToURLWithDispositionBlockUntilNavigationsComplete(
       browser,
@@ skipping 10 matching lines @@
       browser,
       url,
       number_of_navigations,
       CURRENT_TAB,
       BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 DOMElementProxyRef GetActiveDOMDocument(Browser* browser) {
   JavaScriptExecutionController* executor =
       new InProcessJavaScriptExecutionController(
-          browser->GetSelectedTabContents()->GetRenderViewHost());
+          browser->GetSelectedWebContents()->GetRenderViewHost());
   int element_handle;
   executor->ExecuteJavaScriptAndGetReturn("document;", &element_handle);
   return executor->GetObjectProxy<DOMElementProxy>(element_handle);
 }
 
 bool ExecuteJavaScript(RenderViewHost* render_view_host,
                        const std::wstring& frame_xpath,
                        const std::wstring& original_script) {
   std::wstring script =
       original_script + L"window.domAutomationController.send(0);";
@@ skipping 60 matching lines @@
   return url;
 }
 
 AppModalDialog* WaitForAppModalDialog() {
   TestNotificationObserver observer;
   RegisterAndWait(&observer, chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN,
                   content::NotificationService::AllSources());
   return content::Source<AppModalDialog>(observer.source()).ptr();
 }
 
-void CrashTab(TabContents* tab) {
+void CrashTab(WebContents* tab) {
   content::RenderProcessHost* rph = tab->GetRenderProcessHost();
   base::KillProcess(rph->GetHandle(), 0, false);
   TestNotificationObserver observer;
   RegisterAndWait(&observer, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                   content::Source<content::RenderProcessHost>(rph));
 }
 
 int FindInPage(TabContentsWrapper* tab_contents, const string16& search_string,
                bool forward, bool match_case, int* ordinal) {
   tab_contents->
@@ skipping 498 matching lines @@
   return taker.TakeRenderWidgetSnapshot(rwh, page_size, page_size, bitmap);
 }
 
 bool TakeEntirePageSnapshot(RenderViewHost* rvh, SkBitmap* bitmap) {
   DCHECK(bitmap);
   SnapshotTaker taker;
   return taker.TakeEntirePageSnapshot(rvh, bitmap);
 }
 
 }  // namespace ui_test_utils