Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

chrome/browser/captive_portal/captive_portal_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 <map>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/captive_portal/captive_portal_service.h"
 #include "chrome/browser/captive_portal/captive_portal_service_factory.h"
 #include "chrome/browser/captive_portal/captive_portal_tab_helper.h"
 #include "chrome/browser/captive_portal/captive_portal_tab_reloader.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_iterator.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/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
@@ skipping 872 matching lines @@
 }
 
 CaptivePortalTabReloader::State CaptivePortalBrowserTest::GetStateOfTabReloader(
     TabContents* tab_contents) const {
   return GetTabReloader(tab_contents)->state();
 }
 
 CaptivePortalTabReloader::State
 CaptivePortalBrowserTest::GetStateOfTabReloaderAt(Browser* browser,
                                                   int index) const {
-  return GetStateOfTabReloader(browser->GetTabContentsAt(index));
+  return GetStateOfTabReloader(chrome::GetTabContentsAt(browser, index));
 }
 
 int CaptivePortalBrowserTest::NumTabsWithState(
     CaptivePortalTabReloader::State state) const {
   int num_tabs = 0;
   for (TabContentsIterator tab_contents_it;
        !tab_contents_it.done();
        ++tab_contents_it) {
     if (GetStateOfTabReloader(*tab_contents_it) == state)
       ++num_tabs;
@@ skipping 24 matching lines @@
   EXPECT_EQ(0, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
   EXPECT_EQ(1, browser->tab_count());
   EXPECT_EQ(expected_navigations, navigation_observer.num_navigations());
   EXPECT_EQ(0, NumLoadingTabs());
 }
 
 void CaptivePortalBrowserTest::SlowLoadNoCaptivePortal(
     Browser* browser, Result expected_result) {
   CaptivePortalTabReloader* tab_reloader =
-      GetTabReloader(browser->GetActiveTabContents());
+      GetTabReloader(chrome::GetActiveTabContents(browser));
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
   ui_test_utils::NavigateToURLWithDisposition(browser,
                                               GURL(kMockHttpsUrl),
                                               CURRENT_TAB,
                                               ui_test_utils::BROWSER_TEST_NONE);
 
@@ skipping 22 matching lines @@
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromDays(1));
 }
 
 void CaptivePortalBrowserTest::FastTimeoutNoCaptivePortal(
     Browser* browser, Result expected_result) {
   ASSERT_NE(expected_result, RESULT_BEHIND_CAPTIVE_PORTAL);
 
   // Set the load time to be large, so the timer won't trigger.  The value is
   // not restored at the end of the function.
   CaptivePortalTabReloader* tab_reloader =
-      GetTabReloader(browser->GetActiveTabContents());
+      GetTabReloader(chrome::GetActiveTabContents(browser));
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromHours(1));
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
 
   // Neither of these should be changed by the navigation.
   int active_index = browser->active_index();
   int expected_tab_count = browser->tab_count();
 
   ui_test_utils::NavigateToURL(
       browser,
       URLRequestFailedJob::GetMockHttpsUrl(net::ERR_CONNECTION_TIMED_OUT));
 
   // An attempt to detect a captive portal should have started by now.  If not,
   // abort early to prevent hanging.
   ASSERT_TRUE(portal_observer.num_results_received() > 0 ||
               CheckPending(browser));
 
   portal_observer.WaitForResults(1);
   navigation_observer.WaitForNavigations(1);
 
   // Check the result.
   EXPECT_EQ(1, portal_observer.num_results_received());
   EXPECT_EQ(expected_result, portal_observer.captive_portal_result());
 
   // Check that the right tab was navigated, and there were no extra
   // navigations.
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   browser->GetWebContentsAt(active_index)));
+                   chrome::GetWebContentsAt(browser, active_index)));
   EXPECT_EQ(0, NumLoadingTabs());
 
   // Check the tab's state, and verify no captive portal check is pending.
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser, 0));
   EXPECT_FALSE(CheckPending(browser));
 
   // Make sure no login tab was opened.
   EXPECT_EQ(expected_tab_count, browser->tab_count());
 }
 
 void CaptivePortalBrowserTest::SlowLoadBehindCaptivePortal(
     Browser* browser,
     bool expect_open_login_tab) {
   // Calling this on a tab that's waiting for a load to manually be timed out
   // will result in a hang.
-  ASSERT_FALSE(browser->GetActiveWebContents()->IsLoading());
+  ASSERT_FALSE(chrome::GetActiveWebContents(browser)->IsLoading());
 
   // Trigger a captive portal check quickly.
   CaptivePortalTabReloader* tab_reloader =
-      GetTabReloader(browser->GetActiveTabContents());
+      GetTabReloader(chrome::GetActiveTabContents(browser));
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   // Number of tabs expected to be open after the captive portal checks
   // have completed.
   int initial_tab_count = browser->tab_count();
   int initial_active_index = browser->active_index();
   int initial_loading_tabs = NumLoadingTabs();
   int expected_broken_tabs = NumBrokenTabs();
   if (CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL !=
-          GetStateOfTabReloader(browser->GetActiveTabContents())) {
+          GetStateOfTabReloader(chrome::GetActiveTabContents(browser))) {
     ++expected_broken_tabs;
   }
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
   ui_test_utils::NavigateToURLWithDisposition(browser,
                                               GURL(kMockHttpsUrl),
                                               CURRENT_TAB,
                                               ui_test_utils::BROWSER_TEST_NONE);
 
   if (expect_open_login_tab) {
     portal_observer.WaitForResults(2);
     navigation_observer.WaitForNavigations(1);
     EXPECT_EQ(2, portal_observer.num_results_received());
 
     ASSERT_EQ(initial_tab_count + 1, browser->tab_count());
     EXPECT_EQ(initial_tab_count, browser->active_index());
 
     EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                     browser->GetWebContentsAt(initial_tab_count)));
