Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

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 87 matching lines @@
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog.h"
 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog_queue.h"
 #include "chrome/browser/ui/app_modal_dialogs/javascript_app_modal_dialog.h"
 #include "chrome/browser/ui/app_modal_dialogs/native_app_modal_dialog.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #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/fullscreen_controller.h"
 #include "chrome/browser/ui/fullscreen/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_edit_model.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
@@ skipping 360 matching lines @@
   browser->window()->Close();
 }
 
 void TestingAutomationProvider::ActivateTab(int handle,
                                             int at_index,
                                             int* status) {
   *status = -1;
   if (browser_tracker_->ContainsHandle(handle) && at_index > -1) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (at_index >= 0 && at_index < browser->tab_count()) {
-      browser->ActivateTabAt(at_index, true);
+      chrome::ActivateTabAt(browser, at_index, true);
       *status = 0;
     }
   }
 }
 
 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);
-    TabContents* contents =
-        browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_TYPED);
+    TabContents* contents = chrome::AddSelectedTabWithURL(
+        browser, 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.
 
     if (observer)
@@ skipping 24 matching lines @@
 
 void TestingAutomationProvider::CloseTab(int tab_handle,
                                          bool wait_until_closed,
                                          IPC::Message* reply_message) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
     NavigationController* controller = tab_tracker_->GetResource(tab_handle);
     Browser* browser = browser::FindBrowserWithWebContents(
         controller->GetWebContents());
     DCHECK(browser);
     new TabClosedNotificationObserver(this, wait_until_closed, reply_message);
-    browser->CloseTabContents(controller->GetWebContents());
+    chrome::CloseWebContents(browser, controller->GetWebContents());
     return;
   }
 
   AutomationMsg_CloseTab::WriteReplyParams(reply_message, false);
   Send(reply_message);
 }
 
 void TestingAutomationProvider::GetCookies(const GURL& url, int handle,
                                            int* value_size,
                                            std::string* value) {
@@ skipping 490 matching lines @@
   }
 }
 
 void TestingAutomationProvider::GetTab(int win_handle,
                                        int tab_index,
                                        int* tab_handle) {
   *tab_handle = 0;
   if (browser_tracker_->ContainsHandle(win_handle) && (tab_index >= 0)) {
     Browser* browser = browser_tracker_->GetResource(win_handle);
     if (tab_index < browser->tab_count()) {
-      WebContents* web_contents = browser->GetWebContentsAt(tab_index);
+      WebContents* web_contents = chrome::GetWebContentsAt(browser, tab_index);
       *tab_handle = tab_tracker_->Add(&web_contents->GetController());
     }
   }
 }
 
 void TestingAutomationProvider::GetTabTitle(int handle,
                                             int* title_string_size,
                                             std::wstring* title) {
   *title_string_size = -1;  // -1 is the error code
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     NavigationEntry* entry = tab->GetActiveEntry();
     if (entry != NULL) {
       *title = UTF16ToWideHack(entry->GetTitleForDisplay(""));
     } else {
       *title = std::wstring();
     }
     *title_string_size = static_cast<int>(title->size());
   }
 }
 
 void TestingAutomationProvider::GetTabIndex(int handle, int* tabstrip_index) {
   *tabstrip_index = -1;  // -1 is the error code
 
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     Browser* browser = browser::FindBrowserWithWebContents(
         tab->GetWebContents());
-    *tabstrip_index = browser->GetIndexOfController(tab);
+    *tabstrip_index = chrome::GetIndexOfTab(browser, tab->GetWebContents());
   }
 }
 
 void TestingAutomationProvider::GetTabURL(int handle,
                                           bool* success,
                                           GURL* url) {
   *success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     // Return what the user would see in the location bar.
@@ skipping 1109 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;
   }
 
-  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
+  TabContents* tab_contents = chrome::GetTabContentsAt(browser, 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 175 matching lines @@
         break;
       default:
         type = "unknown";
         break;
     }
     browser_item->SetString("type", type);
     // For each window, add info about all tabs in a list of dictionaries,
     // one dictionary item per tab.
     ListValue* tabs = new ListValue;
     for (int i = 0; i < browser->tab_count(); ++i) {
-      WebContents* wc = browser->GetWebContentsAt(i);
+      WebContents* wc = chrome::GetWebContentsAt(browser, i);
       DictionaryValue* tab = new DictionaryValue;
       tab->SetInteger("index", i);
       tab->SetString("url", wc->GetURL().spec());
       tab->SetInteger("renderer_pid",
                       base::GetProcId(wc->GetRenderProcessHost()->GetHandle()));
       tab->Set("infobars", GetInfobarsInfo(wc));
-      tab->SetBoolean("pinned", browser->IsTabPinned(i));
+      tab->SetBoolean("pinned", browser->tab_strip_model()->IsTabPinned(i));
       tabs->Append(tab);
     }
     browser_item->Set("tabs", tabs);
 
     windows->Append(browser_item);
   }
   return_value->Set("windows", windows);
 
 #if defined(OS_LINUX)
   int flags = ChildProcessHost::CHILD_ALLOW_SELF;
