TabContentsWrapper -> TabContents, part 56.

chrome/test/base/ui_test_utils.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 "chrome/test/base/ui_test_utils.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 23 matching lines @@
 #include "chrome/browser/search_engines/template_url_service_test_util.h"
 #include "chrome/browser/tab_contents/thumbnail_generator.h"
 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/find_bar/find_notification_details.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/test/automation/javascript_execution_controller.h"
 #include "chrome/test/base/bookmark_load_observer.h"
 #include "content/public/browser/dom_operation_notification_details.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/geolocation.h"
 #include "content/public/browser/navigation_controller.h"
@@ skipping 75 matching lines @@
  private:
   content::NotificationRegistrar registrar_;
   std::string response_;
   bool did_respond_;
 
   DISALLOW_COPY_AND_ASSIGN(DOMOperationObserver);
 };
 
 class FindInPageNotificationObserver : public content::NotificationObserver {
  public:
-  explicit FindInPageNotificationObserver(TabContentsWrapper* parent_tab)
+  explicit FindInPageNotificationObserver(TabContents* parent_tab)
       : parent_tab_(parent_tab),
         active_match_ordinal_(-1),
         number_of_matches_(0) {
     current_find_request_id_ =
         parent_tab->find_tab_helper()->current_find_request_id();
     registrar_.Add(this, chrome::NOTIFICATION_FIND_RESULT_AVAILABLE,
                    content::Source<WebContents>(parent_tab_->web_contents()));
     ui_test_utils::RunMessageLoop();
   }
 
@@ skipping 17 matching lines @@
           DVLOG(1) << "Ignoring, since we only care about the final message";
         }
       }
     } else {
       NOTREACHED();
     }
   }
 
  private:
   content::NotificationRegistrar registrar_;
-  TabContentsWrapper* parent_tab_;
+  TabContents* parent_tab_;
   // We will at some point (before final update) be notified of the ordinal and
   // we need to preserve it so we can send it later.
   int active_match_ordinal_;
   int number_of_matches_;
   // The id of the current find request, obtained from WebContents. Allows us
   // to monitor when the search completes.
   int current_find_request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(FindInPageNotificationObserver);
 };
@@ skipping 118 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) {
-  WebContents* web_contents = browser->GetSelectedWebContents();
+  WebContents* web_contents = browser->GetActiveWebContents();
   if (!web_contents)
     return false;
   NavigationEntry* last_entry = web_contents->GetController().GetActiveEntry();
   if (!last_entry)
     return false;
   title->assign(last_entry->GetTitleForDisplay(""));
   return true;
 }
 
 void WaitForNavigations(NavigationController* controller,
@@ skipping 47 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 = browser::FindTabbedBrowser(
       profile->GetOffTheRecordProfile(), false);
-  WaitForNavigations(&browser->GetSelectedWebContents()->GetController(), 1);
+  WaitForNavigations(&browser->GetActiveWebContents()->GetController(), 1);
 }
 
 void NavigateToURL(browser::NavigateParams* params) {
   content::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->GetSelectedWebContents())
-    WaitForLoadStop(browser->GetSelectedWebContents());
+  if (disposition == CURRENT_TAB && browser->GetActiveWebContents())
+    WaitForLoadStop(browser->GetActiveWebContents());
   NavigationController* controller =
-      browser->GetSelectedWebContents() ?
-      &browser->GetSelectedWebContents()->GetController() : NULL;
+      browser->GetActiveWebContents() ?
+      &browser->GetActiveWebContents()->GetController() : NULL;
   content::TestNavigationObserver same_tab_observer(
       content::Source<NavigationController>(controller),
       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);
@@ skipping 24 matching lines @@
     // We've opened up a new tab, but not selected it.
     web_contents = browser->GetWebContentsAt(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.
-    web_contents = browser->GetSelectedWebContents();
+    web_contents = browser->GetActiveWebContents();
   }
   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 (web_contents) {
     NavigationController* controller = &web_contents->GetController();
     WaitForNavigations(controller, number_of_navigations);
@@ skipping 23 matching lines @@
       browser,
       url,
       number_of_navigations,
       CURRENT_TAB,
       BROWSER_TEST_WAIT_FOR_NAVIGATION);
 }
 
 DOMElementProxyRef GetActiveDOMDocument(Browser* browser) {
   JavaScriptExecutionController* executor =
       new InProcessJavaScriptExecutionController(
-          browser->GetSelectedWebContents()->GetRenderViewHost());
+          browser->GetActiveWebContents()->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 75 matching lines @@
 
 void CrashTab(WebContents* tab) {
   content::RenderProcessHost* rph = tab->GetRenderProcessHost();
   WindowedNotificationObserver observer(
       content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::Source<content::RenderProcessHost>(rph));
   base::KillProcess(rph->GetHandle(), 0, false);
   observer.Wait();
 }
 
-int FindInPage(TabContentsWrapper* tab_contents, const string16& search_string,
+int FindInPage(TabContents* tab_contents, const string16& search_string,
                bool forward, bool match_case, int* ordinal) {
   tab_contents->
       find_tab_helper()->StartFinding(search_string, forward, match_case);
   FindInPageNotificationObserver observer(tab_contents);
   if (ordinal)
     *ordinal = observer.active_match_ordinal();
   return observer.number_of_matches();
 }
 
 void SimulateMouseClick(content::WebContents* tab) {
@@ skipping 650 matching lines @@
                int state,
                const base::Closure& followup) {
   if (!followup.is_null())
     ui_controls::SendMouseEventsNotifyWhenDone(button, state, followup);
   else
     ui_controls::SendMouseEvents(button, state);
 }
 
 }  // namespace internal
 }  // namespace ui_test_utils