+                     chrome::GetWebContentsAt(browser, initial_tab_count)));
     EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-              GetStateOfTabReloader(browser->GetTabContentsAt(1)));
-    EXPECT_TRUE(IsLoginTab(browser->GetTabContentsAt(1)));
+              GetStateOfTabReloader(chrome::GetTabContentsAt(browser, 1)));
+    EXPECT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser, 1)));
   } else {
     portal_observer.WaitForResults(1);
     EXPECT_EQ(0, navigation_observer.num_navigations());
     EXPECT_EQ(initial_active_index, browser->active_index());
     ASSERT_EQ(initial_tab_count, browser->tab_count());
     EXPECT_EQ(initial_active_index, browser->active_index());
   }
 
   // Wait for all the expect resource loads to actually start, so subsequent
   // functions can rely on them having started.
   URLRequestTimeoutOnDemandJob::WaitForJobs(initial_loading_tabs + 1);
 
   EXPECT_EQ(initial_loading_tabs + 1, NumLoadingTabs());
   EXPECT_EQ(expected_broken_tabs, NumBrokenTabs());
   EXPECT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_FALSE(CheckPending(browser));
 
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloader(
-                browser->GetTabContentsAt(initial_active_index)));
+                chrome::GetTabContentsAt(browser, initial_active_index)));
 
   // Reset the load time to be large, so the timer won't trigger on a reload.
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromHours(1));
 }
 
 void CaptivePortalBrowserTest::FastTimeoutBehindCaptivePortal(
     Browser* browser,
     bool expect_open_login_tab) {
   // Calling this on a tab that's waiting for a load to manually be timed out
   // will result in a hang.
-  ASSERT_FALSE(browser->GetActiveWebContents()->IsLoading());
+  ASSERT_FALSE(chrome::GetActiveWebContents(browser)->IsLoading());
 
   // Set the load time to be large, so the timer won't trigger.  The value is
   // not restored at the end of the function.
   CaptivePortalTabReloader* tab_reloader =
-      GetTabReloader(browser->GetActiveTabContents());
+      GetTabReloader(chrome::GetActiveTabContents(browser));
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromHours(1));
 
   // Number of tabs expected to be open after the captive portal checks
   // have completed.
   int initial_tab_count = browser->tab_count();
   int initial_active_index = browser->active_index();
   int initial_loading_tabs = NumLoadingTabs();
   int expected_broken_tabs = NumBrokenTabs();
   if (CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL !=
-          GetStateOfTabReloader(browser->GetActiveTabContents())) {
+          GetStateOfTabReloader(chrome::GetActiveTabContents(browser))) {
     ++expected_broken_tabs;
   }
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
   ui_test_utils::NavigateToURLWithDisposition(browser,
                                               GURL(kMockHttpsQuickTimeoutUrl),
                                               CURRENT_TAB,
                                               ui_test_utils::BROWSER_TEST_NONE);
 
   if (expect_open_login_tab) {
     portal_observer.WaitForResults(2);
     navigation_observer.WaitForNavigations(2);
     EXPECT_EQ(2, portal_observer.num_results_received());
 
     ASSERT_EQ(initial_tab_count + 1, browser->tab_count());
     EXPECT_EQ(initial_tab_count, browser->active_index());
     // Make sure that the originally active tab and the captive portal tab have
     // each loaded once.
     EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                     browser->GetWebContentsAt(initial_active_index)));
