Remove HostDesktopType from BrowserList::GetInstance()

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 <stddef.h>
 
 #include <algorithm>
 
@@ skipping 147 matching lines @@
 
 }  // namespace test
 
 using test::GetCenterInScreenCoordinates;
 using test::SetID;
 using test::ResetIDs;
 using test::IDString;
 using test::GetTabStripForBrowser;
 
 TabDragControllerTest::TabDragControllerTest()
-    : native_browser_list(BrowserList::GetInstance(
-                              chrome::HOST_DESKTOP_TYPE_NATIVE)) {
-}
+    : browser_list(BrowserList::GetInstance()) {}
 
 TabDragControllerTest::~TabDragControllerTest() {
 }
 
 void TabDragControllerTest::StopAnimating(TabStrip* tab_strip) {
   tab_strip->StopAnimating(true);
 }
 
 void TabDragControllerTest::AddTabAndResetBrowser(Browser* browser) {
   AddBlankTabAndShow(browser);
@@ skipping 579 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, native_browser_list->size());
-  Browser* new_browser = native_browser_list->get(1);
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = 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 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, native_browser_list->size());
-  Browser* new_browser = native_browser_list->get(1);
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = 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 45 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, native_browser_list->size());
-  Browser* new_browser = native_browser_list->get(1);
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = 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_TRUE(browser()->window()->IsMaximized());
 
@@ skipping 149 matching lines @@
   // 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, native_browser_list)));
+      base::Bind(&DeleteSourceDetachedStep2, to_delete, browser_list)));
   QuitWhenNotDragging();
 
   // Should not be dragging.
-  ASSERT_EQ(1u, native_browser_list->size());
-  Browser* new_browser = native_browser_list->get(0);
+  ASSERT_EQ(1u, browser_list->size());
+  Browser* new_browser = browser_list->get(0);
   ASSERT_FALSE(GetTabStripForBrowser(new_browser)->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
 
   EXPECT_FALSE(GetIsDragged(new_browser));
 
   // Remaining browser window should not be maximized
   EXPECT_FALSE(new_browser->window()->IsMaximized());
 }
@@ skipping 23 matching lines @@
                        MAYBE_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, native_browser_list)));
+      base::Bind(&PressEscapeWhileDetachedStep2, 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, native_browser_list->size());
+  EXPECT_EQ(1u, browser_list->size());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // Remaining browser window should not be maximized
   EXPECT_FALSE(browser()->window()->IsMaximized());
 
   // The tab strip should no longer have capture because the drag was ended and
   // mouse/touch was released.
   EXPECT_FALSE(tab_strip->GetWidget()->HasCapture());
 }
@@ skipping 27 matching lines @@
   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, native_browser_list)));
+      base::Bind(&DragAllStep2, this, 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, native_browser_list->size());
+  EXPECT_EQ(1u, browser_list->size());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   EXPECT_FALSE(GetIsDragged(browser()));
 
   // Remaining browser window should not be maximized
   EXPECT_FALSE(browser()->window()->IsMaximized());
 }
 
 namespace {
@@ skipping 41 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(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2,
-                 native_browser_list)));
+                 browser_list)));
   QuitWhenNotDragging();
 
   // Should now be attached to tab_strip2.
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(1u, native_browser_list->size());
+  ASSERT_EQ(1u, 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_FALSE(GetIsDragged(browser2));
 
   // Remaining browser window should not be maximized
@@ skipping 48 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, native_browser_list)));
+                             tab_strip, tab_strip2, browser_list)));
   QuitWhenNotDragging();
 
   // Should now be attached to tab_strip2.
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(1u, native_browser_list->size());
+  ASSERT_EQ(1u, 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, native_browser_list->size());
+  ASSERT_EQ(1u, browser_list->size());
 
   EXPECT_FALSE(GetIsDragged(browser2));
 
   // Remaining browser window should not be maximized
   EXPECT_FALSE(browser2->window()->IsMaximized());
 }
 
 #if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN)
 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
 // compositor. crbug.com/331924
@@ skipping 71 matching lines @@
   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,
-                 native_browser_list)));
+                 browser_list)));
   QuitWhenNotDragging();
 
   // Should now be attached to tab_strip2.
   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(1u, native_browser_list->size());
+  ASSERT_EQ(1u, 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_FALSE(GetIsDragged(browser2));
 
   // Remaining browser window should not be maximized
@@ skipping 44 matching lines @@
 
   // 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, native_browser_list)));
+      base::Bind(&CancelOnNewTabWhenDraggingStep2, this, browser_list)));
   QuitWhenNotDragging();
 
   // Should be two windows and not dragging.
   ASSERT_FALSE(TabDragController::IsActive());
-  ASSERT_EQ(2u, native_browser_list->size());
+  ASSERT_EQ(2u, browser_list->size());
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     EXPECT_FALSE(GetIsDragged(*it));
     // Should not be maximized
     EXPECT_FALSE(it->window()->IsMaximized());
   }
 }
 
 #if defined(OS_CHROMEOS)
 // TODO(sky,sad): A number of tests below are disabled as they fail due to
 // resize locks with a real compositor. crbug.com/331924
