TabContentsWrapper -> TabContents, part 53.

chrome/browser/ui/browser_navigator_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 "chrome/browser/ui/browser_navigator_browsertest.h"
 
 #include "base/command_line.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/autocomplete/autocomplete_edit.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 
@@ skipping 42 matching lines @@
 
 Browser* BrowserNavigatorTest::CreateEmptyBrowserForApp(Browser::Type type,
                                                         Profile* profile) {
   Browser* browser = Browser::CreateWithParams(
       Browser::CreateParams::CreateForApp(
           Browser::TYPE_POPUP, "Test", gfx::Rect(), profile));
   browser->AddBlankTab(true);
   return browser;
 }
 
-TabContentsWrapper* BrowserNavigatorTest::CreateTabContents() {
+TabContents* BrowserNavigatorTest::CreateTabContents() {
   return Browser::TabContentsFactory(
       browser()->profile(),
       NULL,
       MSG_ROUTING_NONE,
-      browser()->GetSelectedWebContents(),
+      browser()->GetActiveWebContents(),
       NULL);
 }
 
 void BrowserNavigatorTest::RunSuppressTest(WindowOpenDisposition disposition) {
-  GURL old_url = browser()->GetSelectedWebContents()->GetURL();
+  GURL old_url = browser()->GetActiveWebContents()->GetURL();
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = disposition;
   browser::Navigate(&p);
 
   // Nothing should have happened as a result of Navigate();
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(1u, BrowserList::size());
-  EXPECT_EQ(old_url, browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(old_url, browser()->GetActiveWebContents()->GetURL());
 }
 
 void BrowserNavigatorTest::RunUseNonIncognitoWindowTest(const GURL& url) {
   Browser* incognito_browser = CreateIncognitoBrowser();
 
   EXPECT_EQ(2u, BrowserList::size());
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(1, incognito_browser->tab_count());
 
   // Navigate to the page.
   browser::NavigateParams p(MakeNavigateParams(incognito_browser));
   p.disposition = SINGLETON_TAB;
   p.url = url;
   p.window_action = browser::NavigateParams::SHOW_WINDOW;
   browser::Navigate(&p);
 
   // This page should be opened in browser() window.
   EXPECT_NE(incognito_browser, p.browser);
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(2, browser()->tab_count());
-  EXPECT_EQ(url, browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(url, browser()->GetActiveWebContents()->GetURL());
 }
 
 void BrowserNavigatorTest::RunDoNothingIfIncognitoIsForcedTest(
     const GURL& url) {
   Browser* browser = CreateIncognitoBrowser();
 
   // Set kIncognitoModeAvailability to FORCED.
   PrefService* prefs1 = browser->profile()->GetPrefs();
   prefs1->SetInteger(prefs::kIncognitoModeAvailability,
                      IncognitoModePrefs::FORCED);
   PrefService* prefs2 = browser->profile()->GetOriginalProfile()->GetPrefs();
   prefs2->SetInteger(prefs::kIncognitoModeAvailability,
                      IncognitoModePrefs::FORCED);
 
   // Navigate to the page.
   browser::NavigateParams p(MakeNavigateParams(browser));
   p.disposition = OFF_THE_RECORD;
   p.url = url;
   p.window_action = browser::NavigateParams::SHOW_WINDOW;
   browser::Navigate(&p);
 
   // The page should not be opened.
   EXPECT_EQ(browser, p.browser);
   EXPECT_EQ(1, browser->tab_count());
   EXPECT_EQ(GURL(chrome::kAboutBlankURL),
-            browser->GetSelectedWebContents()->GetURL());
+            browser->GetActiveWebContents()->GetURL());
 }
 
 void BrowserNavigatorTest::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB: {
       ++this->created_tab_contents_count_;
       break;
     }
     default:
       break;
   }
 }
 
 
 namespace {
 
 // This test verifies that when a navigation occurs within a tab, the tab count
 // of the Browser remains the same and the current tab bears the loaded URL.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_CurrentTab) {
   ui_test_utils::NavigateToURL(browser(), GetGoogleURL());
-  EXPECT_EQ(GetGoogleURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetGoogleURL(), browser()->GetActiveWebContents()->GetURL());
   // We should have one window with one tab.
   EXPECT_EQ(1u, BrowserList::size());
   EXPECT_EQ(1, browser()->tab_count());
 }
 
 // This test verifies that a singleton tab is refocused if one is already opened
 // in another or an existing window, or added if it is not.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_SingletonTabExisting) {
   GURL singleton_url1("http://maps.google.com/");
 
   // Register for a notification if an additional tab_contents was instantiated.
   // Opening a Singleton tab that is already opened should not be opening a new