+                     chrome::GetWebContentsAt(browser, initial_active_index)));
     EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                     browser->GetWebContentsAt(initial_tab_count)));
+                     chrome::GetWebContentsAt(browser, initial_tab_count)));
     EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-              GetStateOfTabReloader(browser->GetTabContentsAt(1)));
-    EXPECT_TRUE(IsLoginTab(browser->GetTabContentsAt(1)));
+              GetStateOfTabReloader(chrome::GetTabContentsAt(browser, 1)));
+    EXPECT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser, 1)));
   } else {
     portal_observer.WaitForResults(1);
     navigation_observer.WaitForNavigations(1);
     EXPECT_EQ(1, portal_observer.num_results_received());
 
     EXPECT_EQ(initial_active_index, browser->active_index());
     EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                     browser->GetWebContentsAt(initial_active_index)));
+                     chrome::GetWebContentsAt(browser, initial_active_index)));
     ASSERT_EQ(initial_tab_count, browser->tab_count());
     EXPECT_EQ(initial_active_index, browser->active_index());
   }
 
   EXPECT_EQ(initial_loading_tabs, NumLoadingTabs());
   EXPECT_EQ(expected_broken_tabs, NumBrokenTabs());
   EXPECT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_FALSE(CheckPending(browser));
 
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloader(
-                browser->GetTabContentsAt(initial_active_index)));
+                chrome::GetTabContentsAt(browser, initial_active_index)));
 }
 
 void CaptivePortalBrowserTest::NavigateLoginTab(Browser* browser,
                                                 int num_loading_tabs,
                                                 int num_timed_out_tabs) {
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
 
   int initial_tab_count = browser->tab_count();
   EXPECT_EQ(num_loading_tabs, NumLoadingTabs());
   EXPECT_EQ(num_timed_out_tabs, NumBrokenTabs() - NumLoadingTabs());
 
   int login_tab_index = browser->active_index();
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser->GetActiveTabContents()));
-  ASSERT_TRUE(IsLoginTab(browser->GetActiveTabContents()));
+            GetStateOfTabReloader(chrome::GetActiveTabContents(browser)));
+  ASSERT_TRUE(IsLoginTab(chrome::GetActiveTabContents(browser)));
 
   // Do the navigation.
   content::RenderViewHost* render_view_host =
-      browser->GetActiveWebContents()->GetRenderViewHost();
+      chrome::GetActiveWebContents(browser)->GetRenderViewHost();
   render_view_host->ExecuteJavascriptInWebFrame(
       string16(),
       ASCIIToUTF16("submitForm()"));
 
   portal_observer.WaitForResults(1);
   navigation_observer.WaitForNavigations(1);
 
   // Check the captive portal result.
   EXPECT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_EQ(1, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
 
   // Make sure not much has changed.
   EXPECT_EQ(initial_tab_count, browser->tab_count());
   EXPECT_EQ(num_loading_tabs, NumLoadingTabs());
   EXPECT_EQ(num_loading_tabs + num_timed_out_tabs, NumBrokenTabs());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser->GetTabContentsAt(login_tab_index)));
