TabContentsWrapper -> TabContents, part 6.

chrome/browser/automation/testing_automation_provider.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/browser/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 95 matching lines @@
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/find_bar/find_bar.h"
 #include "chrome/browser/ui/fullscreen_controller.h"
 #include "chrome/browser/ui/fullscreen_exit_bubble_type.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/browser/ui/media_stream_infobar_delegate.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
 #include "chrome/browser/ui/search_engines/keyword_editor_controller.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/common/automation_events.h"
 #include "chrome/common/automation_id.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 364 matching lines @@
 void TestingAutomationProvider::AppendTab(int handle,
                                           const GURL& url,
                                           IPC::Message* reply_message) {
   int append_tab_response = -1;  // -1 is the error code
   TabAppendedNotificationObserver* observer = NULL;
 
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     observer = new TabAppendedNotificationObserver(browser, this,
                                                    reply_message);
-    TabContentsWrapper* contents =
+    TabContents* contents =
         browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_TYPED);
     if (contents) {
       append_tab_response = GetIndexForNavigationController(
           &contents->web_contents()->GetController(), browser);
     }
   }
 
   if (append_tab_response < 0) {
     // Appending tab failed. Clean up and send failure response.
 
@@ skipping 1574 matching lines @@
   if (args->GetInteger("height", &height))
     rect.set_height(height);
   browser->window()->SetBounds(rect);
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 ListValue* TestingAutomationProvider::GetInfobarsInfo(WebContents* wc) {
   // Each infobar may have different properties depending on the type.
   ListValue* infobars = new ListValue;
   InfoBarTabHelper* infobar_helper =
-      TabContentsWrapper::GetCurrentWrapperForContents(wc)->
+      TabContents::GetOwningTabContentsForWebContents(wc)->
           infobar_tab_helper();
   for (size_t i = 0; i < infobar_helper->infobar_count(); ++i) {
     DictionaryValue* infobar_item = new DictionaryValue;
     InfoBarDelegate* infobar = infobar_helper->GetInfoBarDelegateAt(i);
     switch (infobar->GetInfoBarAutomationType()) {
       case InfoBarDelegate::CONFIRM_INFOBAR:
         infobar_item->SetString("type", "confirm_infobar");
         break;
       case InfoBarDelegate::ONE_CLICK_LOGIN_INFOBAR:
         infobar_item->SetString("type", "oneclicklogin_infobar");
@@ skipping 64 matching lines @@
   int tab_index;
   int infobar_index_int;
   std::string action;
   if (!args->GetInteger("tab_index", &tab_index) ||
       !args->GetInteger("infobar_index", &infobar_index_int) ||
       !args->GetString("action", &action)) {
     reply.SendError("Invalid or missing args");
     return;
   }
 
-  TabContentsWrapper* tab_contents =
-      browser->GetTabContentsWrapperAt(tab_index);
+  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
   if (!tab_contents) {
     reply.SendError(StringPrintf("No such tab at index %d", tab_index));
     return;
   }
   InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
 
   InfoBarDelegate* infobar = NULL;
   size_t infobar_index = static_cast<size_t>(infobar_index_int);
   if (infobar_index >= infobar_helper->infobar_count()) {
     reply.SendError(StringPrintf("No such infobar at index %" PRIuS,
@@ skipping 948 matching lines @@
   model->OnUpOrDownKeyPressed(count);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "OmniboxAcceptInput" }
 void TestingAutomationProvider::OmniboxAcceptInput(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   NavigationController& controller =
-      browser->GetSelectedWebContents()->GetController();
+      browser->GetActiveWebContents()->GetController();
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   if (!loc_bar) {
     AutomationJSONReply(this, reply_message).SendError(
         "The specified browser does not have a location bar.");
     return;
   }
   new OmniboxAcceptNotificationObserver(&controller, this, reply_message);
   loc_bar->AcceptInput();
 }
 
@@ skipping 457 matching lines @@
 
   remover->AddObserver(
       new AutomationProviderBrowsingDataObserver(this, reply_message));
   remover->Remove(remove_mask, BrowsingDataHelper::UNPROTECTED_WEB);
   // BrowsingDataRemover deletes itself using DeleteTask.
   // The observer also deletes itself after sending the reply.
 }
 
 namespace {
 
-// Get the TabContentsWrapper from a dictionary of arguments.
-TabContentsWrapper* GetTabContentsWrapperFromDict(const Browser* browser,
-                                                  const DictionaryValue* args,
-                                                  std::string* error_message) {
+// Get the TabContents from a dictionary of arguments.
+TabContents* GetTabContentsFromDict(const Browser* browser,
+                                    const DictionaryValue* args,
+                                    std::string* error_message) {
   int tab_index;
   if (!args->GetInteger("tab_index", &tab_index)) {
     *error_message = "Must include tab_index.";
     return NULL;
   }
 
-  TabContentsWrapper* tab_contents =
-      browser->GetTabContentsWrapperAt(tab_index);
+  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
   if (!tab_contents) {
     *error_message = StringPrintf("No tab at index %d.", tab_index);
     return NULL;
   }
   return tab_contents;
 }
 
 // Get the TranslateInfoBarDelegate from WebContents.
 TranslateInfoBarDelegate* GetTranslateInfoBarDelegate(
     WebContents* web_contents) {
   InfoBarTabHelper* infobar_helper =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents)->
+      TabContents::GetOwningTabContentsForWebContents(web_contents)->
           infobar_tab_helper();
   for (size_t i = 0; i < infobar_helper->infobar_count(); i++) {
     InfoBarDelegate* infobar = infobar_helper->GetInfoBarDelegateAt(i);
     if (infobar->AsTranslateInfoBarDelegate())
       return infobar->AsTranslateInfoBarDelegate();
   }
   // No translate infobar.
   return NULL;
 }
 
 }  // namespace
 
 void TestingAutomationProvider::FindInPage(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error_message;
-  TabContentsWrapper* tab_contents =
-      GetTabContentsWrapperFromDict(browser, args, &error_message);
+  TabContents* tab_contents =
+      GetTabContentsFromDict(browser, args, &error_message);
   if (!tab_contents) {
     AutomationJSONReply(this, reply_message).SendError(error_message);
     return;
   }
   string16 search_string;
   bool forward;
   bool match_case;
   bool find_next;
   if (!args->GetString("search_string", &search_string)) {
     AutomationJSONReply(this, reply_message).
@@ skipping 24 matching lines @@
                   reply_message);
 }
 
 // See GetTranslateInfo() in chrome/test/pyautolib/pyauto.py for sample json
 // input and output.
 void TestingAutomationProvider::GetTranslateInfo(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error_message;
-  TabContentsWrapper* tab_contents_wrapper =
-      GetTabContentsWrapperFromDict(browser, args, &error_message);
-  if (!tab_contents_wrapper) {
+  TabContents* tab_contents =
+      GetTabContentsFromDict(browser, args, &error_message);
+  if (!tab_contents) {
     AutomationJSONReply(this, reply_message).SendError(error_message);
     return;
   }
 
-  WebContents* web_contents = tab_contents_wrapper->web_contents();
+  WebContents* web_contents = tab_contents->web_contents();
   // Get the translate bar if there is one and pass it to the observer.
   // The observer will check for null and populate the information accordingly.
   TranslateInfoBarDelegate* translate_bar =
       GetTranslateInfoBarDelegate(web_contents);
 
   TabLanguageDeterminedObserver* observer = new TabLanguageDeterminedObserver(
       this, reply_message, web_contents, translate_bar);
   // If the language for the page hasn't been loaded yet, then just make
   // the observer, otherwise call observe directly.
-  TranslateTabHelper* helper = TabContentsWrapper::GetCurrentWrapperForContents(
+  TranslateTabHelper* helper = TabContents::GetOwningTabContentsForWebContents(
       web_contents)->translate_tab_helper();
   std::string language = helper->language_state().original_language();
   if (!language.empty()) {
     observer->Observe(chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
                       content::Source<WebContents>(web_contents),
                       content::Details<std::string>(&language));
   }
 }
 
 // See SelectTranslateOption() in chrome/test/pyautolib/pyauto.py for sample
 // json input.
 // Sample json output: {}
 void TestingAutomationProvider::SelectTranslateOption(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string option;
   std::string error_message;
-  TabContentsWrapper* tab_contents_wrapper =
-      GetTabContentsWrapperFromDict(browser, args, &error_message);
-  if (!tab_contents_wrapper) {
+  TabContents* tab_contents =
+      GetTabContentsFromDict(browser, args, &error_message);
+  if (!tab_contents) {
     AutomationJSONReply(this, reply_message).SendError(error_message);
     return;
   }
 
-  WebContents* web_contents = tab_contents_wrapper->web_contents();
+  WebContents* web_contents = tab_contents->web_contents();
   TranslateInfoBarDelegate* translate_bar =
       GetTranslateInfoBarDelegate(web_contents);
   if (!translate_bar) {
     AutomationJSONReply(this, reply_message)
         .SendError("There is no translate bar open.");
     return;
   }
 
   if (!args->GetString("option", &option)) {
     AutomationJSONReply(this, reply_message).SendError("Must include option");
@@ skipping 77 matching lines @@
     if (!translate_bar->ShouldShowNeverTranslateButton()) {
       reply.SendError("Always translate button not showing.");
       return;
     }
     translate_bar->NeverTranslatePageLanguage();
     reply.SendSuccess(NULL);
   } else if (option == "decline_translation") {
     // This is the function called when an infobar is dismissed or when the
     // user clicks the 'Nope' translate button.
     translate_bar->TranslationDeclined();
-    tab_contents_wrapper->infobar_tab_helper()->RemoveInfoBar(translate_bar);
+    tab_contents->infobar_tab_helper()->RemoveInfoBar(translate_bar);
     reply.SendSuccess(NULL);
   } else {
     reply.SendError("Invalid string found for option.");
   }
 }
 
 // Sample json input: { "command": "GetBlockedPopupsInfo",
 //                      "tab_index": 1 }
 // Refer GetBlockedPopupsInfo() in pyauto.py for sample output.
 void TestingAutomationProvider::GetBlockedPopupsInfo(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string error_message;
-  TabContentsWrapper* tab_contents = GetTabContentsWrapperFromDict(
+  TabContents* tab_contents = GetTabContentsFromDict(
       browser, args, &error_message);
   if (!tab_contents) {
     reply.SendError(error_message);
     return;
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   BlockedContentTabHelper* blocked_content =
       tab_contents->blocked_content_tab_helper();
   ListValue* blocked_popups_list = new ListValue;
-  std::vector<TabContentsWrapper*> blocked_contents;
+  std::vector<TabContents*> blocked_contents;
   blocked_content->GetBlockedContents(&blocked_contents);
-  for (std::vector<TabContentsWrapper*>::const_iterator it =
+  for (std::vector<TabContents*>::const_iterator it =
            blocked_contents.begin(); it != blocked_contents.end(); ++it) {
     DictionaryValue* item = new DictionaryValue;
     item->SetString("url", (*it)->web_contents()->GetURL().spec());
     item->SetString("title", (*it)->web_contents()->GetTitle());
     blocked_popups_list->Append(item);
   }
   return_value->Set("blocked_popups", blocked_popups_list);
   reply.SendSuccess(return_value.get());
 }
 
 // Refer UnblockAndLaunchBlockedPopup() in pyauto.py for sample input.
 void TestingAutomationProvider::UnblockAndLaunchBlockedPopup(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string error_message;
-  TabContentsWrapper* tab_contents = GetTabContentsWrapperFromDict(
+  TabContents* tab_contents = GetTabContentsFromDict(
       browser, args, &error_message);
   if (!tab_contents) {
     reply.SendError(error_message);
     return;
   }
   int popup_index;
   if (!args->GetInteger("popup_index", &popup_index)) {
     reply.SendError("Need popup_index arg");
     return;
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   BlockedContentTabHelper* blocked_content =
       tab_contents->blocked_content_tab_helper();
   if (popup_index >= (int)blocked_content->GetBlockedContentsCount()) {
     reply.SendError(StringPrintf("No popup at index %d", popup_index));
     return;
   }
-  std::vector<TabContentsWrapper*> blocked_contents;
+  std::vector<TabContents*> blocked_contents;
   blocked_content->GetBlockedContents(&blocked_contents);
   blocked_content->LaunchForContents(blocked_contents[popup_index]);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "GetThemeInfo" }
 // Refer GetThemeInfo() in chrome/test/pyautolib/pyauto.py for sample output.
 void TestingAutomationProvider::GetThemeInfo(
     Browser* browser,
     DictionaryValue* args,
@@ skipping 458 matching lines @@
       reply.SendError(error);
       return;
     }
 
     RenderViewHost* render_view = web_contents->GetRenderViewHost();
     if (!render_view) {
       reply.SendError("Tab has no associated RenderViewHost");
       return;
     }
 
-    TabContentsWrapper* tab_contents =
-        TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
+    TabContents* tab_contents =
+        TabContents::GetOwningTabContentsForWebContents(web_contents);
     tab_contents->automation_tab_helper()->HeapProfilerDump(reason_string);
     reply.SendSuccess(NULL);
     return;
   }
 
   reply.SendError("Process type is not supported");
 }
 #endif  // !defined(NO_TCMALLOC) && (defined(OS_LINUX) || defined(OS_CHROMEOS))
 
 namespace {
@@ skipping 56 matching lines @@
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   // Get the AutofillProfiles currently in the database.
   int tab_index = 0;
   if (!args->GetInteger("tab_index", &tab_index)) {
     reply.SendError("Invalid or missing tab_index integer value.");
     return;
   }
 
-  TabContentsWrapper* tab_contents =
-      browser->GetTabContentsWrapperAt(tab_index);
+  TabContents* tab_contents =
+      browser->GetTabContentsAt(tab_index);
   if (tab_contents) {
     PersonalDataManager* pdm = PersonalDataManagerFactory::GetForProfile(
         tab_contents->profile()->GetOriginalProfile());
     if (pdm) {
       std::vector<AutofillProfile*> autofill_profiles = pdm->profiles();
       std::vector<CreditCard*> credit_cards = pdm->credit_cards();
 
       ListValue* profiles = GetListFromAutofillProfiles(autofill_profiles);
       ListValue* cards = GetListFromCreditCards(credit_cards);
 
@@ skipping 44 matching lines @@
   }
 
   // Save the AutofillProfiles.
   int tab_index = 0;
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing tab_index integer");
     return;
   }
 
-  TabContentsWrapper* tab_contents =
-      browser->GetTabContentsWrapperAt(tab_index);
+  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
 
   if (tab_contents) {
     PersonalDataManager* pdm =
         PersonalDataManagerFactory::GetForProfile(tab_contents->profile());
     if (pdm) {
       if (profiles || cards) {
         // This observer will delete itself.
         AutofillChangedObserver* observer = new AutofillChangedObserver(
             this, reply_message, autofill_profiles.size(), credit_cards.size());
         observer->Init();
@@ skipping 23 matching lines @@
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   int tab_index;
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'tab_index' missing or invalid.");
     return;
   }
-  TabContentsWrapper* tab_contents =
-      browser->GetTabContentsWrapperAt(tab_index);
+  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
   if (!tab_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         StringPrintf("No such tab at index %d", tab_index));
     return;
   }
 
   string16 frame_xpath, javascript;
   if (!args->GetString("frame_xpath", &frame_xpath)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'frame_xpath' missing or invalid.");
@@ skipping 1057 matching lines @@
                      id.c_str()));
     return;
   }
 
   // Look at preferences to find the right launch container.  If no preference
   // is set, launch as a regular tab.
   extension_misc::LaunchContainer launch_container =
       service->extension_prefs()->GetLaunchContainer(
           extension, ExtensionPrefs::LAUNCH_REGULAR);
 
-  WebContents* old_contents = browser->GetSelectedWebContents();
+  WebContents* old_contents = browser->GetActiveWebContents();
   if (!old_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         "Cannot identify selected tab contents.");
     return;
   }
 
   // This observer will delete itself.
   new AppLaunchObserver(&old_contents->GetController(), this, reply_message,
                         launch_container);
   application_launch::OpenApplication(profile(), extension, launch_container,
@@ skipping 139 matching lines @@
     IPC::Message* reply_message) {
   DictionaryValue dict;
   dict.SetBoolean("result", browser->IsFullscreenForTabOrPending());
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsMouseLocked(Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   DictionaryValue dict;
-  dict.SetBoolean("result", browser->GetSelectedWebContents()->
+  dict.SetBoolean("result", browser->GetActiveWebContents()->
       GetRenderViewHost()->GetView()->IsMouseLocked());
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::IsMouseLockPermissionRequested(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   FullscreenExitBubbleType type =
       browser->fullscreen_controller_->GetFullscreenExitBubbleType();
@@ skipping 36 matching lines @@
       browser->fullscreen_controller_->GetFullscreenExitBubbleType();
   DictionaryValue dict;
   dict.SetBoolean("result", fullscreen_bubble::ShowButtonsForType(type));
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::AcceptCurrentFullscreenOrMouseLockRequest(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
-  WebContents* fullscreen_tab = browser->GetSelectedWebContents();
+  WebContents* fullscreen_tab = browser->GetActiveWebContents();
   FullscreenExitBubbleType type =
       browser->fullscreen_controller_->GetFullscreenExitBubbleType();
   browser->OnAcceptFullscreenPermission(fullscreen_tab->GetURL(), type);
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::DenyCurrentFullscreenOrMouseLockRequest(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
@@ skipping 113 matching lines @@
     reply.SendError("'tab_id' is invalid");
     return;
   }
   if (has_handle && (!args->GetInteger("tab_handle", &id_or_handle) ||
                      !tab_tracker_->ContainsHandle(id_or_handle))) {
     reply.SendError("'tab_handle' is invalid");
     return;
   }
   int id = id_or_handle;
   if (has_handle) {
-    TabContentsWrapper* tab = TabContentsWrapper::GetCurrentWrapperForContents(
+    TabContents* tab = TabContents::GetOwningTabContentsForWebContents(
         tab_tracker_->GetResource(id_or_handle)->GetWebContents());
     id = tab->restore_tab_helper()->session_id().id();
   }
   BrowserList::const_iterator iter = BrowserList::begin();
   int browser_index = 0;
   for (; iter != BrowserList::end(); ++iter, ++browser_index) {
     Browser* browser = *iter;
     for (int tab_index = 0; tab_index < browser->tab_count(); ++tab_index) {
-      TabContentsWrapper* tab = browser->GetTabContentsWrapperAt(tab_index);
+      TabContents* tab = browser->GetTabContentsAt(tab_index);
       if (tab->restore_tab_helper()->session_id().id() == id) {
         DictionaryValue dict;
         dict.SetInteger("windex", browser_index);
         dict.SetInteger("tab_index", tab_index);
         reply.SendSuccess(&dict);
         return;
       }
     }
   }
   reply.SendError("Could not find tab among current browser windows");
@@ skipping 297 matching lines @@
         .SendError("'path' missing or invalid");
     return;
   }
 
   RenderViewHost* render_view = web_contents->GetRenderViewHost();
   if (render_view) {
     FilePath path(path_str);
     // This will delete itself when finished.
     PageSnapshotTaker* snapshot_taker = new PageSnapshotTaker(
         this, reply_message,
-        TabContentsWrapper::GetCurrentWrapperForContents(web_contents), path);
+        TabContents::GetOwningTabContentsForWebContents(web_contents), path);
     snapshot_taker->Start();
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError("Tab has no associated RenderViewHost");
   }
 }
 
 void TestingAutomationProvider::GetCookiesJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::GetCookiesJSON(this, args, reply_message);
 }
 
 void TestingAutomationProvider::DeleteCookieJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::DeleteCookieJSON(this, args, reply_message);
 }
 
 void TestingAutomationProvider::SetCookieJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   automation_util::SetCookieJSON(this, args, reply_message);
 }
 
 void TestingAutomationProvider::GetTabIds(
     DictionaryValue* args, IPC::Message* reply_message) {
   ListValue* id_list = new ListValue();
   BrowserList::const_iterator iter = BrowserList::begin();
   for (; iter != BrowserList::end(); ++iter) {
     Browser* browser = *iter;
     for (int i = 0; i < browser->tab_count(); ++i) {
-      int id = browser->GetTabContentsWrapperAt(i)->restore_tab_helper()->
+      int id = browser->GetTabContentsAt(i)->restore_tab_helper()->
           session_id().id();
       id_list->Append(Value::CreateIntegerValue(id));
     }
   }
   DictionaryValue dict;
   dict.Set("ids", id_list);
   AutomationJSONReply(this, reply_message).SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::GetViews(
     DictionaryValue* args, IPC::Message* reply_message) {
   ListValue* view_list = new ListValue();
   printing::PrintPreviewTabController* preview_controller =
       printing::PrintPreviewTabController::GetInstance();
   BrowserList::const_iterator browser_iter = BrowserList::begin();
   for (; browser_iter != BrowserList::end(); ++browser_iter) {
     Browser* browser = *browser_iter;
     for (int i = 0; i < browser->tab_count(); ++i) {
-      TabContentsWrapper* tab = browser->GetTabContentsWrapperAt(i);
+      TabContents* tab = browser->GetTabContentsAt(i);
       DictionaryValue* dict = new DictionaryValue();
       AutomationId id = automation_util::GetIdForTab(tab);
       dict->Set("auto_id", id.ToValue());
       view_list->Append(dict);
       if (preview_controller) {
-        TabContentsWrapper* preview_tab =
+        TabContents* preview_tab =
             preview_controller->GetPrintPreviewForTab(tab);
         if (preview_tab) {
           DictionaryValue* dict = new DictionaryValue();
           AutomationId id = automation_util::GetIdForTab(preview_tab);
           dict->Set("auto_id", id.ToValue());
           view_list->Append(dict);
         }
       }
     }
   }
@@ skipping 26 matching lines @@
   int id;
   if (!args->GetInteger("id", &id)) {
     reply.SendError("'id' missing or invalid");
     return;
   }
   bool is_valid = false;
   BrowserList::const_iterator iter = BrowserList::begin();
   for (; iter != BrowserList::end(); ++iter) {
     Browser* browser = *iter;
     for (int i = 0; i < browser->tab_count(); ++i) {
-      TabContentsWrapper* tab = browser->GetTabContentsWrapperAt(i);
+      TabContents* tab = browser->GetTabContentsAt(i);
       if (tab->restore_tab_helper()->session_id().id() == id) {
         is_valid = true;
         break;
       }
     }
   }
   DictionaryValue dict;
   dict.SetBoolean("is_valid", is_valid);
   reply.SendSuccess(&dict);
 }
@@ skipping 186 matching lines @@
 
   NavigationController* controller = tab_tracker_->GetResource(tab_handle);
   if (!controller) {
     AutomationMsg_WaitForInfoBarCount::WriteReplyParams(reply_message_, false);
     Send(reply_message_);
     return;
   }
 
   // The delegate will delete itself.
   new InfoBarCountObserver(this, reply_message,
-      TabContentsWrapper::GetCurrentWrapperForContents(
+      TabContents::GetOwningTabContentsForWebContents(
           controller->GetWebContents()), target_count);
 }
 
 void TestingAutomationProvider::ResetToDefaultTheme() {
   ThemeServiceFactory::GetForProfile(profile_)->UseDefaultTheme();
 }
 
 void TestingAutomationProvider::WaitForProcessLauncherThreadToGoIdle(
     IPC::Message* reply_message) {
   new WaitForProcessLauncherThreadToGoIdleObserver(this, reply_message);
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
-  if (browser->GetSelectedWebContents() != tab ||
+  if (browser->GetActiveWebContents() != tab ||
       browser != BrowserList::GetLastActive()) {
     browser->ActivateTabAt(browser->GetIndexOfController(&tab->GetController()),
         true /* user_gesture */);
   }
 }