@@ skipping 107 matching lines @@
 // Refer to GetNavigationInfo() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetNavigationInfo(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int tab_index;
   WebContents* web_contents = NULL;
   if (!args->GetInteger("tab_index", &tab_index) ||
-      !(web_contents = browser->GetWebContentsAt(tab_index))) {
+      !(web_contents = chrome::GetWebContentsAt(browser, tab_index))) {
     reply.SendError("tab_index missing or invalid.");
     return;
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   const NavigationController& controller = web_contents->GetController();
   NavigationEntry* nav_entry = controller.GetActiveEntry();
   DCHECK(nav_entry);
 
   // Security info.
   DictionaryValue* ssl = new DictionaryValue;
@@ skipping 618 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->GetActiveWebContents()->GetController();
+      chrome::GetActiveWebContents(browser)->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 154 matching lines @@
   FilePath::StringType filename;
   FilePath::StringType parent_directory;
   WebContents* web_contents = NULL;
 
   if (!args->GetInteger("tab_index", &tab_index) ||
       !args->GetString("filename", &filename)) {
     AutomationJSONReply(this, reply_message)
         .SendError("tab_index or filename param missing");
     return;
   } else {
-    web_contents = browser->GetWebContentsAt(tab_index);
+    web_contents = chrome::GetWebContentsAt(browser, tab_index);
     if (!web_contents) {
       AutomationJSONReply(this, reply_message).SendError("no tab at tab_index");
       return;
     }
   }
   // We're doing a SAVE_AS_ONLY_HTML so the the directory path isn't
   // used.  Nevertheless, SavePackage requires it be valid.  Sigh.
   parent_directory = FilePath(filename).DirName().value();
   if (!web_contents->SavePage(
           FilePath(filename),
@@ skipping 292 matching lines @@
 // 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;
   }
 
-  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
+  TabContents* tab_contents = chrome::GetTabContentsAt(browser, 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) {
@@ skipping 820 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;
   }
 
-  TabContents* tab_contents =
-      browser->GetTabContentsAt(tab_index);
+  TabContents* tab_contents = chrome::GetTabContentsAt(browser, 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;
   }
 
-  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
+  TabContents* tab_contents = chrome::GetTabContentsAt(browser, 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;
   }
-  TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
+  TabContents* tab_contents = chrome::GetTabContentsAt(browser, 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 34 matching lines @@
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   int tab_index;
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args");
     return;
   }
 
-  WebContents* web_contents = browser->GetWebContentsAt(tab_index);
+  WebContents* web_contents = chrome::GetWebContentsAt(browser, tab_index);
   if (!web_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         StringPrintf("No such tab at index %d", tab_index));
     return;
   }
 
   new AutofillDisplayedObserver(
       chrome::NOTIFICATION_AUTOFILL_DID_SHOW_SUGGESTIONS,
       web_contents->GetRenderViewHost(), this, reply_message);
   SendWebKeyPressEventAsync(ui::VKEY_DOWN, web_contents);
 }
 
 void TestingAutomationProvider::AutofillHighlightSuggestion(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   int tab_index;
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args");
     return;
   }
 
-  WebContents* web_contents = browser->GetWebContentsAt(tab_index);
+  WebContents* web_contents = chrome::GetWebContentsAt(browser, tab_index);
   if (!web_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         StringPrintf("No such tab at index %d", tab_index));
     return;
   }
 
   std::string direction;
   if (!args->GetString("direction", &direction) || (direction != "up" &&
                                                     direction != "down")) {
     AutomationJSONReply(this, reply_message).SendError(
@@ skipping 12 matching lines @@
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   int tab_index;
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args");
     return;
   }
 
-  WebContents* web_contents = browser->GetWebContentsAt(tab_index);
+  WebContents* web_contents = chrome::GetWebContentsAt(browser, tab_index);
   if (!web_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         StringPrintf("No such tab at index %d", tab_index));
     return;
   }
 
   new AutofillDisplayedObserver(
       chrome::NOTIFICATION_AUTOFILL_DID_FILL_FORM_DATA,
       web_contents->GetRenderViewHost(), this, reply_message);
   SendWebKeyPressEventAsync(ui::VKEY_RETURN, web_contents);
@@ skipping 687 matching lines @@
 
   std::string error;
   Browser* browser;
   WebContents* web_contents;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &web_contents, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   // The key events will be sent to the browser window, we need the current tab
   // containing the element we send the text in to be shown.