-  EXPECT_TRUE(IsLoginTab(browser->GetTabContentsAt(login_tab_index)));
+            GetStateOfTabReloader(chrome::GetTabContentsAt(browser,
+                                                           login_tab_index)));
+  EXPECT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser, login_tab_index)));
 
   // Make sure there were no unexpected navigations.
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   browser->GetWebContentsAt(login_tab_index)));
+                   chrome::GetWebContentsAt(browser, login_tab_index)));
 }
 
 void CaptivePortalBrowserTest::Login(Browser* browser,
                                      int num_loading_tabs,
                                      int num_timed_out_tabs) {
   // Simulate logging in.
   URLRequestMockCaptivePortalJobFactory::SetBehindCaptivePortal(false);
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
 
   int initial_tab_count = browser->tab_count();
   ASSERT_EQ(num_loading_tabs, NumLoadingTabs());
   EXPECT_EQ(num_timed_out_tabs, NumBrokenTabs() - NumLoadingTabs());
 
   // Verify that the login page is on top.
   int login_tab_index = browser->active_index();
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser->GetTabContentsAt(login_tab_index)));
-  ASSERT_TRUE(IsLoginTab(browser->GetTabContentsAt(login_tab_index)));
+            GetStateOfTabReloader(chrome::GetTabContentsAt(browser,
+                                                           login_tab_index)));
+  ASSERT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser, login_tab_index)));
 
   // Trigger a navigation.
   content::RenderViewHost* render_view_host =
-      browser->GetActiveWebContents()->GetRenderViewHost();
+      chrome::GetActiveWebContents(browser)->GetRenderViewHost();
   render_view_host->ExecuteJavascriptInWebFrame(
       string16(),
       ASCIIToUTF16("submitForm()"));
 
   portal_observer.WaitForResults(1);
 
   // Wait for all the timed out tabs to reload.
   navigation_observer.WaitForNavigations(1 + num_timed_out_tabs);
   EXPECT_EQ(1, portal_observer.num_results_received());
 
   // The tabs that were loading before should still be loading, and now be in
   // STATE_NEEDS_RELOAD.
   EXPECT_EQ(0, NumBrokenTabs());
   EXPECT_EQ(num_loading_tabs, NumLoadingTabs());
   EXPECT_EQ(num_loading_tabs, NumNeedReloadTabs());
 
   // Make sure that the broken tabs have reloaded, and there's no more
   // captive portal tab.
   EXPECT_EQ(initial_tab_count, browser->tab_count());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser, login_tab_index));
-  EXPECT_FALSE(IsLoginTab(browser->GetTabContentsAt(login_tab_index)));
+  EXPECT_FALSE(IsLoginTab(chrome::GetTabContentsAt(browser, login_tab_index)));
 
   // Make sure there were no unexpected navigations of the login tab.
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   browser->GetWebContentsAt(login_tab_index)));
+                   chrome::GetWebContentsAt(browser, login_tab_index)));
 }
 
 void CaptivePortalBrowserTest::FailLoadsAfterLogin(Browser* browser,
                                                    int num_loading_tabs) {
   ASSERT_EQ(num_loading_tabs, NumLoadingTabs());
   ASSERT_EQ(num_loading_tabs, NumNeedReloadTabs());
   EXPECT_EQ(0, NumBrokenTabs());
 
   int initial_num_tabs = browser->tab_count();
   int initial_active_tab = browser->active_index();
@@ skipping 21 matching lines @@
 
 void CaptivePortalBrowserTest::FailLoadsWithoutLogin(Browser* browser,
                                                      int num_loading_tabs) {
   ASSERT_EQ(num_loading_tabs, NumLoadingTabs());
   ASSERT_EQ(0, NumNeedReloadTabs());
   EXPECT_EQ(num_loading_tabs, NumBrokenTabs());
 
   int initial_num_tabs = browser->tab_count();
   int login_tab = browser->active_index();
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser->GetActiveTabContents()));
-  ASSERT_TRUE(IsLoginTab(browser->GetActiveTabContents()));
+            GetStateOfTabReloader(chrome::GetActiveTabContents(browser)));
+  ASSERT_TRUE(IsLoginTab(chrome::GetActiveTabContents(browser)));
 
   CaptivePortalObserver portal_observer(browser->profile());
   MultiNavigationObserver navigation_observer;
   // Connection(s) finally time out.  There should have already been a call
   // to wait for the requests to be issued.
   URLRequestTimeoutOnDemandJob::FailJobs(num_loading_tabs);
 
   navigation_observer.WaitForNavigations(num_loading_tabs);
 
   // No captive portal checks should have ocurred or be pending, and there
   // should be no new tabs.
   EXPECT_EQ(0, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser));
   EXPECT_EQ(initial_num_tabs, browser->tab_count());
 
   EXPECT_EQ(0, NumNeedReloadTabs());
   EXPECT_EQ(0, NumLoadingTabs());
   EXPECT_EQ(num_loading_tabs, NumBrokenTabs());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser->GetActiveTabContents()));