-  // tab nor be creating a new TabContentsWrapper object.
+  // tab nor be creating a new TabContents object.
   content::NotificationRegistrar registrar;
 
   // As the registrar object goes out of scope, this will get unregistered
   registrar.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
                 content::NotificationService::AllSources());
 
   browser()->AddSelectedTabWithURL(
       singleton_url1, content::PAGE_TRANSITION_LINK);
   browser()->AddSelectedTabWithURL(
       GetGoogleURL(), content::PAGE_TRANSITION_LINK);
@@ skipping 87 matching lines @@
   // We should now have 2 tabs, the 2nd one selected.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(2, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
 }
 
 // This test verifies that when a navigation results in a foreground tab, the
 // tab count of the Browser increases and the selected tab shifts to the new
 // foreground tab.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewForegroundTab) {
-  WebContents* old_contents = browser()->GetSelectedWebContents();
+  WebContents* old_contents = browser()->GetActiveWebContents();
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_FOREGROUND_TAB;
   browser::Navigate(&p);
-  EXPECT_NE(old_contents, browser()->GetSelectedWebContents());
-  EXPECT_EQ(browser()->GetSelectedTabContentsWrapper(), p.target_contents);
+  EXPECT_NE(old_contents, browser()->GetActiveWebContents());
+  EXPECT_EQ(browser()->GetActiveTabContents(), p.target_contents);
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 // This test verifies that when a navigation results in a background tab, the
 // tab count of the Browser increases but the selected tab remains the same.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewBackgroundTab) {
-  WebContents* old_contents = browser()->GetSelectedWebContents();
+  WebContents* old_contents = browser()->GetActiveWebContents();
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_BACKGROUND_TAB;
   browser::Navigate(&p);
-  WebContents* new_contents = browser()->GetSelectedWebContents();
+  WebContents* new_contents = browser()->GetActiveWebContents();
   // The selected tab should have remained unchanged, since the new tab was
   // opened in the background.
   EXPECT_EQ(old_contents, new_contents);
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 // This test verifies that when a navigation requiring a new foreground tab
 // occurs in a Browser that cannot host multiple tabs, the new foreground tab
 // is created in an existing compatible Browser.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
@@ skipping 288 matching lines @@
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_SaveToDisk) {
   RunSuppressTest(SAVE_TO_DISK);
 }
 
 // This test verifies that no navigation action occurs when
 // WindowOpenDisposition = IGNORE_ACTION.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_IgnoreAction) {
   RunSuppressTest(IGNORE_ACTION);
 }
 
-// This tests adding a foreground tab with a predefined TabContentsWrapper.
+// This tests adding a foreground tab with a predefined TabContents.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, TargetContents_ForegroundTab) {
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_FOREGROUND_TAB;
   p.target_contents = CreateTabContents();
   browser::Navigate(&p);
 
   // Navigate() should have opened the contents in a new foreground in the
   // current Browser.
   EXPECT_EQ(browser(), p.browser);