-  browser->ActivateTabAt(
-      browser->GetIndexOfController(&web_contents->GetController()), true);
+  chrome::ActivateTabAt(browser, chrome::GetIndexOfTab(browser, web_contents),
+                        true);
 
   BrowserWindow* browser_window = browser->window();
   if (!browser_window) {
     AutomationJSONReply(this, reply_message)
         .SendError("Could not get the browser window");
     return;
   }
   gfx::NativeWindow window = browser_window->GetNativeWindow();
   if (!window) {
     AutomationJSONReply(this, reply_message)
@@ skipping 236 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->GetActiveWebContents();
+  WebContents* old_contents = chrome::GetActiveWebContents(browser);
   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 66 matching lines @@
   WebContents* web_contents;
   int tab_index;
   std::string error;
 
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing 'tab_index' argument.");
     return;
   }
 
-  web_contents = browser->GetWebContentsAt(tab_index);
+  web_contents = chrome::GetWebContentsAt(browser, tab_index);
   if (!web_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         StringPrintf("Could not get WebContents at tab index %d", tab_index));
     return;
   }
 
   RenderViewHost* render_view = web_contents->GetRenderViewHost();
 
   // This observer will delete itself.
   new V8HeapStatsObserver(
@@ skipping 13 matching lines @@
   WebContents* web_contents;
   int tab_index;
   std::string error;
 
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing 'tab_index' argument.");
     return;
   }
 
-  web_contents = browser->GetWebContentsAt(tab_index);
+  web_contents = chrome::GetWebContentsAt(browser, tab_index);
   if (!web_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         StringPrintf("Could not get WebContents at tab index %d", tab_index));
     return;
   }
 
   RenderViewHost* render_view = web_contents->GetRenderViewHost();
   int routing_id = render_view->GetRoutingID();
 
   // This observer will delete itself.
@@ skipping 18 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->GetActiveWebContents()->
+  dict.SetBoolean("result", chrome::GetActiveWebContents(browser)->
       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->GetActiveWebContents();
+  WebContents* fullscreen_tab = chrome::GetActiveWebContents(browser);
   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 122 matching lines @@
   if (has_handle) {
     TabContents* tab = TabContents::FromWebContents(
         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) {
-      TabContents* tab = browser->GetTabContentsAt(tab_index);
+      TabContents* tab = chrome::GetTabContentsAt(browser, 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 325 matching lines @@
   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->GetTabContentsAt(i)->restore_tab_helper()->
+      int id = chrome::GetTabContentsAt(browser, 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) {
-      TabContents* tab = browser->GetTabContentsAt(i);
+      TabContents* tab = chrome::GetTabContentsAt(browser, i);
       DictionaryValue* dict = new DictionaryValue();
       AutomationId id = automation_util::GetIdForTab(tab);
       dict->Set("auto_id", id.ToValue());
       view_list->Append(dict);
       if (preview_controller) {
         TabContents* preview_tab =
             preview_controller->GetPrintPreviewForTab(tab);
         if (preview_tab) {
           DictionaryValue* dict = new DictionaryValue();
           AutomationId id = automation_util::GetIdForTab(preview_tab);
@@ skipping 32 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) {
-      TabContents* tab = browser->GetTabContentsAt(i);
+      TabContents* tab = chrome::GetTabContentsAt(browser, 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 15 matching lines @@
 }
 
 void TestingAutomationProvider::CloseTabJSON(
     DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   WebContents* tab;
   std::string error;
   // Close tabs synchronously.
   if (GetBrowserAndTabFromJSONArgs(args, &browser, &tab, &error)) {
-    browser->CloseTabContents(tab);
+    chrome::CloseWebContents(browser, tab);
     reply.SendSuccess(NULL);
     return;
   }
 
   // Close other types of views asynchronously.
   RenderViewHost* view;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     reply.SendError(error);
     return;
   }
@@ skipping 59 matching lines @@
     return;
 
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   WebContents* web_contents;
   std::string error;
   if (!GetBrowserAndTabFromJSONArgs(args, &browser, &web_contents, &error)) {
     reply.SendError(error);
     return;
   }
-  browser->ActivateTabAt(
-      browser->GetIndexOfController(&web_contents->GetController()), true);
+  chrome::ActivateTabAt(browser, chrome::GetIndexOfTab(browser, web_contents),
+                        true);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::IsPageActionVisible(
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
 
   WebContents* tab;
   std::string error;
@@ skipping 117 matching lines @@
   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->GetActiveWebContents() != tab) {
-    browser->ActivateTabAt(browser->GetIndexOfController(
-        &tab->GetController()), true);
-  }
+  if (chrome::GetActiveWebContents(browser) != tab)
+    chrome::ActivateTabAt(browser, chrome::GetIndexOfTab(browser, tab), true);
 }