-  EXPECT_TRUE(IsLoginTab(browser->GetActiveTabContents()));
+            GetStateOfTabReloader(chrome::GetActiveTabContents(browser)));
+  EXPECT_TRUE(IsLoginTab(chrome::GetActiveTabContents(browser)));
   EXPECT_EQ(login_tab, browser->active_index());
 
   EXPECT_EQ(0, navigation_observer.NumNavigationsForTab(
-                   browser->GetWebContentsAt(login_tab)));
+                   chrome::GetWebContentsAt(browser, login_tab)));
 }
 
 void CaptivePortalBrowserTest::SetSlowSSLLoadTime(
     CaptivePortalTabReloader* tab_reloader,
     base::TimeDelta slow_ssl_load_time) {
   tab_reloader->set_slow_ssl_load_time(slow_ssl_load_time);
 }
 
 CaptivePortalTabReloader* CaptivePortalBrowserTest::GetTabReloader(
     TabContents* tab_contents) const {
@@ skipping 124 matching lines @@
             GetStateOfTabReloaderAt(browser(), 0));
 
   Login(incognito_browser, 1, 0);
   FailLoadsAfterLogin(incognito_browser, 1);
 
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 0));
 
   EXPECT_EQ(0, navigation_observer.NumNavigationsForTab(
-                   browser()->GetWebContentsAt(0)));
+                   chrome::GetWebContentsAt(browser(), 0)));
   EXPECT_EQ(0, non_incognito_portal_observer.num_results_received());
 }
 
 // The captive portal page is opened before the SSL page times out,
 // but the user logs in only after the page times out.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, LoginSlow) {
   SlowLoadBehindCaptivePortal(browser(), true);
   FailLoadsWithoutLogin(browser(), 1);
   Login(browser(), 0, 1);
 }
 
 // Checks the unlikely case that the tab times out before the timer triggers.
 // This most likely won't happen, but should still work:
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, LoginFastTimeout) {
   FastTimeoutBehindCaptivePortal(browser(), true);
   Login(browser(), 0, 1);
 }
 
 // Tries navigating both the tab that encounters an SSL timeout and the
 // login tab twice, only logging in the second time.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, LoginExtraNavigations) {
   FastTimeoutBehindCaptivePortal(browser(), true);
 
   // Activate the timed out tab and navigate it to a timeout again.
-  browser()->ActivateTabAt(0, true);
+  chrome::ActivateTabAt(browser(), 0, true);
   FastTimeoutBehindCaptivePortal(browser(), false);
 
   // Activate and navigate the captive portal tab.  This should not trigger a
   // reload of the tab with the error.
-  browser()->ActivateTabAt(1, true);
+  chrome::ActivateTabAt(browser(), 1, true);
   NavigateLoginTab(browser(), 0, 1);
 
   // Simulate logging in.
   Login(browser(), 0, 1);
 }
 
 // After the first SSL timeout, closes the login tab and makes sure it's opened
 // it again on a second timeout.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, CloseLoginTab) {
   // First load starts, opens a login tab, and then times out.
