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

chrome/browser/sessions/tab_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/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.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/find_bar/find_notification_details.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.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/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "net/test/test_server.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFindOptions.h"
 
 class TabRestoreTest : public InProcessBrowserTest {
  public:
-  TabRestoreTest() : InProcessBrowserTest() {
+  TabRestoreTest()
+      : native_browser_list(chrome::BrowserListImpl::GetInstance(
+                                chrome::HOST_DESKTOP_TYPE_NATIVE)) {
     url1_ = ui_test_utils::GetTestUrl(
         base::FilePath().AppendASCII("session_history"),
         base::FilePath().AppendASCII("bot1.html"));
     url2_ = ui_test_utils::GetTestUrl(
         base::FilePath().AppendASCII("session_history"),
         base::FilePath().AppendASCII("bot2.html"));
   }
 
  protected:
   Browser* GetBrowser(int index) {
-    CHECK(static_cast<int>(BrowserList::size()) > index);
-    return *(BrowserList::begin() + index);
+
+    CHECK(static_cast<int>(native_browser_list->size()) > index);
+    return native_browser_list->get(index);
   }
 
   // Adds tabs to the given browser, all navigated to url1_. Returns
   // the final number of tabs.
   int AddSomeTabs(Browser* browser, int how_many) {
     int starting_tab_count = browser->tab_strip_model()->count();
 
     for (int i = 0; i < how_many; ++i) {
       ui_test_utils::NavigateToURLWithDisposition(
           browser, url1_, NEW_FOREGROUND_TAB,
@@ skipping 14 matching lines @@
   }
 
   // Uses the undo-close-tab accelerator to undo a close-tab or close-window
   // operation. The newly restored tab is expected to appear in the
   // window at index |expected_window_index|, at the |expected_tabstrip_index|,
   // and to be active. If |expected_window_index| is equal to the number of
   // current windows, the restored tab is expected to be created in a new
   // window (since the index is 0-based).
   void RestoreTab(int expected_window_index,
                   int expected_tabstrip_index) {
-    int window_count = static_cast<int>(BrowserList::size());
+    int window_count = static_cast<int>(native_browser_list->size());
     ASSERT_GT(window_count, 0);
 
     bool expect_new_window = (expected_window_index == window_count);
 
     Browser* browser;
     if (expect_new_window) {
-      browser = *(BrowserList::begin());
+      browser = native_browser_list->get(0);
     } else {
       browser = GetBrowser(expected_window_index);
     }
     int tab_count = browser->tab_strip_model()->count();
     ASSERT_GT(tab_count, 0);
 
     // Restore the tab.
     content::WindowedNotificationObserver tab_added_observer(
         chrome::NOTIFICATION_TAB_PARENTED,
         content::NotificationService::AllSources());
     content::WindowedNotificationObserver tab_loaded_observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     chrome::RestoreTab(browser);
     tab_added_observer.Wait();
     tab_loaded_observer.Wait();
 
     if (expect_new_window) {
-      int new_window_count = static_cast<int>(BrowserList::size());
+      int new_window_count = static_cast<int>(native_browser_list->size());
       EXPECT_EQ(++window_count, new_window_count);
       browser = GetBrowser(expected_window_index);
     } else {
       EXPECT_EQ(++tab_count, browser->tab_strip_model()->count());
     }
 
     // Get a handle to the restored tab.
     ASSERT_GT(browser->tab_strip_model()->count(), expected_tabstrip_index);
 
     // Ensure that the tab and window are active.
@@ skipping 17 matching lines @@
 
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::Source<content::NavigationController>(controller));
     observer.Wait();
   }
 
   GURL url1_;
   GURL url2_;
 
+  // The TabRestore browser tests only uses the native desktop for now.
+  const chrome::BrowserListImpl* native_browser_list;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(TabRestoreTest);
 };
 
 // Close the end tab in the current window, then restore it. The tab should be
 // in its original position, and active.
 IN_PROC_BROWSER_TEST_F(TabRestoreTest, Basic) {
   int starting_tab_count = browser()->tab_strip_model()->count();
   int tab_count = AddSomeTabs(browser(), 1);
 
@@ skipping 38 matching lines @@
 
   // Close one in the middle
   int closed_tab_index = starting_tab_count + 1;
   CloseTab(closed_tab_index);
   EXPECT_EQ(starting_tab_count + 2, browser()->tab_strip_model()->count());
 
   // Create a new browser.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
-  EXPECT_EQ(2u, BrowserList::size());
+  EXPECT_EQ(2u, native_browser_list->size());
 
   // Restore tab into original browser.
   ASSERT_NO_FATAL_FAILURE(RestoreTab(0, closed_tab_index));
 
   // And make sure everything looks right.
   EXPECT_EQ(starting_tab_count + 3, browser()->tab_strip_model()->count());
   EXPECT_EQ(closed_tab_index, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(url1_,
             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 }
 
 // Close a tab, open a new window, close the first window, then restore the
 // tab. It should be in a new window.
 // If this becomes flaky, use http://crbug.com/14774
 IN_PROC_BROWSER_TEST_F(TabRestoreTest, DISABLED_BasicRestoreFromClosedWindow) {
   // Navigate to url1 then url2.
   ui_test_utils::NavigateToURL(browser(), url1_);
   ui_test_utils::NavigateToURL(browser(), url2_);
 
   // Create a new browser.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
-  EXPECT_EQ(2u, BrowserList::size());
+  EXPECT_EQ(2u, native_browser_list->size());
 
   // Close the final tab in the first browser.
   content::WindowedNotificationObserver window_observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   CloseTab(0);
   window_observer.Wait();
 
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0));
 
@@ skipping 41 matching lines @@
 
   // Close one in the middle
   int closed_tab_index = starting_tab_count + 1;
   CloseTab(closed_tab_index);
   EXPECT_EQ(starting_tab_count + 2, browser()->tab_strip_model()->count());
 
   // Create a new browser.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
-  EXPECT_EQ(2u, BrowserList::size());
+  EXPECT_EQ(2u, native_browser_list->size());
 
   // Close the first browser.
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   chrome::CloseWindow(browser());
   observer.Wait();
-  EXPECT_EQ(1u, BrowserList::size());
+  EXPECT_EQ(1u, native_browser_list->size());
 
   // Restore the first window. The expected_tabstrip_index (second argument)
   // indicates the expected active tab.
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, starting_tab_count + 1));
   Browser* browser = GetBrowser(1);
   EXPECT_EQ(starting_tab_count + 2, browser->tab_strip_model()->count());
 
   // Restore the closed tab.
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, closed_tab_index));
   EXPECT_EQ(starting_tab_count + 3, browser->tab_strip_model()->count());
   EXPECT_EQ(url1_,
             browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 }
 
 // Open a window with two tabs, close both (closing the window), then restore
 // both. Make sure both restored tabs are in the same window.
 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreIntoSameWindow) {
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url1_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   // Navigate the rightmost one to url2_ for easier identification.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url2_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Create a new browser.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
-  EXPECT_EQ(2u, BrowserList::size());
+  EXPECT_EQ(2u, native_browser_list->size());
 
   // Close all but one tab in the first browser, left to right.
   while (browser()->tab_strip_model()->count() > 1)
     CloseTab(0);
 
   // Close the last tab, closing the browser.
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   CloseTab(0);
   observer.Wait();
-  EXPECT_EQ(1u, BrowserList::size());
+  EXPECT_EQ(1u, native_browser_list->size());
 
   // Restore the last-closed tab into a new window.
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0));
   Browser* browser = GetBrowser(1);
   EXPECT_EQ(1, browser->tab_strip_model()->count());
   EXPECT_EQ(url2_,
             browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 
   // Restore the next-to-last-closed tab into the same window.
   ASSERT_NO_FATAL_FAILURE(RestoreTab(1, 0));
@@ skipping 104 matching lines @@
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), http_url2, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   EXPECT_FALSE(chrome::CanGoForward(browser()));
   EXPECT_EQ(http_url2,
             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreWindow) {
   // Create a new window.
-  size_t window_count = BrowserList::size();
+  size_t window_count = native_browser_list->size();
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), GURL(chrome::kChromeUINewTabURL), NEW_WINDOW,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_BROWSER);
-  EXPECT_EQ(++window_count, BrowserList::size());
+  EXPECT_EQ(++window_count, native_browser_list->size());
 
   // Create two more tabs, one with url1, the other url2.
   int initial_tab_count = browser()->tab_strip_model()->count();
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url1_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), url2_, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Close the window.
   content::WindowedNotificationObserver close_window_observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   chrome::CloseWindow(browser());
   close_window_observer.Wait();
