Explicitly hardcode tab_drag_controller_interactive_uitest.cc to use the native desktop list.

chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.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/views/tabs/tab_drag_controller_interactive_uitest.h"
 
 #include "ash/wm/property_util.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/browser_list.h"
+#include "chrome/browser/ui/browser_iterator.h"
+#include "chrome/browser/ui/browser_list_impl.h"
+#include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "chrome/test/base/ui_controls.h"
@@ skipping 108 matching lines @@
 }
 
 }  // namespace test
 
 using test::GetCenterInScreenCoordinates;
 using test::SetID;
 using test::ResetIDs;
 using test::IDString;
 using test::GetTabStripForBrowser;
 
-TabDragControllerTest::TabDragControllerTest() {
+TabDragControllerTest::TabDragControllerTest()
+    : native_browser_list(chrome::BrowserListImpl::GetInstance(
+                              chrome::HOST_DESKTOP_TYPE_NATIVE)) {
 }
 
 TabDragControllerTest::~TabDragControllerTest() {
 }
 
 void TabDragControllerTest::StopAnimating(TabStrip* tab_strip) {
   tab_strip->StopAnimating(true);
 }
 
 void TabDragControllerTest::AddTabAndResetBrowser(Browser* browser) {
@@ skipping 284 matching lines @@
   if (input_source() == INPUT_SOURCE_MOUSE) {
     ASSERT_TRUE(ReleaseMouseAsync());
     QuitWhenNotDragging();
   }
 
   // Should no longer be dragging.
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   // There should now be another browser.
-  ASSERT_EQ(2u, BrowserList::size());
-  Browser* new_browser = *(++BrowserList::begin());
+  ASSERT_EQ(2u, native_browser_list->size());
+  Browser* new_browser = native_browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
 
   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
 
   // The bounds of the initial window should not have changed.
   EXPECT_EQ(initial_bounds.ToString(),
             browser()->window()->GetBounds().ToString());
@@ skipping 92 matching lines @@
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
 
   EXPECT_TRUE(GetTrackedByWorkspace(browser()));
 }
 
 namespace {
 
-void DeleteSourceDetachedStep2(WebContents* tab) {
-  ASSERT_EQ(2u, BrowserList::size());
-  Browser* new_browser = *(++BrowserList::begin());
+void DeleteSourceDetachedStep2(WebContents* tab,
+                               const chrome::BrowserListImpl* browser_list) {
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = browser_list->get(1);
   // This ends up closing the source window.
   delete tab;
   // Cancel the drag.
   ui_controls::SendKeyPress(new_browser->window()->GetNativeWindow(),
                             ui::VKEY_ESCAPE, false, false, false, false);
 }
 
 }  // namespace
 
 // Detaches a tab and while detached deletes a tab from the source so that the
 // source window closes then presses escape to cancel the drag.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        DeleteSourceDetached) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   WebContents* to_delete = browser()->tab_strip_model()->GetWebContentsAt(1);
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
-      base::Bind(&DeleteSourceDetachedStep2, to_delete)));
+      base::Bind(&DeleteSourceDetachedStep2, to_delete, native_browser_list)));
   QuitWhenNotDragging();
 
   // Should not be dragging.
-  ASSERT_EQ(1u, BrowserList::size());
-  Browser* new_browser = *BrowserList::begin();
+  ASSERT_EQ(1u, native_browser_list->size());
+  Browser* new_browser = native_browser_list->get(0);
   ASSERT_FALSE(GetTabStripForBrowser(new_browser)->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
 
   EXPECT_TRUE(GetTrackedByWorkspace(new_browser));
 }
 
 namespace {
 
-void PressEscapeWhileDetachedStep2() {
-  ASSERT_EQ(2u, BrowserList::size());
-  Browser* new_browser = *(++BrowserList::begin());
+void PressEscapeWhileDetachedStep2(
+    const chrome::BrowserListImpl* browser_list) {
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = browser_list->get(1);
   ui_controls::SendKeyPress(
       new_browser->window()->GetNativeWindow(), ui::VKEY_ESCAPE, false, false,
       false, false);
 }
 
 }  // namespace
 
 // This is disabled until NativeViewHost::Detach really detaches.
 // Detaches a tab and while detached presses escape to revert the drag.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        PressEscapeWhileDetached) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
-      base::Bind(&PressEscapeWhileDetachedStep2)));
+      base::Bind(&PressEscapeWhileDetachedStep2, native_browser_list)));
   QuitWhenNotDragging();
 
   // Should not be dragging.
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   // And there should only be one window.
-  EXPECT_EQ(1u, BrowserList::size());
+  EXPECT_EQ(1u, native_browser_list->size());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 }
 
 namespace {
 
-void DragAllStep2(DetachToBrowserTabDragControllerTest* test) {
+void DragAllStep2(DetachToBrowserTabDragControllerTest* test,
+                  const chrome::BrowserListImpl* browser_list) {
   // Should only be one window.
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, browser_list->size());
   if (test->input_source() == INPUT_SOURCE_TOUCH) {
     ASSERT_TRUE(test->ReleaseInput());
   } else {
     ASSERT_TRUE(test->ReleaseMouseAsync());
   }
 }
 
 }  // namespace
 
 // Selects multiple tabs and starts dragging the window.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest, DragAll) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   browser()->tab_strip_model()->AddTabAtToSelection(0);
   browser()->tab_strip_model()->AddTabAtToSelection(1);
 
   // Move to the first tab and drag it enough so that it would normally
   // detach.
   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