-  EXPECT_EQ(browser()->GetSelectedTabContentsWrapper(), p.target_contents);
+  EXPECT_EQ(browser()->GetActiveTabContents(), p.target_contents);
 
   // We should have one window, with two tabs.
   EXPECT_EQ(1u, BrowserList::size());
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 #if defined(OS_WIN)
-// This tests adding a popup with a predefined TabContentsWrapper.
+// This tests adding a popup with a predefined TabContents.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, DISABLED_TargetContents_Popup) {
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_POPUP;
   p.target_contents = CreateTabContents();
   p.window_bounds = gfx::Rect(10, 10, 500, 500);
   browser::Navigate(&p);
 
   // Navigate() should have opened a new popup window.
   EXPECT_NE(browser(), p.browser);
   EXPECT_TRUE(p.browser->is_type_popup());
   EXPECT_FALSE(p.browser->is_app());
 
   // The web platform is weird. The window bounds specified in
   // |p.window_bounds| are used as follows:
   // - the origin is used to position the window
-  // - the size is used to size the TabContentsWrapper of the window.
+  // - the size is used to size the TabContents of the window.
   // As such the position of the resulting window will always match
   // p.window_bounds.origin(), but its size will not. We need to match
   // the size against the selected tab's view's container size.
   // Only Windows positions the window according to |p.window_bounds.origin()| -
   // on Mac the window is offset from the opener and on Linux it always opens
   // at 0,0.
   EXPECT_EQ(p.window_bounds.origin(),
             p.browser->window()->GetRestoredBounds().origin());
   // All platforms should respect size however provided width > 400 (Mac has a
   // minimum window width of 400).
@@ skipping 16 matching lines @@
   // insertion index preference is reflected in common cases.
   browser::NavigateParams p(MakeNavigateParams());
   p.disposition = NEW_FOREGROUND_TAB;
   p.tabstrip_index = 0;
   p.tabstrip_add_types = TabStripModel::ADD_FORCE_INDEX;
   browser::Navigate(&p);
 
   // Navigate() should have inserted a new tab at slot 0 in the tabstrip.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(0, browser()->tab_strip_model()->GetIndexOfTabContents(
-      static_cast<const TabContentsWrapper*>(p.target_contents)));
+      static_cast<const TabContents*>(p.target_contents)));
 
   // We should have one window - the browser() provided by the framework.
   EXPECT_EQ(1u, BrowserList::size());
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 // This test verifies that constructing params with a NULL browser has
 // the same result as navigating to a new foreground tab in the (only)
 // active browser. Tests are the same as for Disposition_NewForegroundTab.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, NullBrowser_NewForegroundTab) {
-  WebContents* old_contents = browser()->GetSelectedWebContents();
+  WebContents* old_contents = browser()->GetActiveWebContents();
   // Navigate with a NULL browser.
   browser::NavigateParams p(MakeNavigateParams(NULL));
   p.disposition = NEW_FOREGROUND_TAB;
   p.profile = browser()->profile();
   browser::Navigate(&p);
 
   // Navigate() should have found browser() and create a new tab.
   EXPECT_EQ(browser(), p.browser);
-  EXPECT_NE(old_contents, browser()->GetSelectedWebContents());
-  EXPECT_EQ(browser()->GetSelectedTabContentsWrapper(), p.target_contents);
+  EXPECT_NE(old_contents, browser()->GetActiveWebContents());
+  EXPECT_EQ(browser()->GetActiveTabContents(), p.target_contents);
   EXPECT_EQ(2, browser()->tab_count());
 }
 
 // This test verifies that constructing params with a NULL browser and
 // a specific profile matches the specified profile.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, NullBrowser_MatchProfile) {
   // Create a new browser with using the incognito profile.
   Browser* incognito =
       Browser::Create(browser()->profile()->GetOffTheRecordProfile());
 
   // Navigate with a NULL browser and the incognito profile.
   browser::NavigateParams p(MakeNavigateParams(NULL));
   p.disposition = NEW_FOREGROUND_TAB;
   p.profile = incognito->profile();
   browser::Navigate(&p);
 
   // Navigate() should have found incognito, not browser().
   EXPECT_EQ(incognito, p.browser);