-  EXPECT_EQ(window_count - 1, BrowserList::size());
+  EXPECT_EQ(window_count - 1, native_browser_list->size());
 
   // Restore the window.
   content::WindowedNotificationObserver open_window_observer(
       chrome::NOTIFICATION_BROWSER_OPENED,
       content::NotificationService::AllSources());
   content::WindowedNotificationObserver load_stop_observer(
       content::NOTIFICATION_LOAD_STOP,
       content::NotificationService::AllSources());
-  chrome::RestoreTab(*BrowserList::begin());
+  chrome::RestoreTab(native_browser_list->get(0));
   open_window_observer.Wait();
-  EXPECT_EQ(window_count, BrowserList::size());
+  EXPECT_EQ(window_count, native_browser_list->size());
 
   Browser* browser = GetBrowser(1);
   EXPECT_EQ(initial_tab_count + 2, browser->tab_strip_model()->count());
   load_stop_observer.Wait();
 
   content::WebContents* restored_tab =
       browser->tab_strip_model()->GetWebContentsAt(initial_tab_count);
   EnsureTabFinishedRestoring(restored_tab);
   EXPECT_EQ(url1_, restored_tab->GetURL());
 
@@ skipping 50 matching lines @@
   EnsureTabFinishedRestoring(tab);
   ASSERT_EQ(http_url, tab->GetURL());
 
   // Go back, and see if content is as expected.
   GoBack(browser());
   EXPECT_GT(
       ui_test_utils::FindInPage(tab, ASCIIToUTF16("webkit"), true, false, NULL,
                                 NULL),
       0);
 }