-      base::Bind(&DragAllStep2, this)));
+      base::Bind(&DragAllStep2, this, native_browser_list)));
   QuitWhenNotDragging();
 
   // Should not be dragging.
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   // And there should only be one window.
-  EXPECT_EQ(1u, BrowserList::size());
+  EXPECT_EQ(1u, native_browser_list->size());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   EXPECT_TRUE(GetTrackedByWorkspace(browser()));
 }
 
 namespace {
 
 // Invoked from the nested message loop.
 void DragAllToSeparateWindowStep2(DetachToBrowserTabDragControllerTest* test,
                                   TabStrip* attached_tab_strip,
-                                  TabStrip* target_tab_strip) {
+                                  TabStrip* target_tab_strip,
+                                  const chrome::BrowserListImpl* browser_list) {
   ASSERT_TRUE(attached_tab_strip->IsDragSessionActive());
   ASSERT_FALSE(target_tab_strip->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, browser_list->size());
 
   // Drag to target_tab_strip. This should stop the nested loop from dragging
   // the window.
   gfx::Point target_point(target_tab_strip->width() - 1,
                           target_tab_strip->height() / 2);
   views::View::ConvertPointToScreen(target_tab_strip, &target_point);
   ASSERT_TRUE(test->DragInputToAsync(target_point));
 }
 
 }  // namespace
@@ skipping 13 matching lines @@
   browser()->tab_strip_model()->AddTabAtToSelection(0);
   browser()->tab_strip_model()->AddTabAtToSelection(1);
 
   // Move to the first tab and drag it enough so that it detaches, but not
   // enough that it attaches to browser2.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
-      base::Bind(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2)));
+      base::Bind(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2,
+                 native_browser_list)));
   QuitWhenNotDragging();
 
   // Should now be attached to tab_strip2.
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
 
   // Release the mouse, stopping the drag session.
   ASSERT_TRUE(ReleaseInput());
   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("100 0 1", IDString(browser2->tab_strip_model()));
 
   EXPECT_TRUE(GetTrackedByWorkspace(browser2));
 }
 
 namespace {
 
 // Invoked from the nested message loop.
 void DragAllToSeparateWindowAndCancelStep2(
     DetachToBrowserTabDragControllerTest* test,
     TabStrip* attached_tab_strip,
-    TabStrip* target_tab_strip) {
+    TabStrip* target_tab_strip,
+    const chrome::BrowserListImpl* browser_list) {
   ASSERT_TRUE(attached_tab_strip->IsDragSessionActive());
   ASSERT_FALSE(target_tab_strip->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, browser_list->size());
 
   // Drag to target_tab_strip. This should stop the nested loop from dragging
   // the window.
   gfx::Point target_point(target_tab_strip->width() - 1,
                           target_tab_strip->height() / 2);
   views::View::ConvertPointToScreen(target_tab_strip, &target_point);
   ASSERT_TRUE(test->DragInputToAsync(target_point));
 }
 
 }  // namespace
@@ skipping 15 matching lines @@
   browser()->tab_strip_model()->AddTabAtToSelection(1);
 
   // Move to the first tab and drag it enough so that it detaches, but not
   // enough that it attaches to browser2.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
                   base::Bind(&DragAllToSeparateWindowAndCancelStep2, this,
-                             tab_strip, tab_strip2)));
+                             tab_strip, tab_strip2, native_browser_list)));
   QuitWhenNotDragging();
 
   // Should now be attached to tab_strip2.
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
 
   // Cancel the drag.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
       browser2, ui::VKEY_ESCAPE, false, false, false, false));
 
   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("100 0 1", IDString(browser2->tab_strip_model()));
 
   // browser() will have been destroyed, but browser2 should remain.
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
 
   EXPECT_TRUE(GetTrackedByWorkspace(browser2));
 }
 
 // Creates two browsers, drags from first into the second in such a way that
 // no detaching should happen.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        DragDirectlyToSecondWindow) {
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
@@ skipping 48 matching lines @@
   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   const gfx::Rect initial_bounds(browser2->window()->GetBounds());
 
   // Move to the first tab and drag it enough so that it detaches, but not
   // enough that it attaches to browser2.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