@@ skipping 31 matching lines @@
 
   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,
-                 native_browser_list)));
+                 browser_list)));
   QuitWhenNotDragging();
 
   ASSERT_FALSE(TabDragController::IsActive());
 
   // Should be two browsers.
-  ASSERT_EQ(2u, native_browser_list->size());
-  Browser* new_browser = native_browser_list->get(1);
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
 
   EXPECT_TRUE(browser()->window()->GetNativeWindow()->IsVisible());
   EXPECT_TRUE(new_browser->window()->GetNativeWindow()->IsVisible());
 
   EXPECT_FALSE(GetIsDragged(browser()));
   EXPECT_FALSE(GetIsDragged(new_browser));
 
   // The source window should be maximized.
   EXPECT_TRUE(browser()->window()->IsMaximized());
@@ skipping 67 matching lines @@
                              this, gfx::Point(600 + tab_0_center.x(),
                                               tab_0_center.y()
                                               + GetDetachY(tab_strip)))));
   QuitWhenNotDragging();
 
   // Should no longer be dragging.
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   // There should now be another browser.
-  ASSERT_EQ(2u, native_browser_list->size());
-  Browser* new_browser = native_browser_list->get(1);
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
 
   // This other browser should be on the second screen (with mouse drag)
   // With the touch input the browser cannot be dragged from one screen
   // to another and the window stays on the first screen.
   if (input_source() == INPUT_SOURCE_MOUSE) {
     aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
     ASSERT_EQ(2u, roots.size());
@@ skipping 486 matching lines @@
                                      .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,
-                            native_browser_list)));
+                            browser_list)));
   QuitWhenNotDragging();
 
-  ASSERT_EQ(1u, native_browser_list->size());
+  ASSERT_EQ(1u, 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 22 matching lines @@
                                      .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,
-                            native_browser_list)));
+                            browser_list)));
   QuitWhenNotDragging();
 
-  ASSERT_EQ(1u, native_browser_list->size());
+  ASSERT_EQ(1u, 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));
 }
 
 namespace {
 
 void PressSecondFingerWhileDetachedStep2(
     DetachToBrowserTabDragControllerTest* test) {
   ASSERT_TRUE(TabDragController::IsActive());
-  ASSERT_EQ(2u, test->native_browser_list->size());
-  Browser* new_browser = test->native_browser_list->get(1);
+  ASSERT_EQ(2u, test->browser_list->size());
+  Browser* new_browser = test->browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
 
   ASSERT_TRUE(test->PressInput2());
 }
 
 }  // namespace
 
 // Detaches a tab and while detached presses a second finger.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTestTouch,
                        DISABLED_PressSecondFingerWhileDetached) {
   gfx::Rect bounds(browser()->window()->GetBounds());
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   // 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(DragInputToDelayedNotifyWhenDone(
                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
                   base::Bind(&PressSecondFingerWhileDetachedStep2, this),
                   base::TimeDelta::FromMilliseconds(60)));
   QuitWhenNotDragging();
 
   // The drag should have been reverted.
-  ASSERT_EQ(1u, native_browser_list->size());
+  ASSERT_EQ(1u, browser_list->size());
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   ASSERT_TRUE(ReleaseInput());
   ASSERT_TRUE(ReleaseInput2());
 }
 
 #if defined(OS_CHROMEOS)
 
 namespace {
 
 void DetachToDockedWindowNextStep(
     DetachToBrowserTabDragControllerTest* test,
     const gfx::Point& target_point,
     int iteration) {
-  ASSERT_EQ(2u, test->native_browser_list->size());
-  Browser* new_browser = test->native_browser_list->get(1);
+  ASSERT_EQ(2u, test->browser_list->size());
+  Browser* new_browser = test->browser_list->get(1);
   ASSERT_TRUE(new_browser->window()->IsActive());
 
   if (!iteration) {
     ASSERT_TRUE(test->ReleaseInput());
     return;
   }
   ASSERT_TRUE(test->DragInputToNotifyWhenDone(
       target_point.x(), target_point.y(),
       base::Bind(&DetachToDockedWindowNextStep,
                  test,
@@ skipping 27 matching lines @@
                  gfx::Point(0, tab_0_center.y() + GetDetachY(tab_strip)),
                  kNumIterations)));
   // Continue dragging enough times to go through snapping sequence and dock
   // the window.
   QuitWhenNotDragging();
   // Should no longer be dragging.
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   // There should now be another browser.
-  ASSERT_EQ(2u, native_browser_list->size());
-  Browser* new_browser = native_browser_list->get(1);
+  ASSERT_EQ(2u, browser_list->size());
+  Browser* new_browser = 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_TRUE(browser()->window()->IsMaximized());
 
@@ skipping 28 matching lines @@
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse", "touch"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTestTouch,
                         ::testing::Values("touch"));
 #elif defined(USE_ASH)
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse"));
 #endif