Move tab functions off Browser into browser_tabstrip and browser_tabrestore.

chrome/browser/sessions/session_restore_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 "base/command_line.h"
 #include "base/file_path.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.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/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 152 matching lines @@
   CloseBrowserSynchronously(browser());
 
   // Create a new window, which should open NTP.
   ui_test_utils::BrowserAddedObserver browser_added_observer;
   chrome::NewWindow(incognito_browser);
   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 
   ASSERT_TRUE(new_browser);
   EXPECT_EQ(1, new_browser->tab_count());
   EXPECT_EQ(GURL(chrome::kChromeUINewTabURL),
-            new_browser->GetWebContentsAt(0)->GetURL());
+            chrome::GetWebContentsAt(new_browser, 0)->GetURL());
 }
 #endif  // OS_CHROMEOS
 
 #if !defined(OS_CHROMEOS)
 // This test does not apply to ChromeOS as it does not do session restore when
 // a new window is opened.
 
 #if defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
 // Crashes on Linux Views: http://crbug.com/39476
 #define MAYBE_RestoreOnNewWindowWithNoTabbedBrowsers \
@@ skipping 33 matching lines @@
   ui_test_utils::BrowserAddedObserver observer;
   chrome::NewWindow(popup);
   Browser* new_browser = observer.WaitForSingleNewBrowser();
 
   ASSERT_TRUE(new_browser != NULL);
 
   // The browser should only have one tab.
   ASSERT_EQ(1, new_browser->tab_count());
 
   // And the first url should be url.
-  EXPECT_EQ(url, new_browser->GetWebContentsAt(0)->GetURL());
+  EXPECT_EQ(url, chrome::GetWebContentsAt(new_browser, 0)->GetURL());
 }
 #endif  // !OS_CHROMEOS
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreIndividualTabFromWindow) {
   GURL url1(ui_test_utils::GetTestUrl(
       FilePath(FilePath::kCurrentDirectory),
       FilePath(FILE_PATH_LITERAL("title1.html"))));
   GURL url2(ui_test_utils::GetTestUrl(
       FilePath(FilePath::kCurrentDirectory),
       FilePath(FILE_PATH_LITERAL("title2.html"))));
   GURL url3(ui_test_utils::GetTestUrl(
       FilePath(FilePath::kCurrentDirectory),
       FilePath(FILE_PATH_LITERAL("title3.html"))));
 
   // Add and navigate three tabs.
   ui_test_utils::NavigateToURL(browser(), url1);
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
-    browser()->AddSelectedTabWithURL(url2, content::PAGE_TRANSITION_LINK);
+    chrome::AddSelectedTabWithURL(browser(), url2,
+                                  content::PAGE_TRANSITION_LINK);
     observer.Wait();
   }
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
-    browser()->AddSelectedTabWithURL(url3, content::PAGE_TRANSITION_LINK);
+    chrome::AddSelectedTabWithURL(browser(), url3,
+                                  content::PAGE_TRANSITION_LINK);
     observer.Wait();
   }
 
   TabRestoreService* service =
       TabRestoreServiceFactory::GetForProfile(browser()->profile());
   service->ClearEntries();
 
   browser()->window()->Close();
 
   // Expect a window with three tabs.
@@ skipping 74 matching lines @@
   // open.
   CloseBrowserSynchronously(browser());
 
   // Create a new window, which should trigger session restore.
   ui_test_utils::BrowserAddedObserver browser_added_observer;
   chrome::NewWindow(incognito_browser);
   Browser* new_browser = browser_added_observer.WaitForSingleNewBrowser();
 
   // The first tab should have 'url' as its url.
   ASSERT_TRUE(new_browser);
