Get rid of native-desktop-only BrowserList:: iterator methods in tests.

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/time.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/session_service_test_helper.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/sessions/session_types_test_helper.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_list_impl.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"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "sync/protocol/session_specifics.pb.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 class SessionRestoreTest : public InProcessBrowserTest {
+ public:
+  SessionRestoreTest()
+      : native_browser_list(chrome::BrowserListImpl::GetInstance(
+                                chrome::HOST_DESKTOP_TYPE_NATIVE)) {
+  }
+
  protected:
 #if defined(OS_CHROMEOS)
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // TODO(nkostylev): Investigate if we can remove this switch.
     command_line->AppendSwitch(switches::kCreateBrowserOnStartupForTests);
     InProcessBrowserTest::SetUpCommandLine(command_line);
   }
 #endif
 
   virtual void SetUpOnMainThread() OVERRIDE {
@@ skipping 76 matching lines @@
 
   void GoForward(Browser* browser) {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     chrome::GoForward(browser, CURRENT_TAB);
     observer.Wait();
   }
 
   void AssertOneWindowWithOneTab(Browser* browser) {
-    ASSERT_EQ(1u, BrowserList::size());
+    ASSERT_EQ(1u, native_browser_list->size());
     ASSERT_EQ(1, browser->tab_strip_model()->count());
   }
 
   int RenderProcessHostCount() {
     content::RenderProcessHost::iterator hosts =
         content::RenderProcessHost::AllHostsIterator();
     int count = 0;
     while (!hosts.IsAtEnd()) {
       if (hosts.GetCurrentValue()->HasConnection())
         count++;
       hosts.Advance();
     }
     return count;
   }
 
   GURL url1_;
   GURL url2_;
   GURL url3_;
+
+  // The SessionRestore browser tests only uses the native desktop for now.
+  const chrome::BrowserListImpl* native_browser_list;
 };
 
 #if defined(OS_CHROMEOS)
 // Verify that session restore does not occur when a user opens a browser window
 // when no other browser windows are open on ChromeOS.
 // TODO(pkotwicz): Add test which doesn't open incognito browser once
 // disable-zero-browsers-open-for-tests is removed.
 // (http://crbug.com/119175)
 // TODO(pkotwicz): Mac should have the behavior outlined by this test. It should
 // not do session restore if an incognito window is already open.
@@ skipping 353 matching lines @@
     tab2.SetFromSyncData(sync_data, base::Time::Now());
   }
   window.tabs.push_back(&tab2);
 
   session.push_back(static_cast<const SessionWindow*>(&window));
   ui_test_utils::BrowserAddedObserver window_observer;
   SessionRestore::RestoreForeignSessionWindows(
       profile, browser()->host_desktop_type(), session.begin(), session.end());
   Browser* new_browser = window_observer.WaitForSingleNewBrowser();
   ASSERT_TRUE(new_browser);
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, native_browser_list->size());
   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
 
   content::WebContents* web_contents_1 =
       new_browser->tab_strip_model()->GetWebContentsAt(0);
   content::WebContents* web_contents_2 =
       new_browser->tab_strip_model()->GetWebContentsAt(1);
   ASSERT_EQ(url1, web_contents_1->GetURL());
   ASSERT_EQ(url2, web_contents_2->GetURL());
 
   // Check user agent override state.