-      base::Bind(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2)));
+      base::Bind(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2,
+                 native_browser_list)));
   QuitWhenNotDragging();
 
   // Should now be attached to tab_strip2.
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
 
   // Release the mouse, stopping the drag session.
   ASSERT_TRUE(ReleaseInput());
   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("100 0", IDString(browser2->tab_strip_model()));
 
   EXPECT_TRUE(GetTrackedByWorkspace(browser2));
   // Make sure that the window is still managed and not user moved.
   EXPECT_TRUE(IsWindowPositionManaged(browser2->window()->GetNativeWindow()));
   EXPECT_FALSE(HasUserChangedWindowPositionOrSize(
       browser2->window()->GetNativeWindow()));
   // Also make sure that the drag to window position has not changed.
   EXPECT_EQ(initial_bounds.ToString(),
             browser2->window()->GetBounds().ToString());
 }
 
 namespace {
 
 // Invoked from the nested message loop.
 void CancelOnNewTabWhenDraggingStep2(
-    DetachToBrowserTabDragControllerTest* test) {
+    DetachToBrowserTabDragControllerTest* test,
+    const chrome::BrowserListImpl* browser_list) {
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, browser_list->size());
 
-  // Add another tab. This shoudl trigger exiting the nested loop.
-  test->AddBlankTabAndShow(*BrowserList::begin_last_active());
+  // Add another tab. This should trigger exiting the nested loop.
+  test->AddBlankTabAndShow(browser_list->GetLastActive());
 }
 
 }  // namespace
 
 // Adds another tab, detaches into separate window, adds another tab and
 // verifies the run loop ends.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        CancelOnNewTabWhenDragging) {
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Add another tab to browser().
   AddTabAndResetBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
-      base::Bind(&CancelOnNewTabWhenDraggingStep2, this)));
+      base::Bind(&CancelOnNewTabWhenDraggingStep2, this, native_browser_list)));
   QuitWhenNotDragging();
 
   // Should be two windows and not dragging.
   ASSERT_FALSE(TabDragController::IsActive());
-  ASSERT_EQ(2u, BrowserList::size());
-  for (BrowserList::const_iterator i = BrowserList::begin();
-       i != BrowserList::end(); ++i) {
-    EXPECT_TRUE(GetTrackedByWorkspace(*i));
-  }
+  ASSERT_EQ(2u, native_browser_list->size());
+  for (chrome::BrowserIterator it; !it.done(); it.Next())
+    EXPECT_TRUE(GetTrackedByWorkspace(*it));
 }
 
 #if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
 
 namespace {
 
 void DragInMaximizedWindowStep2(DetachToBrowserTabDragControllerTest* test,
                                 Browser* browser,
-                                TabStrip* tab_strip) {
+                                TabStrip* tab_strip,
+                                const chrome::BrowserListImpl* browser_list) {
   // There should be another browser.
-  ASSERT_EQ(2u, BrowserList::size());
-  Browser* new_browser = *(++BrowserList::begin());
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = browser_list->get(1);
   EXPECT_NE(browser, new_browser);
   ASSERT_TRUE(new_browser->window()->IsActive());
   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
 
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
 
   // Both windows should be visible.
   EXPECT_TRUE(tab_strip->GetWidget()->IsVisible());
   EXPECT_TRUE(tab_strip2->GetWidget()->IsVisible());
@@ skipping 11 matching lines @@
   browser()->window()->Maximize();
 
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
-      base::Bind(&DragInMaximizedWindowStep2, this, browser(), tab_strip)));
+      base::Bind(&DragInMaximizedWindowStep2, this, browser(), tab_strip,
+                 native_browser_list)));
   QuitWhenNotDragging();
 
   ASSERT_FALSE(TabDragController::IsActive());
 
   // Should be two browsers.
-  ASSERT_EQ(2u, BrowserList::size());
-  Browser* new_browser = *(++BrowserList::begin());
+  ASSERT_EQ(2u, native_browser_list->size());
+  Browser* new_browser = native_browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
 
   // Only the new browser should be visible.
   EXPECT_FALSE(browser()->window()->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(new_browser->window()->GetNativeWindow()->IsVisible());
 
   EXPECT_TRUE(GetTrackedByWorkspace(browser()));
   EXPECT_TRUE(GetTrackedByWorkspace(new_browser));
 }
 