-  EXPECT_EQ(url, new_browser->GetWebContentsAt(0)->GetURL());
+  EXPECT_EQ(url, chrome::GetWebContentsAt(new_browser, 0)->GetURL());
 }
 #endif  // !OS_CHROMEOS
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignTab) {
   GURL url1("http://google.com");
   GURL url2("http://google2.com");
   TabNavigation nav1(0, url1, content::Referrer(), ASCIIToUTF16("one"),
         std::string(), content::PAGE_TRANSITION_TYPED);
   TabNavigation nav2(0, url2, content::Referrer(), ASCIIToUTF16("two"),
         std::string(), content::PAGE_TRANSITION_TYPED);
 
   // Set up the restore data.
   SessionTab tab;
   tab.tab_visual_index = 0;
   tab.current_navigation_index = 1;
   tab.pinned = false;
   tab.navigations.push_back(nav1);
   tab.navigations.push_back(nav2);
 
   ASSERT_EQ(1, browser()->tab_count());
 
   // Restore in the current tab.
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     SessionRestore::RestoreForeignSessionTab(
-        browser()->GetActiveWebContents(), tab, CURRENT_TAB);
+        chrome::GetActiveWebContents(browser()), tab, CURRENT_TAB);
     observer.Wait();
   }
   ASSERT_EQ(1, browser()->tab_count());
   VerifyNavigationEntries(
-      browser()->GetWebContentsAt(0)->GetController(), url1, url2);
+      chrome::GetWebContentsAt(browser(), 0)->GetController(), url1, url2);
 
   // Restore in a new tab.
   {
     ui_test_utils::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     SessionRestore::RestoreForeignSessionTab(
-        browser()->GetActiveWebContents(), tab, NEW_BACKGROUND_TAB);
+        chrome::GetActiveWebContents(browser()), tab, NEW_BACKGROUND_TAB);
     observer.Wait();
   }
   ASSERT_EQ(2, browser()->tab_count());
   ASSERT_EQ(0, browser()->active_index());
   VerifyNavigationEntries(
-      browser()->GetWebContentsAt(1)->GetController(), url1, url2);
+      chrome::GetWebContentsAt(browser(), 1)->GetController(), url1, url2);
 
   // Restore in a new window.
   ui_test_utils::BrowserAddedObserver browser_observer;
   SessionRestore::RestoreForeignSessionTab(
-      browser()->GetActiveWebContents(), tab, NEW_WINDOW);
+      chrome::GetActiveWebContents(browser()), tab, NEW_WINDOW);
   Browser* new_browser = browser_observer.WaitForSingleNewBrowser();
 
   ASSERT_EQ(1, new_browser->tab_count());
   VerifyNavigationEntries(
-      new_browser->GetWebContentsAt(0)->GetController(), url1, url2);
+      chrome::GetWebContentsAt(new_browser, 0)->GetController(), url1, url2);
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoreForeignSession) {
   Profile* profile = browser()->profile();
 
   GURL url1("http://google.com");
   GURL url2("http://google2.com");
   TabNavigation nav1(0, url1, content::Referrer(), ASCIIToUTF16("one"),
         std::string(), content::PAGE_TRANSITION_TYPED);
   TabNavigation nav2(0, url2, content::Referrer(), ASCIIToUTF16("two"),
@@ skipping 18 matching lines @@
 
   session.push_back(static_cast<const SessionWindow*>(&window));
   ui_test_utils::BrowserAddedObserver window_observer;
   SessionRestore::RestoreForeignSessionWindows(
       profile, session.begin(), session.end());
   Browser* new_browser = window_observer.WaitForSingleNewBrowser();
   ASSERT_TRUE(new_browser);
   ASSERT_EQ(2u, BrowserList::size());
   ASSERT_EQ(2, new_browser->tab_count());
 
-  ASSERT_EQ(url1, new_browser->GetWebContentsAt(0)->GetURL());
-  ASSERT_EQ(url2, new_browser->GetWebContentsAt(1)->GetURL());
+  ASSERT_EQ(url1, chrome::GetWebContentsAt(new_browser, 0)->GetURL());
+  ASSERT_EQ(url2, chrome::GetWebContentsAt(new_browser, 1)->GetURL());
 
   // The SessionWindow destructor deletes the tabs, so we have to clear them
   // here to avoid a crash.
   window.tabs.clear();
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, Basic) {
   ui_test_utils::NavigateToURL(browser(), url1_);
   ui_test_utils::NavigateToURL(browser(), url2_);
 
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
   ASSERT_EQ(1u, BrowserList::size());
-  ASSERT_EQ(url2_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url2_, chrome::GetActiveWebContents(new_browser)->GetURL());
   GoBack(new_browser);
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, RestoresForwardAndBackwardNavs) {
   ui_test_utils::NavigateToURL(browser(), url1_);
   ui_test_utils::NavigateToURL(browser(), url2_);
   ui_test_utils::NavigateToURL(browser(), url3_);
 
   GoBack(browser());
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
   ASSERT_EQ(1u, BrowserList::size());
-  ASSERT_EQ(url2_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url2_, chrome::GetActiveWebContents(new_browser)->GetURL());
   GoForward(new_browser);
-  ASSERT_EQ(url3_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url3_, chrome::GetActiveWebContents(new_browser)->GetURL());
   GoBack(new_browser);
-  ASSERT_EQ(url2_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url2_, chrome::GetActiveWebContents(new_browser)->GetURL());
 
   // Test renderer-initiated back/forward as well.
   GURL go_back_url("javascript:history.back();");
   ui_test_utils::NavigateToURL(new_browser, go_back_url);
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
 }
 
 // Tests that the SiteInstances used for entries in a restored tab's history
 // are given appropriate max page IDs, so that going back to a restored
 // cross-site page and then forward again works.  (Bug 1204135)
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
                        RestoresCrossSiteForwardAndBackwardNavs) {
   ASSERT_TRUE(test_server()->Start());
 
   GURL cross_site_url(test_server()->GetURL("files/title2.html"));
 
   // Visit URLs on different sites.
   ui_test_utils::NavigateToURL(browser(), url1_);
   ui_test_utils::NavigateToURL(browser(), cross_site_url);
   ui_test_utils::NavigateToURL(browser(), url2_);
 
   GoBack(browser());
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
   ASSERT_EQ(1u, BrowserList::size());
   ASSERT_EQ(1, new_browser->tab_count());
 
   // Check that back and forward work as expected.
-  ASSERT_EQ(cross_site_url, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(cross_site_url,
+            chrome::GetActiveWebContents(new_browser)->GetURL());
 
   GoBack(new_browser);
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
 
   GoForward(new_browser);
-  ASSERT_EQ(cross_site_url, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(cross_site_url,
+            chrome::GetActiveWebContents(new_browser)->GetURL());
 
   // Test renderer-initiated back/forward as well.
   GURL go_forward_url("javascript:history.forward();");
   ui_test_utils::NavigateToURL(new_browser, go_forward_url);
-  ASSERT_EQ(url2_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url2_, chrome::GetActiveWebContents(new_browser)->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoTabsSecondSelected) {
   ui_test_utils::NavigateToURL(browser(), url1_);
 
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url2_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   Browser* new_browser = QuitBrowserAndRestore(browser(), 2);
 
   ASSERT_EQ(1u, BrowserList::size());
   ASSERT_EQ(2, new_browser->tab_count());
   ASSERT_EQ(1, new_browser->active_index());
-  ASSERT_EQ(url2_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url2_, chrome::GetActiveWebContents(new_browser)->GetURL());
 
-  ASSERT_EQ(url1_, new_browser->GetWebContentsAt(0)->GetURL());
+  ASSERT_EQ(url1_, chrome::GetWebContentsAt(new_browser, 0)->GetURL());
 }
 
 // Creates two tabs, closes one, quits and makes sure only one tab is restored.
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, ClosedTabStaysClosed) {
   ui_test_utils::NavigateToURL(browser(), url1_);
 
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url2_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   chrome::CloseTab(browser());
 
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 
   AssertOneWindowWithOneTab(new_browser);
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
 }
 
 // Test to verify that the print preview tab is not restored.
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, DontRestorePrintPreviewTabTest) {
   ui_test_utils::NavigateToURL(browser(), url1_);
 
   // Append the print preview tab.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUIPrintURL), NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Restart and make sure we have only one window with one tab and the url
   // is url1_.
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 
   AssertOneWindowWithOneTab(new_browser);
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
 }
 
 // Creates a tabbed browser and popup and makes sure we restore both.
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, NormalAndPopup) {
   if (!browser_defaults::kRestorePopups)
     return;  // Test only applicable if restoring popups.
 
   ui_test_utils::NavigateToURL(browser(), url1_);
 
   // Make sure we have one window.
@@ skipping 57 matching lines @@
   ASSERT_EQ(2u, BrowserList::size());
 
   // Close the first window. The only window left is the App window.
   CloseBrowserSynchronously(browser());
 
   // Restore the session, which should bring back the first window with url1_.
   Browser* new_browser = QuitBrowserAndRestore(app_window, 1);
 
   AssertOneWindowWithOneTab(new_browser);
 
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
 }
 
 #endif  // !defined(OS_CHROMEOS) && !defined(OS_MACOSX)
 
 // Creates two windows, closes one, restores, make sure only one window open.
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, TwoWindowsCloseOneRestoreOnlyOne) {
   ui_test_utils::NavigateToURL(browser(), url1_);
 
   // Open a second window.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kAboutBlankURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
 
   ASSERT_EQ(2u, BrowserList::size());
 
   // Close it.
   Browser* new_window = *(++BrowserList::begin());
   CloseBrowserSynchronously(new_window);
 
   // Restart and make sure we have only one window with one tab and the url
   // is url1_.
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
 
   AssertOneWindowWithOneTab(new_browser);
 
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
 }
 
 // Make sure after a restore the number of processes matches that of the number
 // of processes running before the restore. This creates a new tab so that
 // we should have two new tabs running.  (This test will pass in both
 // process-per-site and process-per-site-instance, because we treat the new tab
 // as a special case in process-per-site-instance so that it only ever uses one
 // process.)
 //
 // Flaky: http://code.google.com/p/chromium/issues/detail?id=52022