@@ skipping 12 matching lines @@
   // 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(1u, native_browser_list->size());
   ASSERT_EQ(url2_,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
   GoBack(new_browser);
   ASSERT_EQ(url1_,
             new_browser->tab_strip_model()->GetActiveWebContents()->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(1u, native_browser_list->size());
   ASSERT_EQ(url2_,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
   GoForward(new_browser);
   ASSERT_EQ(url3_,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
   GoBack(new_browser);
   ASSERT_EQ(url2_,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 
   // Test renderer-initiated back/forward as well.
@@ skipping 12 matching lines @@
 
   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(1u, native_browser_list->size());
   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
 
   // Check that back and forward work as expected.
   ASSERT_EQ(cross_site_url,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 
   GoBack(new_browser);
   ASSERT_EQ(url1_,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 
@@ skipping 10 matching lines @@
 
 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(1u, native_browser_list->size());
   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
   ASSERT_EQ(url2_,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 
   ASSERT_EQ(url1_,
             new_browser->tab_strip_model()->GetWebContentsAt(0)->GetURL());
 }
 
 // Creates two tabs, closes one, quits and makes sure only one tab is restored.
@@ skipping 20 matching lines @@
   ui_test_utils::NavigateToURL(browser(), url1_);
 
   // Make sure we have one window.
   AssertOneWindowWithOneTab(browser());
 
   // Open a popup.
   Browser* popup = new Browser(
       Browser::CreateParams(Browser::TYPE_POPUP, browser()->profile(),
                             browser()->host_desktop_type()));
   popup->window()->Show();
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, native_browser_list->size());
 
   ui_test_utils::NavigateToURL(popup, url1_);
 
   // Simulate an exit by shuting down the session service. If we don't do this
   // the first window close is treated as though the user closed the window
   // and won't be restored.
   SessionServiceFactory::ShutdownForProfile(browser()->profile());
 
   // Restart and make sure we have two windows.
   QuitBrowserAndRestore(browser(), 1);
 
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, native_browser_list->size());
 
-  Browser* browser1 = *BrowserList::begin();
-  Browser* browser2 = *(++BrowserList::begin());
+  Browser* browser1 = native_browser_list->get(0);
+  Browser* browser2 = native_browser_list->get(1);
 
   Browser::Type type1 = browser1->type();
   Browser::Type type2 = browser2->type();
 
   // The order of whether the normal window or popup is first depends upon
   // activation order, which is not necessarily consistant across runs.
   if (type1 == Browser::TYPE_TABBED) {
     EXPECT_EQ(type2, Browser::TYPE_POPUP);
   } else {
     EXPECT_EQ(type1, Browser::TYPE_POPUP);
@@ skipping 15 matching lines @@
 
   // Launch an app.
   CommandLine app_launch_arguments = GetCommandLineForRelaunch();
   app_launch_arguments.AppendSwitchASCII(switches::kApp, url2_.spec());
 
   ui_test_utils::BrowserAddedObserver window_observer;
 
   base::LaunchProcess(app_launch_arguments, base::LaunchOptions(), NULL);
 
   Browser* app_window = window_observer.WaitForSingleNewBrowser();
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, native_browser_list->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->tab_strip_model()->GetActiveWebContents()->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());
+  ASSERT_EQ(2u, native_browser_list->size());
 
   // Close it.
-  Browser* new_window = *(++BrowserList::begin());
+  Browser* new_window = native_browser_list->get(1);
   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->tab_strip_model()->GetActiveWebContents()->GetURL());
@@ skipping 38 matching lines @@
       SetUserAgentOverride("override");
 
   // Create a tab without an overridden user agent.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url2_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Kill the original browser then open a new one to trigger a restore.
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
   ASSERT_EQ(1, new_browser->tab_strip_model()->active_index());
 
   // Confirm that the user agent overrides are properly set.
   EXPECT_EQ("override",
             new_browser->tab_strip_model()->GetWebContentsAt(0)->
                 GetUserAgentOverride());
   EXPECT_EQ("",
             new_browser->tab_strip_model()->GetWebContentsAt(1)->
                 GetUserAgentOverride());
@@ skipping 13 matching lines @@
       browser(), url2_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   ASSERT_EQ(1, browser()->tab_strip_model()->active_index());
   // Select the pinned tab.
   browser()->tab_strip_model()->ActivateTabAt(0, true);
   ASSERT_EQ(0, browser()->tab_strip_model()->active_index());
   Profile* profile = browser()->profile();
 
   // This will also initiate a session restore, but we're not interested in it.
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
   ASSERT_EQ(2, new_browser->tab_strip_model()->count());
   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
   // Close the pinned tab.
   chrome::CloseTab(new_browser);
   ASSERT_EQ(1, new_browser->tab_strip_model()->count());
   ASSERT_EQ(0, new_browser->tab_strip_model()->active_index());
   // Use the existing tab to navigate away, so that we can verify it was really
   // clobbered.
   ui_test_utils::NavigateToURL(new_browser, url3_);
 
@@ skipping 14 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(SessionRestoreTest, SessionStorage) {
   ui_test_utils::NavigateToURL(browser(), url1_);
   content::NavigationController* controller =
       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
   ASSERT_TRUE(controller->GetDefaultSessionStorageNamespace());
   std::string session_storage_persistent_id =
       controller->GetDefaultSessionStorageNamespace()->persistent_id();
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
   ASSERT_EQ(url1_,
             new_browser->tab_strip_model()->GetActiveWebContents()->GetURL());
   content::NavigationController* new_controller =
       &new_browser->tab_strip_model()->GetActiveWebContents()->GetController();
   ASSERT_TRUE(new_controller->GetDefaultSessionStorageNamespace());
   std::string restored_session_storage_persistent_id =
       new_controller->GetDefaultSessionStorageNamespace()->persistent_id();
   EXPECT_EQ(session_storage_persistent_id,
             restored_session_storage_persistent_id);
 }
@@ skipping 24 matching lines @@
   }
 
   // Check that the sessionStorage data is going to be persisted.
   content::NavigationController* controller =
       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
   EXPECT_TRUE(
       controller->GetDefaultSessionStorageNamespace()->should_persist());
 
   // Quit and restore. Check that no extra tabs were created.
   Browser* new_browser = QuitBrowserAndRestore(browser(), 1);
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
   EXPECT_EQ(1, new_browser->tab_strip_model()->count());
 }