-  EXPECT_EQ(incognito->GetSelectedTabContentsWrapper(), p.target_contents);
+  EXPECT_EQ(incognito->GetActiveTabContents(), p.target_contents);
   EXPECT_EQ(1, incognito->tab_count());
 }
 
 // This test verifies that constructing params with a NULL browser and
 // disposition = NEW_WINDOW always opens exactly one new window.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, NullBrowser_NewWindow) {
   browser::NavigateParams p(MakeNavigateParams(NULL));
   p.disposition = NEW_WINDOW;
   p.profile = browser()->profile();
   browser::Navigate(&p);
@@ skipping 29 matching lines @@
   p.window_action = browser::NavigateParams::SHOW_WINDOW;
   p.path_behavior = browser::NavigateParams::IGNORE_AND_NAVIGATE;
   browser::Navigate(&p);
 
   // The last tab should now be selected and navigated to the sub-page of the
   // URL.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(3, browser()->tab_count());
   EXPECT_EQ(2, browser()->active_index());
   EXPECT_EQ(GetContentSettingsURL(),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // This test verifies that constructing params with disposition = SINGLETON_TAB
 // and IGNORE_AND_NAVIGATE opens an existing tab with the matching URL (minus
 // the path) which is navigated to the specified URL.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabExisting_IgnorePath) {
   GURL singleton_url1(GetSettingsURL());
   browser()->AddSelectedTabWithURL(
       singleton_url1, content::PAGE_TRANSITION_LINK);
@@ skipping 12 matching lines @@
   p.window_action = browser::NavigateParams::SHOW_WINDOW;
   p.path_behavior = browser::NavigateParams::IGNORE_AND_NAVIGATE;
   browser::Navigate(&p);
 
   // The middle tab should now be selected and navigated to the sub-page of the
   // URL.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(3, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
   EXPECT_EQ(GetContentSettingsURL(),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // This test verifies that constructing params with disposition = SINGLETON_TAB
 // and IGNORE_AND_NAVIGATE opens an existing tab with the matching URL (minus
 // the path) which is navigated to the specified URL.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabExistingSubPath_IgnorePath) {
   GURL singleton_url1(GetContentSettingsURL());
   browser()->AddSelectedTabWithURL(
       singleton_url1, content::PAGE_TRANSITION_LINK);
@@ skipping 12 matching lines @@
   p.window_action = browser::NavigateParams::SHOW_WINDOW;
   p.path_behavior = browser::NavigateParams::IGNORE_AND_NAVIGATE;
   browser::Navigate(&p);
 
   // The middle tab should now be selected and navigated to the sub-page of the
   // URL.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(3, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
   EXPECT_EQ(GetClearBrowsingDataURL(),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // This test verifies that constructing params with disposition = SINGLETON_TAB
 // and IGNORE_AND_STAY_PUT opens an existing tab with the matching URL (minus
 // the path).
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabExistingSubPath_IgnorePath2) {
   GURL singleton_url1(GetContentSettingsURL());
   browser()->AddSelectedTabWithURL(
       singleton_url1, content::PAGE_TRANSITION_LINK);
@@ skipping 11 matching lines @@
   p.url = GetClearBrowsingDataURL();
   p.window_action = browser::NavigateParams::SHOW_WINDOW;
   p.path_behavior = browser::NavigateParams::IGNORE_AND_STAY_PUT;
   browser::Navigate(&p);
 
   // The middle tab should now be selected.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(3, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
   EXPECT_EQ(singleton_url1,
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // This test verifies that constructing params with disposition = SINGLETON_TAB
 // and IGNORE_AND_NAVIGATE will update the current tab's URL if the currently
 // selected tab is a match but has a different path.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabFocused_IgnorePath) {
   GURL singleton_url_current(GetContentSettingsURL());
   browser()->AddSelectedTabWithURL(
       singleton_url_current, content::PAGE_TRANSITION_LINK);
@@ skipping 10 matching lines @@
   p.url = singleton_url_target;
   p.window_action = browser::NavigateParams::SHOW_WINDOW;
   p.path_behavior = browser::NavigateParams::IGNORE_AND_NAVIGATE;
   browser::Navigate(&p);
 
   // The second tab should still be selected, but navigated to the new path.
   EXPECT_EQ(browser(), p.browser);
   EXPECT_EQ(2, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
   EXPECT_EQ(singleton_url_target,
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // This test verifies that constructing params with disposition = SINGLETON_TAB
 // and IGNORE_AND_NAVIGATE will open an existing matching tab with a different
 // query.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabExisting_IgnoreQuery) {
   int initial_tab_count = browser()->tab_count();
   GURL singleton_url_current("chrome://settings/internet");
   browser()->AddSelectedTabWithURL(
@@ skipping 37 matching lines @@
   params.disposition = OFF_THE_RECORD;
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser::Navigate(&params);
     observer.Wait();
   }
 
   EXPECT_EQ(1u, BrowserList::size());
-  EXPECT_EQ(GetSettingsURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetSettingsURL(), browser()->GetActiveWebContents()->GetURL());
 }
 
 // Settings page is expected to always open in normal mode regardless
 // of whether the user is trying to open it in incognito mode or not.
 // This test verifies that if incognito mode is forced (by policy), settings
 // page doesn't open at all.
 // Disabled until fixed for uber settings: http://crbug.com/111243
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
     DISABLED_Disposition_Settings_DoNothingIfIncognitoIsForced) {
   RunDoNothingIfIncognitoIsForcedTest(GetSettingsURL());
@@ skipping 28 matching lines @@
 // doesn't open at all.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SyncPromo_DoNothingIfIncognitoIsForced) {
   RunDoNothingIfIncognitoIsForcedTest(GURL(chrome::kChromeUISyncPromoURL));
 }
 
 // This test makes sure a crashed singleton tab reloads from a new navigation.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateToCrashedSingletonTab) {
   GURL singleton_url(GetContentSettingsURL());
-  TabContentsWrapper* wrapper = browser()->AddSelectedTabWithURL(
+  TabContents* tab_contents = browser()->AddSelectedTabWithURL(
       singleton_url, content::PAGE_TRANSITION_LINK);
-  WebContents* web_contents = wrapper->web_contents();
+  WebContents* web_contents = tab_contents->web_contents();
 
   // We should have one browser with 2 tabs, the 2nd selected.
   EXPECT_EQ(1u, BrowserList::size());
   EXPECT_EQ(2, browser()->tab_count());
   EXPECT_EQ(1, browser()->active_index());
 
   // Kill the singleton tab.
   web_contents->SetIsCrashed(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
   EXPECT_TRUE(web_contents->IsCrashed());
 
@@ skipping 11 matching lines @@
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromDefaultToOptionsInSameTab) {
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenOptionsDialog();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
-  EXPECT_EQ(GetSettingsURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetSettingsURL(), browser()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromBlankToOptionsInSameTab) {
   browser::NavigateParams p(MakeNavigateParams());
   p.url = GURL(chrome::kAboutBlankURL);
   ui_test_utils::NavigateToURL(&p);
 
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenOptionsDialog();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
-  EXPECT_EQ(GetSettingsURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetSettingsURL(), browser()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromNTPToOptionsInSameTab) {
   browser::NavigateParams p(MakeNavigateParams());
   p.url = GURL(chrome::kChromeUINewTabURL);
   ui_test_utils::NavigateToURL(&p);
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenOptionsDialog();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
-  EXPECT_EQ(GetSettingsURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetSettingsURL(), browser()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromPageToOptionsInNewTab) {
   browser::NavigateParams p(MakeNavigateParams());
   ui_test_utils::NavigateToURL(&p);
-  EXPECT_EQ(GetGoogleURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetGoogleURL(), browser()->GetActiveWebContents()->GetURL());
   EXPECT_EQ(1u, BrowserList::size());
   EXPECT_EQ(1, browser()->tab_count());
 
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenOptionsDialog();
     observer.Wait();
   }
   EXPECT_EQ(2, browser()->tab_count());
-  EXPECT_EQ(GetSettingsURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetSettingsURL(), browser()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromNTPToOptionsSingleton) {
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenOptionsDialog();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
 
   browser()->NewTab();
   EXPECT_EQ(2, browser()->tab_count());
 
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenOptionsDialog();
     observer.Wait();
   }
   EXPECT_EQ(2, browser()->tab_count());
-  EXPECT_EQ(GetSettingsURL(), browser()->GetSelectedWebContents()->GetURL());
+  EXPECT_EQ(GetSettingsURL(), browser()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromNTPToOptionsPageInSameTab) {
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenClearBrowsingDataDialog();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(GetClearBrowsingDataURL(),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 
   browser()->NewTab();
   EXPECT_EQ(2, browser()->tab_count());
 
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenClearBrowsingDataDialog();
     observer.Wait();
   }
   EXPECT_EQ(2, browser()->tab_count());
   EXPECT_EQ(GetClearBrowsingDataURL(),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // Times out on mac, fails on linux.
 // http://crbug.com/119779
 #if defined(OS_MACOSX) || defined(OS_LINUX)
 #define MAYBE_NavigateFromOtherTabToSingletonOptions DISABLED_NavigateFromOtherTabToSingletonOptions
 #else
 #define MAYBE_NavigateFromOtherTabToSingletonOptions NavigatorFrameOtherTabToSingletonOptions
 #endif
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
@@ skipping 16 matching lines @@
 
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenOptionsDialog();
     observer.Wait();
   }
   EXPECT_EQ(2, browser()->tab_count());
   EXPECT_EQ(GetSettingsURL(),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // Tests that when a new tab is opened from the omnibox, the focus is moved from
 // the omnibox for the current tab.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromOmniboxIntoNewTab) {
   GURL url("http://www.google.com/");
   GURL url2("http://maps.google.com/");
 
   // Navigate to url.
@@ skipping 31 matching lines @@
                        DISABLED_NavigateFromDefaultToHistoryInSameTab) {
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->ShowHistoryTab();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(GURL(chrome::kChromeUIHistoryFrameURL),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromDefaultToBookmarksInSameTab) {
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->OpenBookmarkManager();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(GURL(chrome::kChromeUIBookmarksURL),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        NavigateFromDefaultToDownloadsInSameTab) {
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     browser()->ShowDownloadsTab();
     observer.Wait();
   }
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(GURL(chrome::kChromeUIDownloadsURL),
-            browser()->GetSelectedWebContents()->GetURL());
+            browser()->GetActiveWebContents()->GetURL());
 }
 
 // This test makes sure any link in a crashed panel page navigates to a tabbed
 // window.
 class PanelBrowserNavigatorTest : public BrowserNavigatorTest {
  protected:
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(switches::kEnablePanels);
   }
 };
@@ skipping 17 matching lines @@
   // Navigate() should have navigated in the existing panel window.
   EXPECT_EQ(panel_browser, p.browser);
 
   // We should now have two windows, the browser() provided by the framework and
   // the panel window we opened earlier. The tabbed browser window has 1 tab.
   EXPECT_EQ(2u, BrowserList::size());
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_EQ(1, panel_browser->tab_count());
 
   // Kill the panel page.
-  WebContents* web_contents = panel_browser->GetSelectedWebContents();
+  WebContents* web_contents = panel_browser->GetActiveWebContents();
   web_contents->SetIsCrashed(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
   EXPECT_TRUE(web_contents->IsCrashed());
 
   // Navigate to the page.
   browser::NavigateParams p2(MakeNavigateParams(panel_browser));
-  p2.source_contents = panel_browser->GetSelectedTabContentsWrapper();
+  p2.source_contents = panel_browser->GetActiveTabContents();
   p2.url = url2;
   p2.disposition = CURRENT_TAB;
   browser::Navigate(&p2);
 
   // Navigate() should have opened a new tab in the existing tabbed window.
   EXPECT_EQ(browser(), p2.browser);
 
   // We should now have two windows, the browser() provided by the framework and
   // the panel window we opened earlier. The tabbed browser window has 2 tabs.
   EXPECT_EQ(2u, BrowserList::size());
   EXPECT_EQ(2, browser()->tab_count());
   EXPECT_EQ(1, panel_browser->tab_count());
 }
 
 } // namespace