@@ skipping 53 matching lines @@
 
   // Restore the session again, globbering the existing tab.
   SessionRestore::RestoreSession(
       profile, new_browser,
       SessionRestore::CLOBBER_CURRENT_TAB | SessionRestore::SYNCHRONOUS,
       std::vector<GURL>());
 
   // The pinned tab is the selected tab.
   ASSERT_EQ(2, new_browser->tab_count());
   EXPECT_EQ(0, new_browser->active_index());
-  EXPECT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
-  EXPECT_EQ(url2_, new_browser->GetWebContentsAt(1)->GetURL());
+  EXPECT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
+  EXPECT_EQ(url2_, chrome::GetWebContentsAt(new_browser, 1)->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorage) {
   ui_test_utils::NavigateToURL(browser(), url1_);
   const content::NavigationController& controller =
-      browser()->GetActiveWebContents()->GetController();
+      chrome::GetActiveWebContents(browser())->GetController();
   ASSERT_TRUE(controller.GetSessionStorageNamespace());
   std::string session_storage_persistent_id =
       controller.GetSessionStorageNamespace()->persistent_id();
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
   ASSERT_EQ(1u, BrowserList::size());
-  ASSERT_EQ(url1_, new_browser->GetActiveWebContents()->GetURL());
+  ASSERT_EQ(url1_, chrome::GetActiveWebContents(new_browser)->GetURL());
   const content::NavigationController& new_controller =
-      new_browser->GetActiveWebContents()->GetController();
+      chrome::GetActiveWebContents(new_browser)->GetController();
   ASSERT_TRUE(new_controller.GetSessionStorageNamespace());
   std::string restored_session_storage_persistent_id =
       new_controller.GetSessionStorageNamespace()->persistent_id();
   EXPECT_EQ(session_storage_persistent_id,
             restored_session_storage_persistent_id);
 }