@@ skipping 25 matching lines @@
           FilePath(FILE_PATH_LITERAL("title2.html"))),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   ASSERT_EQ(3, browser()->tab_count());
   EXPECT_FALSE(CheckPending(browser()));
   EXPECT_EQ(0, portal_observer.num_results_received());
   EXPECT_EQ(1, NumLoadingTabs());
   EXPECT_EQ(1, navigation_observer.num_navigations());
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   browser()->GetWebContentsAt(2)));
+                   chrome::GetWebContentsAt(browser(), 2)));
   ASSERT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(browser(), 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser()->GetTabContentsAt(1)));
-  ASSERT_TRUE(IsLoginTab(browser()->GetTabContentsAt(1)));
+    GetStateOfTabReloader(chrome::GetTabContentsAt(browser(), 1)));
+  ASSERT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser(), 1)));
   ASSERT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 2));
   ASSERT_EQ(2, browser()->active_index());
 
   SlowLoadBehindCaptivePortal(browser(), false);
 
-  browser()->ActivateTabAt(1, true);
+  chrome::ActivateTabAt(browser(), 1, true);
   Login(browser(), 2, 0);
   FailLoadsAfterLogin(browser(), 2);
 }
 
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, AbortLoad) {
   SlowLoadBehindCaptivePortal(browser(), true);
 
   // Abandon the request.
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
   URLRequestTimeoutOnDemandJob::AbandonJobs(1);
 
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver navigation_observer;
 
   // Switch back to the hung tab from the login tab, and abort the navigation.
-  browser()->ActivateTabAt(0, true);
+  chrome::ActivateTabAt(browser(), 0, true);
   chrome::Stop(browser());
   navigation_observer.WaitForNavigations(1);
 
   EXPECT_EQ(0, NumBrokenTabs());
   EXPECT_EQ(0, portal_observer.num_results_received());
   EXPECT_FALSE(CheckPending(browser()));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 0));
 
-  browser()->ActivateTabAt(1, true);
+  chrome::ActivateTabAt(browser(), 1, true);
   Login(browser(), 0, 0);
 }
 
 // Checks the case where the timed out tab is successfully navigated before
 // logging in.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, NavigateBrokenTab) {
   // Go to the error page.
   SlowLoadBehindCaptivePortal(browser(), true);
   FailLoadsWithoutLogin(browser(), 1);
 
   // Navigate the error tab to a non-error page.
-  browser()->ActivateTabAt(0, true);
+  chrome::ActivateTabAt(browser(), 0, true);
   ui_test_utils::NavigateToURL(browser(),
                                URLRequestMockHTTPJob::GetMockUrl(
                                    FilePath(FILE_PATH_LITERAL("title2.html"))));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 0));
 
   // Simulate logging in.
-  browser()->ActivateTabAt(1, true);
+  chrome::ActivateTabAt(browser(), 1, true);
   Login(browser(), 0, 0);
 }
 
 // Navigates a broken, but still loading, tab to another such page before
 // logging in.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest,
                        NavigateBrokenToTimeoutTabWhileLoading) {
   // Go to the error page.
   SlowLoadBehindCaptivePortal(browser(), true);
 
   // Abandon the request.
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
   URLRequestTimeoutOnDemandJob::AbandonJobs(1);
 
   CaptivePortalTabReloader* tab_reloader =
-      GetTabReloader(browser()->GetTabContentsAt(0));
+      GetTabReloader(chrome::GetTabContentsAt(browser(), 0));
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver navigation_observer;
 
   // Navigate the error tab to another slow loading page.  Can't have
   // ui_test_utils do the navigation because it will wait for loading tabs to
   // stop loading before navigating.
-  browser()->ActivateTabAt(0, true);
+  chrome::ActivateTabAt(browser(), 0, true);
   browser()->OpenURL(content::OpenURLParams(GURL(kMockHttpsUrl),
                                             content::Referrer(),
                                             CURRENT_TAB,
                                             content::PAGE_TRANSITION_TYPED,
                                             false));
   navigation_observer.WaitForNavigations(1);
   portal_observer.WaitForResults(1);
   EXPECT_FALSE(CheckPending(browser()));
   EXPECT_EQ(1, NumLoadingTabs());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(browser(), 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser()->GetTabContentsAt(1)));