@@ skipping 46 matching lines @@
   if (input_source() == INPUT_SOURCE_MOUSE) {
     ASSERT_TRUE(ReleaseMouseAsync());
     QuitWhenNotDragging();
   }
 
   // Should no longer be dragging.
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   // There should now be another browser.
-  ASSERT_EQ(2u, BrowserList::size());
-  Browser* new_browser = *(++BrowserList::begin());
+  ASSERT_EQ(2u, native_browser_list->size());
+  Browser* new_browser = native_browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
 
   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
 }
 
 namespace {
 
@@ skipping 192 matching lines @@
     MessageLoop::current()->Run();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest);
 };
 
 // Invoked from the nested message loop.
 void CancelDragTabToWindowInSeparateDisplayStep3(
-    TabStrip* tab_strip) {
+    TabStrip* tab_strip,
+    const chrome::BrowserListImpl* browser_list) {
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, browser_list->size());
 
   // Switching display mode should cancel the drag operation.
   ash::internal::DisplayManager::CycleDisplay();
 }
 
 // Invoked from the nested message loop.
 void CancelDragTabToWindowInSeparateDisplayStep2(
     DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest* test,
     TabStrip* tab_strip,
     aura::RootWindow* current_root,
-    gfx::Point final_destination) {
+    gfx::Point final_destination,
+    const chrome::BrowserListImpl* browser_list) {
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(2u, BrowserList::size());
+  ASSERT_EQ(2u, browser_list->size());
 
-  Browser* new_browser = *(++BrowserList::begin());
+  Browser* new_browser = browser_list->get(1);
   EXPECT_EQ(current_root,
             new_browser->window()->GetNativeWindow()->GetRootWindow());
 
   ASSERT_TRUE(test->DragTabAndExecuteTaskWhenDone(
       final_destination,
       base::Bind(&CancelDragTabToWindowInSeparateDisplayStep3,
-                 tab_strip)));
+                 tab_strip, browser_list)));
 }
 
 }  // namespace
 
 // Drags from browser to a second display and releases input.
 IN_PROC_BROWSER_TEST_F(
     DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest,
     CancelDragTabToWindowIn2ndDisplay) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // Move the second browser to the second display.
   std::vector<aura::RootWindow*> roots(ash::Shell::GetAllRootWindows());
   ASSERT_EQ(2u, roots.size());
   gfx::Point final_destination =
       gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
           roots[1]).work_area().CenterPoint();
 
   // Move to the first tab and drag it enough so that it detaches, but not
   // enough to move to another display.
   gfx::Point tab_0_dst(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(Press(tab_0_dst));
   tab_0_dst.Offset(0, GetDetachY(tab_strip));
   ASSERT_TRUE(DragTabAndExecuteTaskWhenDone(
       tab_0_dst, base::Bind(&CancelDragTabToWindowInSeparateDisplayStep2,
-                            this, tab_strip, roots[0], final_destination)));
+                            this, tab_strip, roots[0], final_destination,
+                            native_browser_list)));
   QuitWhenNotDragging();
 
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // Release the mouse
   ASSERT_TRUE(ui_test_utils::SendMouseEventsSync(
       ui_controls::LEFT, ui_controls::UP));
 }
 
 // Drags from browser from a second display to primary and releases input.
@@ skipping 20 matching lines @@
       gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
           roots[0]).work_area().CenterPoint();
 
   // Move to the first tab and drag it enough so that it detaches, but not
   // enough to move to another display.
   gfx::Point tab_0_dst(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(Press(tab_0_dst));
   tab_0_dst.Offset(0, GetDetachY(tab_strip));
   ASSERT_TRUE(DragTabAndExecuteTaskWhenDone(
       tab_0_dst, base::Bind(&CancelDragTabToWindowInSeparateDisplayStep2,
-                            this, tab_strip, roots[1], final_destination)));
+                            this, tab_strip, roots[1], final_destination,
+                            native_browser_list)));
   QuitWhenNotDragging();
 
-  ASSERT_EQ(1u, BrowserList::size());
+  ASSERT_EQ(1u, native_browser_list->size());
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // Release the mouse
   ASSERT_TRUE(ui_test_utils::SendMouseEventsSync(
       ui_controls::LEFT, ui_controls::UP));
 }
 
 #endif
 
 #if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserInSeparateDisplayTabDragControllerTest,
                         ::testing::Values("mouse", "touch"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DifferentDeviceScaleFactorDisplayTabDragControllerTest,
                         ::testing::Values("mouse"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse", "touch"));
 #else
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse"));
 #endif