-  ASSERT_TRUE(IsLoginTab(browser()->GetTabContentsAt(1)));
+            GetStateOfTabReloader(chrome::GetTabContentsAt(browser(), 1)));
+  ASSERT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser(), 1)));
 
   // Need to make sure the request has been issued before logging in.
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
 
   // Simulate logging in.
-  browser()->ActivateTabAt(1, true);
+  chrome::ActivateTabAt(browser(), 1, true);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromDays(1));
   Login(browser(), 1, 0);
 
   // Timeout occurs, and page is automatically reloaded.
   FailLoadsAfterLogin(browser(), 1);
 }
 
 // Checks that navigating a timed out tab back clears its state.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, GoBack) {
   // Navigate to a working page.
   ui_test_utils::NavigateToURL(
       browser(),
       URLRequestMockHTTPJob::GetMockUrl(
           FilePath(FILE_PATH_LITERAL("title2.html"))));
 
   // Go to the error page.
   SlowLoadBehindCaptivePortal(browser(), true);
   FailLoadsWithoutLogin(browser(), 1);
 
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver navigation_observer;
 
   // Activate the error page tab again and go back.
-  browser()->ActivateTabAt(0, true);
+  chrome::ActivateTabAt(browser(), 0, true);
   chrome::GoBack(browser(), CURRENT_TAB);
   navigation_observer.WaitForNavigations(1);
 
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   browser()->GetWebContentsAt(0)));
+                chrome::GetWebContentsAt(browser(), 0)));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 0));
   EXPECT_EQ(0, portal_observer.num_results_received());
 }
 
 // Checks that navigating back to a timeout triggers captive portal detection.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, GoBackToTimeout) {
   // Disable captive portal detection so the first navigation doesn't open a
   // login tab.
   EnableCaptivePortalDetection(browser()->profile(), false);
 
   SlowLoadNoCaptivePortal(browser(), RESULT_INTERNET_CONNECTED);
 
   // Navigate to a working page.
   ui_test_utils::NavigateToURL(browser(),
                                URLRequestMockHTTPJob::GetMockUrl(
                                    FilePath(FILE_PATH_LITERAL("title2.html"))));
   ASSERT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 0));
 
   EnableCaptivePortalDetection(browser()->profile(), true);
 
   CaptivePortalTabReloader* tab_reloader =
-      GetTabReloader(browser()->GetActiveTabContents());
+      GetTabReloader(chrome::GetActiveTabContents(browser()));
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   // Go to the error page.
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser()->profile());
   chrome::GoBack(browser(), CURRENT_TAB);
 
   // Wait for both the check triggered by the broken tab and the first load
   // of the login tab, and for the login tab to stop loading.
   portal_observer.WaitForResults(2);
   navigation_observer.WaitForNavigations(1);
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
 
   EXPECT_EQ(2, portal_observer.num_results_received());
   ASSERT_FALSE(CheckPending(browser()));
   ASSERT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
 
   ASSERT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
-            GetStateOfTabReloader(browser()->GetTabContentsAt(0)));
+            GetStateOfTabReloader(chrome::GetTabContentsAt(browser(), 0)));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser()->GetTabContentsAt(1)));
-  ASSERT_TRUE(IsLoginTab(browser()->GetTabContentsAt(1)));
+            GetStateOfTabReloader(chrome::GetTabContentsAt(browser(), 1)));
+  ASSERT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser(), 1)));
 
   ASSERT_EQ(2, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   browser()->GetWebContentsAt(1)));
+                   chrome::GetWebContentsAt(browser(), 1)));
   EXPECT_EQ(1, NumLoadingTabs());
 
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromDays(1));
   Login(browser(), 1, 0);
   FailLoadsAfterLogin(browser(), 1);
 }
 
 // Checks that reloading a timeout triggers captive portal detection.
 // Much like the last test, though the captive portal is disabled before
 // the inital navigation, rather than captive portal detection.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, ReloadTimeout) {
   URLRequestMockCaptivePortalJobFactory::SetBehindCaptivePortal(false);
 
   // Do the first navigation while not behind a captive portal.
   CaptivePortalObserver portal_observer(browser()->profile());
   ui_test_utils::NavigateToURL(browser(), GURL(kMockHttpsUrl));
   ASSERT_EQ(0, portal_observer.num_results_received());
   ASSERT_EQ(1, browser()->tab_count());
 
   // A captive portal spontaneously appears.
   URLRequestMockCaptivePortalJobFactory::SetBehindCaptivePortal(true);
 
   CaptivePortalTabReloader* tab_reloader =
-      GetTabReloader(browser()->GetActiveTabContents());
+      GetTabReloader(chrome::GetActiveTabContents(browser()));
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   MultiNavigationObserver navigation_observer;
-  browser()->GetActiveWebContents()->GetController().Reload(true);
+  chrome::GetActiveWebContents(browser())->GetController().Reload(true);
 
   // Wait for the login tab to open, and the two captive portal results from
   // opening an it.
   portal_observer.WaitForResults(2);
   navigation_observer.WaitForNavigations(1);
   // Make sure the request has been issued.
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
 
   ASSERT_EQ(2, portal_observer.num_results_received());
   ASSERT_FALSE(CheckPending(browser()));
   ASSERT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
 
   ASSERT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
-            GetStateOfTabReloader(browser()->GetTabContentsAt(0)));
+      GetStateOfTabReloader(chrome::GetTabContentsAt(browser(), 0)));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
-            GetStateOfTabReloader(browser()->GetTabContentsAt(1)));
-  ASSERT_TRUE(IsLoginTab(browser()->GetTabContentsAt(1)));
+            GetStateOfTabReloader(chrome::GetTabContentsAt(browser(), 1)));
+  ASSERT_TRUE(IsLoginTab(chrome::GetTabContentsAt(browser(), 1)));
 
   ASSERT_EQ(2, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   browser()->GetWebContentsAt(1)));
+                   chrome::GetWebContentsAt(browser(), 1)));
   EXPECT_EQ(1, NumLoadingTabs());
 
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta::FromDays(1));
   Login(browser(), 1, 0);
   FailLoadsAfterLogin(browser(), 1);
 }
 
 // Checks the case where there are two windows, and there's an SSL timeout in
 // the background one.
 // Disabled:  http://crbug.com/134357
@@ skipping 36 matching lines @@
 
   // Make sure the active window hasn't changed, and its new tab is
   // active.
   ASSERT_EQ(active_browser,
             browser::FindTabbedBrowser(browser()->profile(), true));
   ASSERT_EQ(1, active_browser->active_index());
 
   // Check that the only two navigated tabs were the new error tab in the
   // backround windows, and the login tab in the active window.
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   inactive_browser->GetWebContentsAt(1)));
+                   chrome::GetWebContentsAt(inactive_browser, 1)));
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
-                   active_browser->GetWebContentsAt(1)));
+                   chrome::GetWebContentsAt(active_browser, 1)));
   EXPECT_EQ(0, NumLoadingTabs());
 
   // Check captive portal test results.
   portal_observer.WaitForResults(2);
   ASSERT_EQ(RESULT_BEHIND_CAPTIVE_PORTAL,
             portal_observer.captive_portal_result());
   EXPECT_EQ(2, portal_observer.num_results_received());
 
   // Check the inactive browser.
   EXPECT_EQ(2, inactive_browser->tab_count());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(inactive_browser, 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(inactive_browser, 1));
 
   // Check the active browser.
   ASSERT_EQ(2, active_browser->tab_count());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(active_browser, 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(active_browser, 1));
-  EXPECT_TRUE(IsLoginTab(active_browser->GetTabContentsAt(1)));
+  EXPECT_TRUE(IsLoginTab(chrome::GetTabContentsAt(active_browser, 1)));
 
   // Simulate logging in.
   Login(active_browser, 0, 1);
 }
 
 }  // namespace captive_portal