Home | History | Annotate | Download | only in tabs 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "ash/wm/window_state.h"
     10 #include "base/bind.h"
     11 #include "base/callback.h"
     12 #include "base/command_line.h"
     13 #include "base/run_loop.h"
     14 #include "base/strings/string_number_conversions.h"
     15 #include "chrome/browser/chrome_notification_types.h"
     16 #include "chrome/browser/ui/browser.h"
     17 #include "chrome/browser/ui/browser_commands.h"
     18 #include "chrome/browser/ui/browser_iterator.h"
     19 #include "chrome/browser/ui/browser_list.h"
     20 #include "chrome/browser/ui/host_desktop.h"
     21 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     22 #include "chrome/browser/ui/views/frame/browser_view.h"
     23 #include "chrome/browser/ui/views/frame/native_browser_frame_factory.h"
     24 #include "chrome/browser/ui/views/tabs/tab.h"
     25 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
     26 #include "chrome/browser/ui/views/tabs/tab_strip.h"
     27 #include "chrome/test/base/in_process_browser_test.h"
     28 #include "chrome/test/base/interactive_test_utils.h"
     29 #include "chrome/test/base/ui_test_utils.h"
     30 #include "content/public/browser/notification_details.h"
     31 #include "content/public/browser/notification_observer.h"
     32 #include "content/public/browser/notification_service.h"
     33 #include "content/public/browser/notification_source.h"
     34 #include "content/public/browser/web_contents.h"
     35 #include "ui/base/test/ui_controls.h"
     36 #include "ui/gfx/screen.h"
     37 #include "ui/views/view.h"
     38 #include "ui/views/widget/widget.h"
     39 
     40 #if defined(USE_AURA) && !defined(OS_CHROMEOS)
     41 #include "chrome/browser/ui/views/frame/desktop_browser_frame_aura.h"
     42 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h"
     43 #endif
     44 
     45 #if defined(USE_ASH)
     46 #include "ash/display/display_controller.h"
     47 #include "ash/display/display_manager.h"
     48 #include "ash/shell.h"
     49 #include "ash/test/cursor_manager_test_api.h"
     50 #include "ash/wm/coordinate_conversion.h"
     51 #include "ash/wm/window_util.h"
     52 #include "chrome/browser/ui/views/frame/immersive_mode_controller.h"
     53 #include "ui/aura/client/screen_position_client.h"
     54 #include "ui/aura/test/event_generator_delegate_aura.h"
     55 #include "ui/aura/window_event_dispatcher.h"
     56 #include "ui/events/test/event_generator.h"
     57 #endif
     58 
     59 using content::WebContents;
     60 
     61 namespace test {
     62 
     63 namespace {
     64 
     65 const char kTabDragControllerInteractiveUITestUserDataKey[] =
     66     "TabDragControllerInteractiveUITestUserData";
     67 
     68 class TabDragControllerInteractiveUITestUserData
     69     : public base::SupportsUserData::Data {
     70  public:
     71   explicit TabDragControllerInteractiveUITestUserData(int id) : id_(id) {}
     72   virtual ~TabDragControllerInteractiveUITestUserData() {}
     73   int id() { return id_; }
     74 
     75  private:
     76   int id_;
     77 };
     78 
     79 }  // namespace
     80 
     81 class QuitDraggingObserver : public content::NotificationObserver {
     82  public:
     83   QuitDraggingObserver() {
     84     registrar_.Add(this, chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE,
     85                    content::NotificationService::AllSources());
     86   }
     87 
     88   virtual void Observe(int type,
     89                        const content::NotificationSource& source,
     90                        const content::NotificationDetails& details) OVERRIDE {
     91     DCHECK_EQ(chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE, type);
     92     base::MessageLoopForUI::current()->Quit();
     93     delete this;
     94   }
     95 
     96  private:
     97   virtual ~QuitDraggingObserver() {}
     98 
     99   content::NotificationRegistrar registrar_;
    100 
    101   DISALLOW_COPY_AND_ASSIGN(QuitDraggingObserver);
    102 };
    103 
    104 gfx::Point GetCenterInScreenCoordinates(const views::View* view) {
    105   gfx::Point center(view->width() / 2, view->height() / 2);
    106   views::View::ConvertPointToScreen(view, &center);
    107   return center;
    108 }
    109 
    110 void SetID(WebContents* web_contents, int id) {
    111   web_contents->SetUserData(&kTabDragControllerInteractiveUITestUserDataKey,
    112                             new TabDragControllerInteractiveUITestUserData(id));
    113 }
    114 
    115 void ResetIDs(TabStripModel* model, int start) {
    116   for (int i = 0; i < model->count(); ++i)
    117     SetID(model->GetWebContentsAt(i), start + i);
    118 }
    119 
    120 std::string IDString(TabStripModel* model) {
    121   std::string result;
    122   for (int i = 0; i < model->count(); ++i) {
    123     if (i != 0)
    124       result += " ";
    125     WebContents* contents = model->GetWebContentsAt(i);
    126     TabDragControllerInteractiveUITestUserData* user_data =
    127         static_cast<TabDragControllerInteractiveUITestUserData*>(
    128             contents->GetUserData(
    129                 &kTabDragControllerInteractiveUITestUserDataKey));
    130     if (user_data)
    131       result += base::IntToString(user_data->id());
    132     else
    133       result += "?";
    134   }
    135   return result;
    136 }
    137 
    138 // Creates a listener that quits the message loop when no longer dragging.
    139 void QuitWhenNotDraggingImpl() {
    140   new QuitDraggingObserver();  // QuitDraggingObserver deletes itself.
    141 }
    142 
    143 TabStrip* GetTabStripForBrowser(Browser* browser) {
    144   BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser);
    145   return static_cast<TabStrip*>(browser_view->tabstrip());
    146 }
    147 
    148 }  // namespace test
    149 
    150 using test::GetCenterInScreenCoordinates;
    151 using test::SetID;
    152 using test::ResetIDs;
    153 using test::IDString;
    154 using test::GetTabStripForBrowser;
    155 
    156 TabDragControllerTest::TabDragControllerTest()
    157     : native_browser_list(BrowserList::GetInstance(
    158                               chrome::HOST_DESKTOP_TYPE_NATIVE)) {
    159 }
    160 
    161 TabDragControllerTest::~TabDragControllerTest() {
    162 }
    163 
    164 void TabDragControllerTest::StopAnimating(TabStrip* tab_strip) {
    165   tab_strip->StopAnimating(true);
    166 }
    167 
    168 void TabDragControllerTest::AddTabAndResetBrowser(Browser* browser) {
    169   AddBlankTabAndShow(browser);
    170   StopAnimating(GetTabStripForBrowser(browser));
    171   ResetIDs(browser->tab_strip_model(), 0);
    172 }
    173 
    174 Browser* TabDragControllerTest::CreateAnotherWindowBrowserAndRelayout() {
    175   // Create another browser.
    176   Browser* browser2 = CreateBrowser(browser()->profile());
    177   ResetIDs(browser2->tab_strip_model(), 100);
    178 
    179   // Resize the two windows so they're right next to each other.
    180   gfx::Rect work_area = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
    181       browser()->window()->GetNativeWindow()).work_area();
    182   gfx::Size half_size =
    183       gfx::Size(work_area.width() / 3 - 10, work_area.height() / 2 - 10);
    184   browser()->window()->SetBounds(gfx::Rect(work_area.origin(), half_size));
    185   browser2->window()->SetBounds(gfx::Rect(
    186       work_area.x() + half_size.width(), work_area.y(),
    187       half_size.width(), half_size.height()));
    188   return browser2;
    189 }
    190 
    191 namespace {
    192 
    193 enum InputSource {
    194   INPUT_SOURCE_MOUSE = 0,
    195   INPUT_SOURCE_TOUCH = 1
    196 };
    197 
    198 int GetDetachY(TabStrip* tab_strip) {
    199   return std::max(TabDragController::kTouchVerticalDetachMagnetism,
    200                   TabDragController::kVerticalDetachMagnetism) +
    201       tab_strip->height() + 1;
    202 }
    203 
    204 bool GetIsDragged(Browser* browser) {
    205 #if !defined(USE_ASH) || defined(OS_WIN)  // TODO(win_ash)
    206   return false;
    207 #else
    208   return ash::wm::GetWindowState(browser->window()->GetNativeWindow())->
    209       is_dragged();
    210 #endif
    211 }
    212 
    213 }  // namespace
    214 
    215 #if defined(USE_ASH) && !defined(OS_WIN)  // TODO(win_ash)
    216 class ScreenEventGeneratorDelegate
    217     : public aura::test::EventGeneratorDelegateAura {
    218  public:
    219   explicit ScreenEventGeneratorDelegate(aura::Window* root_window)
    220       : root_window_(root_window) {}
    221   virtual ~ScreenEventGeneratorDelegate() {}
    222 
    223   // EventGeneratorDelegateAura overrides:
    224   virtual aura::WindowTreeHost* GetHostAt(
    225       const gfx::Point& point) const OVERRIDE {
    226     return root_window_->GetHost();
    227   }
    228 
    229   virtual aura::client::ScreenPositionClient* GetScreenPositionClient(
    230       const aura::Window* window) const OVERRIDE {
    231     return aura::client::GetScreenPositionClient(root_window_);
    232   }
    233 
    234  private:
    235   aura::Window* root_window_;
    236 
    237   DISALLOW_COPY_AND_ASSIGN(ScreenEventGeneratorDelegate);
    238 };
    239 
    240 #endif
    241 
    242 #if !defined(OS_CHROMEOS)
    243 
    244 // Following classes verify a crash scenario. Specifically on Windows when focus
    245 // changes it can trigger capture being lost. This was causing a crash in tab
    246 // dragging as it wasn't set up to handle this scenario. These classes
    247 // synthesize this scenario.
    248 
    249 // Allows making ClearNativeFocus() invoke ReleaseCapture().
    250 class TestDesktopBrowserFrameAura : public DesktopBrowserFrameAura {
    251  public:
    252   TestDesktopBrowserFrameAura(
    253       BrowserFrame* browser_frame,
    254       BrowserView* browser_view)
    255       : DesktopBrowserFrameAura(browser_frame, browser_view),
    256         release_capture_(false) {}
    257   virtual ~TestDesktopBrowserFrameAura() {}
    258 
    259   void ReleaseCaptureOnNextClear() {
    260     release_capture_ = true;
    261   }
    262 
    263   virtual void ClearNativeFocus() OVERRIDE {
    264     views::DesktopNativeWidgetAura::ClearNativeFocus();
    265     if (release_capture_) {
    266       release_capture_ = false;
    267       GetWidget()->ReleaseCapture();
    268     }
    269   }
    270 
    271  private:
    272   // If true ReleaseCapture() is invoked in ClearNativeFocus().
    273   bool release_capture_;
    274 
    275   DISALLOW_COPY_AND_ASSIGN(TestDesktopBrowserFrameAura);
    276 };
    277 
    278 // Factory for creating a TestDesktopBrowserFrameAura.
    279 class TestNativeBrowserFrameFactory : public NativeBrowserFrameFactory {
    280  public:
    281   TestNativeBrowserFrameFactory() {}
    282   virtual ~TestNativeBrowserFrameFactory() {}
    283 
    284   virtual NativeBrowserFrame* Create(
    285       BrowserFrame* browser_frame,
    286       BrowserView* browser_view) OVERRIDE {
    287     return new TestDesktopBrowserFrameAura(browser_frame, browser_view);
    288   }
    289 
    290  private:
    291   DISALLOW_COPY_AND_ASSIGN(TestNativeBrowserFrameFactory);
    292 };
    293 
    294 class TabDragCaptureLostTest : public TabDragControllerTest {
    295  public:
    296   TabDragCaptureLostTest() {
    297     NativeBrowserFrameFactory::Set(new TestNativeBrowserFrameFactory);
    298   }
    299 
    300  private:
    301   DISALLOW_COPY_AND_ASSIGN(TabDragCaptureLostTest);
    302 };
    303 
    304 // See description above for details.
    305 IN_PROC_BROWSER_TEST_F(TabDragCaptureLostTest, ReleaseCaptureOnDrag) {
    306   AddTabAndResetBrowser(browser());
    307 
    308   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    309   gfx::Point tab_1_center(GetCenterInScreenCoordinates(tab_strip->tab_at(1)));
    310   ASSERT_TRUE(ui_test_utils::SendMouseMoveSync(tab_1_center) &&
    311               ui_test_utils::SendMouseEventsSync(
    312                   ui_controls::LEFT, ui_controls::DOWN));
    313   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    314   TestDesktopBrowserFrameAura* frame =
    315       static_cast<TestDesktopBrowserFrameAura*>(
    316           BrowserView::GetBrowserViewForBrowser(browser())->GetWidget()->
    317           native_widget_private());
    318   // Invoke ReleaseCaptureOnDrag() so that when the drag happens and focus
    319   // changes capture is released and the drag cancels.
    320   frame->ReleaseCaptureOnNextClear();
    321   ASSERT_TRUE(ui_test_utils::SendMouseMoveSync(tab_0_center));
    322   EXPECT_FALSE(tab_strip->IsDragSessionActive());
    323 }
    324 
    325 IN_PROC_BROWSER_TEST_F(TabDragControllerTest, GestureEndShouldEndDragTest) {
    326   AddTabAndResetBrowser(browser());
    327 
    328   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    329 
    330   Tab* tab1 = tab_strip->tab_at(1);
    331   gfx::Point tab_1_center(tab1->width() / 2, tab1->height() / 2);
    332 
    333   ui::GestureEvent gesture_tap_down(
    334       tab_1_center.x(),
    335       tab_1_center.x(),
    336       0,
    337       base::TimeDelta(),
    338       ui::GestureEventDetails(ui::ET_GESTURE_TAP_DOWN));
    339   tab_strip->MaybeStartDrag(tab1, gesture_tap_down,
    340     tab_strip->GetSelectionModel());
    341   EXPECT_TRUE(TabDragController::IsActive());
    342 
    343   ui::GestureEvent gesture_end(tab_1_center.x(),
    344                                tab_1_center.x(),
    345                                0,
    346                                base::TimeDelta(),
    347                                ui::GestureEventDetails(ui::ET_GESTURE_END));
    348   tab_strip->OnGestureEvent(&gesture_end);
    349   EXPECT_FALSE(TabDragController::IsActive());
    350   EXPECT_FALSE(tab_strip->IsDragSessionActive());
    351 }
    352 
    353 #endif
    354 
    355 class DetachToBrowserTabDragControllerTest
    356     : public TabDragControllerTest,
    357       public ::testing::WithParamInterface<const char*> {
    358  public:
    359   DetachToBrowserTabDragControllerTest() {}
    360 
    361   virtual void SetUpOnMainThread() OVERRIDE {
    362 #if defined(OS_CHROMEOS)
    363     event_generator_.reset(
    364         new ui::test::EventGenerator(ash::Shell::GetPrimaryRootWindow()));
    365 #endif
    366   }
    367 
    368   InputSource input_source() const {
    369     return strstr(GetParam(), "mouse") ?
    370         INPUT_SOURCE_MOUSE : INPUT_SOURCE_TOUCH;
    371   }
    372 
    373   // Set root window from a point in screen coordinates
    374   void SetEventGeneratorRootWindow(const gfx::Point& point) {
    375     if (input_source() == INPUT_SOURCE_MOUSE)
    376       return;
    377 #if defined(OS_CHROMEOS)
    378     event_generator_.reset(new ui::test::EventGenerator(
    379         new ScreenEventGeneratorDelegate(ash::wm::GetRootWindowAt(point))));
    380 #endif
    381   }
    382 
    383   // The following methods update one of the mouse or touch input depending upon
    384   // the InputSource.
    385   bool PressInput(const gfx::Point& location) {
    386     if (input_source() == INPUT_SOURCE_MOUSE) {
    387       return ui_test_utils::SendMouseMoveSync(location) &&
    388           ui_test_utils::SendMouseEventsSync(
    389               ui_controls::LEFT, ui_controls::DOWN);
    390     }
    391 #if defined(OS_CHROMEOS)
    392     event_generator_->set_current_location(location);
    393     event_generator_->PressTouch();
    394 #else
    395     NOTREACHED();
    396 #endif
    397     return true;
    398   }
    399 
    400   bool PressInput2() {
    401     // Second touch input is only used for touch sequence tests.
    402     EXPECT_EQ(INPUT_SOURCE_TOUCH, input_source());
    403 #if defined(OS_CHROMEOS)
    404     event_generator_->set_current_location(
    405         event_generator_->current_location());
    406     event_generator_->PressTouchId(1);
    407 #else
    408     NOTREACHED();
    409 #endif
    410     return true;
    411   }
    412 
    413   bool DragInputTo(const gfx::Point& location) {
    414     if (input_source() == INPUT_SOURCE_MOUSE)
    415       return ui_test_utils::SendMouseMoveSync(location);
    416 #if defined(OS_CHROMEOS)
    417     event_generator_->MoveTouch(location);
    418 #else
    419     NOTREACHED();
    420 #endif
    421     return true;
    422   }
    423 
    424   bool DragInputToAsync(const gfx::Point& location) {
    425     if (input_source() == INPUT_SOURCE_MOUSE)
    426       return ui_controls::SendMouseMove(location.x(), location.y());
    427 #if defined(OS_CHROMEOS)
    428     event_generator_->MoveTouch(location);
    429 #else
    430     NOTREACHED();
    431 #endif
    432     return true;
    433   }
    434 
    435   bool DragInputToNotifyWhenDone(int x,
    436                                  int y,
    437                                  const base::Closure& task) {
    438     if (input_source() == INPUT_SOURCE_MOUSE)
    439       return ui_controls::SendMouseMoveNotifyWhenDone(x, y, task);
    440 #if defined(OS_CHROMEOS)
    441     base::MessageLoop::current()->PostTask(FROM_HERE, task);
    442     event_generator_->MoveTouch(gfx::Point(x, y));
    443 #else
    444     NOTREACHED();
    445 #endif
    446     return true;
    447   }
    448 
    449   bool DragInputToDelayedNotifyWhenDone(int x,
    450                                         int y,
    451                                         const base::Closure& task,
    452                                         base::TimeDelta delay) {
    453     if (input_source() == INPUT_SOURCE_MOUSE)
    454       return ui_controls::SendMouseMoveNotifyWhenDone(x, y, task);
    455 #if defined(OS_CHROMEOS)
    456     base::MessageLoop::current()->PostDelayedTask(FROM_HERE, task, delay);
    457     event_generator_->MoveTouch(gfx::Point(x, y));
    458 #else
    459     NOTREACHED();
    460 #endif
    461     return true;
    462   }
    463 
    464   bool DragInput2ToNotifyWhenDone(int x,
    465                                  int y,
    466                                  const base::Closure& task) {
    467     if (input_source() == INPUT_SOURCE_MOUSE)
    468       return ui_controls::SendMouseMoveNotifyWhenDone(x, y, task);
    469 #if defined(OS_CHROMEOS)
    470     base::MessageLoop::current()->PostTask(FROM_HERE, task);
    471     event_generator_->MoveTouchId(gfx::Point(x, y), 1);
    472 #else
    473     NOTREACHED();
    474 #endif
    475     return true;
    476   }
    477 
    478   bool ReleaseInput() {
    479     if (input_source() == INPUT_SOURCE_MOUSE) {
    480       return ui_test_utils::SendMouseEventsSync(
    481               ui_controls::LEFT, ui_controls::UP);
    482     }
    483 #if defined(OS_CHROMEOS)
    484     event_generator_->ReleaseTouch();
    485 #else
    486     NOTREACHED();
    487 #endif
    488     return true;
    489   }
    490 
    491   bool ReleaseInput2() {
    492     if (input_source() == INPUT_SOURCE_MOUSE) {
    493       return ui_test_utils::SendMouseEventsSync(
    494               ui_controls::LEFT, ui_controls::UP);
    495     }
    496 #if defined(OS_CHROMEOS)
    497     event_generator_->ReleaseTouchId(1);
    498 #else
    499     NOTREACHED();
    500 #endif
    501     return true;
    502   }
    503 
    504   bool ReleaseMouseAsync() {
    505     return input_source() == INPUT_SOURCE_MOUSE &&
    506         ui_controls::SendMouseEvents(ui_controls::LEFT, ui_controls::UP);
    507   }
    508 
    509   void QuitWhenNotDragging() {
    510     if (input_source() == INPUT_SOURCE_MOUSE) {
    511       // Schedule observer to quit message loop when done dragging. This has to
    512       // be async so the message loop can run.
    513       test::QuitWhenNotDraggingImpl();
    514       base::MessageLoop::current()->Run();
    515     } else {
    516       // Touch events are sync, so we know we're not in a drag session. But some
    517       // tests rely on the browser fully closing, which is async. So, run all
    518       // pending tasks.
    519       base::RunLoop run_loop;
    520       run_loop.RunUntilIdle();
    521     }
    522   }
    523 
    524   void AddBlankTabAndShow(Browser* browser) {
    525     InProcessBrowserTest::AddBlankTabAndShow(browser);
    526   }
    527 
    528   Browser* browser() const { return InProcessBrowserTest::browser(); }
    529 
    530  private:
    531 #if defined(OS_CHROMEOS)
    532   scoped_ptr<ui::test::EventGenerator> event_generator_;
    533 #endif
    534 
    535   DISALLOW_COPY_AND_ASSIGN(DetachToBrowserTabDragControllerTest);
    536 };
    537 
    538 // Creates a browser with two tabs, drags the second to the first.
    539 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest, DragInSameWindow) {
    540   // TODO(sky): this won't work with touch as it requires a long press.
    541   if (input_source() == INPUT_SOURCE_TOUCH) {
    542     VLOG(1) << "Test is DISABLED for touch input.";
    543     return;
    544   }
    545 
    546   AddTabAndResetBrowser(browser());
    547 
    548   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    549   TabStripModel* model = browser()->tab_strip_model();
    550 
    551   gfx::Point tab_1_center(GetCenterInScreenCoordinates(tab_strip->tab_at(1)));
    552   ASSERT_TRUE(PressInput(tab_1_center));
    553   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    554   ASSERT_TRUE(DragInputTo(tab_0_center));
    555   ASSERT_TRUE(ReleaseInput());
    556   EXPECT_EQ("1 0", IDString(model));
    557   EXPECT_FALSE(TabDragController::IsActive());
    558   EXPECT_FALSE(tab_strip->IsDragSessionActive());
    559 
    560   // The tab strip should no longer have capture because the drag was ended and
    561   // mouse/touch was released.
    562   EXPECT_FALSE(tab_strip->GetWidget()->HasCapture());
    563 }
    564 
    565 namespace {
    566 
    567 // Invoked from the nested message loop.
    568 void DragToSeparateWindowStep2(DetachToBrowserTabDragControllerTest* test,
    569                                TabStrip* not_attached_tab_strip,
    570                                TabStrip* target_tab_strip) {
    571   ASSERT_FALSE(not_attached_tab_strip->IsDragSessionActive());
    572   ASSERT_FALSE(target_tab_strip->IsDragSessionActive());
    573   ASSERT_TRUE(TabDragController::IsActive());
    574 
    575   // Drag to target_tab_strip. This should stop the nested loop from dragging
    576   // the window.
    577   gfx::Point target_point(target_tab_strip->width() -1,
    578                           target_tab_strip->height() / 2);
    579   views::View::ConvertPointToScreen(target_tab_strip, &target_point);
    580   ASSERT_TRUE(test->DragInputToAsync(target_point));
    581 }
    582 
    583 }  // namespace
    584 
    585 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
    586 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    587 // compositor. crbug.com/331924
    588 #define MAYBE_DragToSeparateWindow DISABLED_DragToSeparateWindow
    589 #else
    590 #define MAYBE_DragToSeparateWindow DragToSeparateWindow
    591 #endif
    592 // Creates two browsers, drags from first into second.
    593 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    594                        MAYBE_DragToSeparateWindow) {
    595   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    596 
    597   // Add another tab to browser().
    598   AddTabAndResetBrowser(browser());
    599 
    600   // Create another browser.
    601   Browser* browser2 = CreateAnotherWindowBrowserAndRelayout();
    602   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
    603 
    604   // Move to the first tab and drag it enough so that it detaches, but not
    605   // enough that it attaches to browser2.
    606   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    607   ASSERT_TRUE(PressInput(tab_0_center));
    608   ASSERT_TRUE(DragInputToNotifyWhenDone(
    609                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
    610                   base::Bind(&DragToSeparateWindowStep2,
    611                              this, tab_strip, tab_strip2)));
    612   QuitWhenNotDragging();
    613 
    614   // Should now be attached to tab_strip2.
    615   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
    616   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    617   ASSERT_TRUE(TabDragController::IsActive());
    618   EXPECT_FALSE(GetIsDragged(browser()));
    619 
    620   // Release mouse or touch, stopping the drag session.
    621   ASSERT_TRUE(ReleaseInput());
    622   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
    623   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    624   ASSERT_FALSE(TabDragController::IsActive());
    625   EXPECT_EQ("100 0", IDString(browser2->tab_strip_model()));
    626   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
    627   EXPECT_FALSE(GetIsDragged(browser2));
    628 
    629   // Both windows should not be maximized
    630   EXPECT_FALSE(browser()->window()->IsMaximized());
    631   EXPECT_FALSE(browser2->window()->IsMaximized());
    632 
    633   // The tab strip should no longer have capture because the drag was ended and
    634   // mouse/touch was released.
    635   EXPECT_FALSE(tab_strip->GetWidget()->HasCapture());
    636   EXPECT_FALSE(tab_strip2->GetWidget()->HasCapture());
    637 }
    638 
    639 namespace {
    640 
    641 void DetachToOwnWindowStep2(DetachToBrowserTabDragControllerTest* test) {
    642   if (test->input_source() == INPUT_SOURCE_TOUCH)
    643     ASSERT_TRUE(test->ReleaseInput());
    644 }
    645 
    646 #if defined(OS_CHROMEOS)
    647 bool IsWindowPositionManaged(aura::Window* window) {
    648   return ash::wm::GetWindowState(window)->window_position_managed();
    649 }
    650 bool HasUserChangedWindowPositionOrSize(aura::Window* window) {
    651   return ash::wm::GetWindowState(window)->bounds_changed_by_user();
    652 }
    653 #else
    654 bool IsWindowPositionManaged(gfx::NativeWindow window) {
    655   return true;
    656 }
    657 bool HasUserChangedWindowPositionOrSize(gfx::NativeWindow window) {
    658   return false;
    659 }
    660 #endif
    661 
    662 }  // namespace
    663 
    664 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
    665 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    666 // compositor. crbug.com/331924
    667 #define MAYBE_DetachToOwnWindow DISABLED_DetachToOwnWindow
    668 #else
    669 #define MAYBE_DetachToOwnWindow DetachToOwnWindow
    670 #endif
    671 // Drags from browser to separate window and releases mouse.
    672 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    673                        MAYBE_DetachToOwnWindow) {
    674   const gfx::Rect initial_bounds(browser()->window()->GetBounds());
    675   // Add another tab.
    676   AddTabAndResetBrowser(browser());
    677   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    678 
    679   // Move to the first tab and drag it enough so that it detaches.
    680   gfx::Point tab_0_center(
    681       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    682   ASSERT_TRUE(PressInput(tab_0_center));
    683   ASSERT_TRUE(DragInputToNotifyWhenDone(
    684                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
    685                   base::Bind(&DetachToOwnWindowStep2, this)));
    686   if (input_source() == INPUT_SOURCE_MOUSE) {
    687     ASSERT_TRUE(ReleaseMouseAsync());
    688     QuitWhenNotDragging();
    689   }
    690 
    691   // Should no longer be dragging.
    692   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    693   ASSERT_FALSE(TabDragController::IsActive());
    694 
    695   // There should now be another browser.
    696   ASSERT_EQ(2u, native_browser_list->size());
    697   Browser* new_browser = native_browser_list->get(1);
    698   ASSERT_TRUE(new_browser->window()->IsActive());
    699   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
    700   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
    701 
    702   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
    703   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
    704 
    705   // The bounds of the initial window should not have changed.
    706   EXPECT_EQ(initial_bounds.ToString(),
    707             browser()->window()->GetBounds().ToString());
    708 
    709   EXPECT_FALSE(GetIsDragged(browser()));
    710   EXPECT_FALSE(GetIsDragged(new_browser));
    711   // After this both windows should still be manageable.
    712   EXPECT_TRUE(IsWindowPositionManaged(browser()->window()->GetNativeWindow()));
    713   EXPECT_TRUE(IsWindowPositionManaged(
    714       new_browser->window()->GetNativeWindow()));
    715 
    716   // Both windows should not be maximized
    717   EXPECT_FALSE(browser()->window()->IsMaximized());
    718   EXPECT_FALSE(new_browser->window()->IsMaximized());
    719 
    720   // The tab strip should no longer have capture because the drag was ended and
    721   // mouse/touch was released.
    722   EXPECT_FALSE(tab_strip->GetWidget()->HasCapture());
    723   EXPECT_FALSE(tab_strip2->GetWidget()->HasCapture());
    724 }
    725 
    726 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
    727 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    728 // compositor. crbug.com/331924
    729 #define MAYBE_DetachToOwnWindowFromMaximizedWindow \
    730   DISABLED_DetachToOwnWindowFromMaximizedWindow
    731 #else
    732 #define MAYBE_DetachToOwnWindowFromMaximizedWindow \
    733   DetachToOwnWindowFromMaximizedWindow
    734 #endif
    735 // Drags from browser to a separate window and releases mouse.
    736 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    737                        MAYBE_DetachToOwnWindowFromMaximizedWindow) {
    738   // Maximize the initial browser window.
    739   browser()->window()->Maximize();
    740   ASSERT_TRUE(browser()->window()->IsMaximized());
    741 
    742   // Add another tab.
    743   AddTabAndResetBrowser(browser());
    744   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    745 
    746   // Move to the first tab and drag it enough so that it detaches.
    747   gfx::Point tab_0_center(
    748       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    749   ASSERT_TRUE(PressInput(tab_0_center));
    750   ASSERT_TRUE(DragInputToNotifyWhenDone(
    751                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
    752                   base::Bind(&DetachToOwnWindowStep2, this)));
    753   if (input_source() == INPUT_SOURCE_MOUSE) {
    754     ASSERT_TRUE(ReleaseMouseAsync());
    755     QuitWhenNotDragging();
    756   }
    757 
    758   // Should no longer be dragging.
    759   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    760   ASSERT_FALSE(TabDragController::IsActive());
    761 
    762   // There should now be another browser.
    763   ASSERT_EQ(2u, native_browser_list->size());
    764   Browser* new_browser = native_browser_list->get(1);
    765   ASSERT_TRUE(new_browser->window()->IsActive());
    766   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
    767   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
    768 
    769   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
    770   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
    771 
    772   // The bounds of the initial window should not have changed.
    773   EXPECT_TRUE(browser()->window()->IsMaximized());
    774 
    775   EXPECT_FALSE(GetIsDragged(browser()));
    776   EXPECT_FALSE(GetIsDragged(new_browser));
    777   // After this both windows should still be manageable.
    778   EXPECT_TRUE(IsWindowPositionManaged(browser()->window()->GetNativeWindow()));
    779   EXPECT_TRUE(IsWindowPositionManaged(
    780       new_browser->window()->GetNativeWindow()));
    781 
    782   // The new window should be maximized.
    783   EXPECT_TRUE(new_browser->window()->IsMaximized());
    784 }
    785 
    786 // Deletes a tab being dragged before the user moved enough to start a drag.
    787 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    788                        DeleteBeforeStartedDragging) {
    789   // Add another tab.
    790   AddTabAndResetBrowser(browser());
    791   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    792 
    793   // Click on the first tab, but don't move it.
    794   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    795   ASSERT_TRUE(PressInput(tab_0_center));
    796 
    797   // Should be dragging.
    798   ASSERT_TRUE(tab_strip->IsDragSessionActive());
    799   ASSERT_TRUE(TabDragController::IsActive());
    800 
    801   // Delete the tab being dragged.
    802   delete browser()->tab_strip_model()->GetWebContentsAt(0);
    803 
    804   // Should have canceled dragging.
    805   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    806   ASSERT_FALSE(TabDragController::IsActive());
    807 
    808   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
    809   EXPECT_FALSE(GetIsDragged(browser()));
    810 }
    811 
    812 #if defined(OS_CHROMEOS)
    813 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    814 // compositor. crbug.com/331924
    815 #define MAYBE_DeleteTabWhileAttached DISABLED_DeleteTabWhileAttached
    816 #else
    817 #define MAYBE_DeleteTabWhileAttached DeleteTabWhileAttached
    818 #endif
    819 // Deletes a tab being dragged while still attached.
    820 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    821                        MAYBE_DeleteTabWhileAttached) {
    822   // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    823   // compositor. crbug.com/331924
    824   if (input_source() == INPUT_SOURCE_MOUSE) {
    825     VLOG(1) << "Test is DISABLED for mouse input.";
    826     return;
    827   }
    828 
    829   // Add another tab.
    830   AddTabAndResetBrowser(browser());
    831   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    832 
    833   // Click on the first tab and move it enough so that it starts dragging but is
    834   // still attached.
    835   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    836   ASSERT_TRUE(PressInput(tab_0_center));
    837   ASSERT_TRUE(DragInputTo(
    838                   gfx::Point(tab_0_center.x() + 20, tab_0_center.y())));
    839 
    840   // Should be dragging.
    841   ASSERT_TRUE(tab_strip->IsDragSessionActive());
    842   ASSERT_TRUE(TabDragController::IsActive());
    843 
    844   // Delete the tab being dragged.
    845   delete browser()->tab_strip_model()->GetWebContentsAt(0);
    846 
    847   // Should have canceled dragging.
    848   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    849   ASSERT_FALSE(TabDragController::IsActive());
    850 
    851   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
    852 
    853   EXPECT_FALSE(GetIsDragged(browser()));
    854 }
    855 
    856 namespace {
    857 
    858 void DeleteWhileDetachedStep2(WebContents* tab) {
    859   delete tab;
    860 }
    861 
    862 }  // namespace
    863 
    864 #if defined(OS_CHROMEOS)
    865 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    866 // compositor. crbug.com/331924
    867 #define MAYBE_DeleteTabWhileDetached DISABLED_DeleteTabWhileDetached
    868 #else
    869 #define MAYBE_DeleteTabWhileDetached DeleteTabWhileDetached
    870 #endif
    871 // Deletes a tab being dragged after dragging a tab so that a new window is
    872 // created.
    873 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    874                        MAYBE_DeleteTabWhileDetached) {
    875   // Add another tab.
    876   AddTabAndResetBrowser(browser());
    877   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    878 
    879   // Move to the first tab and drag it enough so that it detaches.
    880   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    881   WebContents* to_delete =
    882       browser()->tab_strip_model()->GetWebContentsAt(0);
    883   ASSERT_TRUE(PressInput(tab_0_center));
    884   ASSERT_TRUE(DragInputToNotifyWhenDone(
    885       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
    886       base::Bind(&DeleteWhileDetachedStep2, to_delete)));
    887   QuitWhenNotDragging();
    888 
    889   // Should not be dragging.
    890   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    891   ASSERT_FALSE(TabDragController::IsActive());
    892 
    893   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
    894 
    895   EXPECT_FALSE(GetIsDragged(browser()));
    896 }
    897 
    898 namespace {
    899 
    900 void DeleteSourceDetachedStep2(WebContents* tab,
    901                                const BrowserList* browser_list) {
    902   ASSERT_EQ(2u, browser_list->size());
    903   Browser* new_browser = browser_list->get(1);
    904   // This ends up closing the source window.
    905   delete tab;
    906   // Cancel the drag.
    907   ui_controls::SendKeyPress(new_browser->window()->GetNativeWindow(),
    908                             ui::VKEY_ESCAPE, false, false, false, false);
    909 }
    910 
    911 }  // namespace
    912 
    913 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
    914 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    915 // compositor. crbug.com/331924
    916 #define MAYBE_DeleteSourceDetached DISABLED_DeleteSourceDetached
    917 #else
    918 #define MAYBE_DeleteSourceDetached DeleteSourceDetached
    919 #endif
    920 // Detaches a tab and while detached deletes a tab from the source so that the
    921 // source window closes then presses escape to cancel the drag.
    922 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    923                        MAYBE_DeleteSourceDetached) {
    924   // Add another tab.
    925   AddTabAndResetBrowser(browser());
    926   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    927 
    928   // Move to the first tab and drag it enough so that it detaches.
    929   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    930   WebContents* to_delete = browser()->tab_strip_model()->GetWebContentsAt(1);
    931   ASSERT_TRUE(PressInput(tab_0_center));
    932   ASSERT_TRUE(DragInputToNotifyWhenDone(
    933       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
    934       base::Bind(&DeleteSourceDetachedStep2, to_delete, native_browser_list)));
    935   QuitWhenNotDragging();
    936 
    937   // Should not be dragging.
    938   ASSERT_EQ(1u, native_browser_list->size());
    939   Browser* new_browser = native_browser_list->get(0);
    940   ASSERT_FALSE(GetTabStripForBrowser(new_browser)->IsDragSessionActive());
    941   ASSERT_FALSE(TabDragController::IsActive());
    942 
    943   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
    944 
    945   EXPECT_FALSE(GetIsDragged(new_browser));
    946 
    947   // Remaining browser window should not be maximized
    948   EXPECT_FALSE(new_browser->window()->IsMaximized());
    949 }
    950 
    951 namespace {
    952 
    953 void PressEscapeWhileDetachedStep2(const BrowserList* browser_list) {
    954   ASSERT_EQ(2u, browser_list->size());
    955   Browser* new_browser = browser_list->get(1);
    956   ui_controls::SendKeyPress(
    957       new_browser->window()->GetNativeWindow(), ui::VKEY_ESCAPE, false, false,
    958       false, false);
    959 }
    960 
    961 }  // namespace
    962 
    963 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
    964 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
    965 // compositor. crbug.com/331924
    966 #define MAYBE_PressEscapeWhileDetached DISABLED_PressEscapeWhileDetached
    967 #else
    968 #define MAYBE_PressEscapeWhileDetached PressEscapeWhileDetached
    969 #endif
    970 // This is disabled until NativeViewHost::Detach really detaches.
    971 // Detaches a tab and while detached presses escape to revert the drag.
    972 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
    973                        MAYBE_PressEscapeWhileDetached) {
    974   // Add another tab.
    975   AddTabAndResetBrowser(browser());
    976   TabStrip* tab_strip = GetTabStripForBrowser(browser());
    977 
    978   // Move to the first tab and drag it enough so that it detaches.
    979   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
    980   ASSERT_TRUE(PressInput(tab_0_center));
    981   ASSERT_TRUE(DragInputToNotifyWhenDone(
    982       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
    983       base::Bind(&PressEscapeWhileDetachedStep2, native_browser_list)));
    984   QuitWhenNotDragging();
    985 
    986   // Should not be dragging.
    987   ASSERT_FALSE(tab_strip->IsDragSessionActive());
    988   ASSERT_FALSE(TabDragController::IsActive());
    989 
    990   // And there should only be one window.
    991   EXPECT_EQ(1u, native_browser_list->size());
    992 
    993   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
    994 
    995   // Remaining browser window should not be maximized
    996   EXPECT_FALSE(browser()->window()->IsMaximized());
    997 
    998   // The tab strip should no longer have capture because the drag was ended and
    999   // mouse/touch was released.
   1000   EXPECT_FALSE(tab_strip->GetWidget()->HasCapture());
   1001 }
   1002 
   1003 namespace {
   1004 
   1005 void DragAllStep2(DetachToBrowserTabDragControllerTest* test,
   1006                   const BrowserList* browser_list) {
   1007   // Should only be one window.
   1008   ASSERT_EQ(1u, browser_list->size());
   1009   if (test->input_source() == INPUT_SOURCE_TOUCH) {
   1010     ASSERT_TRUE(test->ReleaseInput());
   1011   } else {
   1012     ASSERT_TRUE(test->ReleaseMouseAsync());
   1013   }
   1014 }
   1015 
   1016 }  // namespace
   1017 
   1018 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   1019 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
   1020 // compositor. crbug.com/331924
   1021 #define MAYBE_DragAll DISABLED_DragAll
   1022 #else
   1023 #define MAYBE_DragAll DragAll
   1024 #endif
   1025 // Selects multiple tabs and starts dragging the window.
   1026 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest, MAYBE_DragAll) {
   1027   // Add another tab.
   1028   AddTabAndResetBrowser(browser());
   1029   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1030   browser()->tab_strip_model()->AddTabAtToSelection(0);
   1031   browser()->tab_strip_model()->AddTabAtToSelection(1);
   1032 
   1033   // Move to the first tab and drag it enough so that it would normally
   1034   // detach.
   1035   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1036   ASSERT_TRUE(PressInput(tab_0_center));
   1037   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1038       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1039       base::Bind(&DragAllStep2, this, native_browser_list)));
   1040   QuitWhenNotDragging();
   1041 
   1042   // Should not be dragging.
   1043   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1044   ASSERT_FALSE(TabDragController::IsActive());
   1045 
   1046   // And there should only be one window.
   1047   EXPECT_EQ(1u, native_browser_list->size());
   1048 
   1049   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   1050 
   1051   EXPECT_FALSE(GetIsDragged(browser()));
   1052 
   1053   // Remaining browser window should not be maximized
   1054   EXPECT_FALSE(browser()->window()->IsMaximized());
   1055 }
   1056 
   1057 namespace {
   1058 
   1059 // Invoked from the nested message loop.
   1060 void DragAllToSeparateWindowStep2(DetachToBrowserTabDragControllerTest* test,
   1061                                   TabStrip* attached_tab_strip,
   1062                                   TabStrip* target_tab_strip,
   1063                                   const BrowserList* browser_list) {
   1064   ASSERT_TRUE(attached_tab_strip->IsDragSessionActive());
   1065   ASSERT_FALSE(target_tab_strip->IsDragSessionActive());
   1066   ASSERT_TRUE(TabDragController::IsActive());
   1067   ASSERT_EQ(2u, browser_list->size());
   1068 
   1069   // Drag to target_tab_strip. This should stop the nested loop from dragging
   1070   // the window.
   1071   gfx::Point target_point(target_tab_strip->width() - 1,
   1072                           target_tab_strip->height() / 2);
   1073   views::View::ConvertPointToScreen(target_tab_strip, &target_point);
   1074   ASSERT_TRUE(test->DragInputToAsync(target_point));
   1075 }
   1076 
   1077 }  // namespace
   1078 
   1079 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   1080 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
   1081 // compositor. crbug.com/331924
   1082 #define MAYBE_DragAllToSeparateWindow DISABLED_DragAllToSeparateWindow
   1083 #else
   1084 #define MAYBE_DragAllToSeparateWindow DragAllToSeparateWindow
   1085 #endif
   1086 // Creates two browsers, selects all tabs in first and drags into second.
   1087 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
   1088                        MAYBE_DragAllToSeparateWindow) {
   1089   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1090 
   1091   // Add another tab to browser().
   1092   AddTabAndResetBrowser(browser());
   1093 
   1094   // Create another browser.
   1095   Browser* browser2 = CreateAnotherWindowBrowserAndRelayout();
   1096   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1097 
   1098   browser()->tab_strip_model()->AddTabAtToSelection(0);
   1099   browser()->tab_strip_model()->AddTabAtToSelection(1);
   1100 
   1101   // Move to the first tab and drag it enough so that it detaches, but not
   1102   // enough that it attaches to browser2.
   1103   gfx::Point tab_0_center(
   1104       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1105   ASSERT_TRUE(PressInput(tab_0_center));
   1106   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1107       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1108       base::Bind(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2,
   1109                  native_browser_list)));
   1110   QuitWhenNotDragging();
   1111 
   1112   // Should now be attached to tab_strip2.
   1113   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1114   ASSERT_TRUE(TabDragController::IsActive());
   1115   ASSERT_EQ(1u, native_browser_list->size());
   1116 
   1117   // Release the mouse, stopping the drag session.
   1118   ASSERT_TRUE(ReleaseInput());
   1119   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1120   ASSERT_FALSE(TabDragController::IsActive());
   1121   EXPECT_EQ("100 0 1", IDString(browser2->tab_strip_model()));
   1122 
   1123   EXPECT_FALSE(GetIsDragged(browser2));
   1124 
   1125   // Remaining browser window should not be maximized
   1126   EXPECT_FALSE(browser2->window()->IsMaximized());
   1127 }
   1128 
   1129 namespace {
   1130 
   1131 // Invoked from the nested message loop.
   1132 void DragAllToSeparateWindowAndCancelStep2(
   1133     DetachToBrowserTabDragControllerTest* test,
   1134     TabStrip* attached_tab_strip,
   1135     TabStrip* target_tab_strip,
   1136     const BrowserList* browser_list) {
   1137   ASSERT_TRUE(attached_tab_strip->IsDragSessionActive());
   1138   ASSERT_FALSE(target_tab_strip->IsDragSessionActive());
   1139   ASSERT_TRUE(TabDragController::IsActive());
   1140   ASSERT_EQ(2u, browser_list->size());
   1141 
   1142   // Drag to target_tab_strip. This should stop the nested loop from dragging
   1143   // the window.
   1144   gfx::Point target_point(target_tab_strip->width() - 1,
   1145                           target_tab_strip->height() / 2);
   1146   views::View::ConvertPointToScreen(target_tab_strip, &target_point);
   1147   ASSERT_TRUE(test->DragInputToAsync(target_point));
   1148 }
   1149 
   1150 }  // namespace
   1151 
   1152 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   1153 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
   1154 // compositor. crbug.com/331924
   1155 #define MAYBE_DragAllToSeparateWindowAndCancel \
   1156   DISABLED_DragAllToSeparateWindowAndCancel
   1157 #else
   1158 #define MAYBE_DragAllToSeparateWindowAndCancel DragAllToSeparateWindowAndCancel
   1159 #endif
   1160 // Creates two browsers, selects all tabs in first, drags into second, then hits
   1161 // escape.
   1162 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
   1163                        MAYBE_DragAllToSeparateWindowAndCancel) {
   1164   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1165 
   1166   // Add another tab to browser().
   1167   AddTabAndResetBrowser(browser());
   1168 
   1169   // Create another browser.
   1170   Browser* browser2 = CreateAnotherWindowBrowserAndRelayout();
   1171   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1172 
   1173   browser()->tab_strip_model()->AddTabAtToSelection(0);
   1174   browser()->tab_strip_model()->AddTabAtToSelection(1);
   1175 
   1176   // Move to the first tab and drag it enough so that it detaches, but not
   1177   // enough that it attaches to browser2.
   1178   gfx::Point tab_0_center(
   1179       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1180   ASSERT_TRUE(PressInput(tab_0_center));
   1181   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1182                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1183                   base::Bind(&DragAllToSeparateWindowAndCancelStep2, this,
   1184                              tab_strip, tab_strip2, native_browser_list)));
   1185   QuitWhenNotDragging();
   1186 
   1187   // Should now be attached to tab_strip2.
   1188   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1189   ASSERT_TRUE(TabDragController::IsActive());
   1190   ASSERT_EQ(1u, native_browser_list->size());
   1191 
   1192   // Cancel the drag.
   1193   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
   1194       browser2, ui::VKEY_ESCAPE, false, false, false, false));
   1195 
   1196   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1197   ASSERT_FALSE(TabDragController::IsActive());
   1198   EXPECT_EQ("100 0 1", IDString(browser2->tab_strip_model()));
   1199 
   1200   // browser() will have been destroyed, but browser2 should remain.
   1201   ASSERT_EQ(1u, native_browser_list->size());
   1202 
   1203   EXPECT_FALSE(GetIsDragged(browser2));
   1204 
   1205   // Remaining browser window should not be maximized
   1206   EXPECT_FALSE(browser2->window()->IsMaximized());
   1207 }
   1208 
   1209 #if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN)
   1210 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
   1211 // compositor. crbug.com/331924
   1212 #define MAYBE_DragDirectlyToSecondWindow DISABLED_DragDirectlyToSecondWindow
   1213 #else
   1214 #define MAYBE_DragDirectlyToSecondWindow DragDirectlyToSecondWindow
   1215 #endif
   1216 // Creates two browsers, drags from first into the second in such a way that
   1217 // no detaching should happen.
   1218 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
   1219                        MAYBE_DragDirectlyToSecondWindow) {
   1220   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1221 
   1222   // Add another tab to browser().
   1223   AddTabAndResetBrowser(browser());
   1224 
   1225   // Create another browser.
   1226   Browser* browser2 = CreateAnotherWindowBrowserAndRelayout();
   1227   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1228 
   1229   // Move the tabstrip down enough so that we can detach.
   1230   gfx::Rect bounds(browser2->window()->GetBounds());
   1231   bounds.Offset(0, 100);
   1232   browser2->window()->SetBounds(bounds);
   1233 
   1234   // Move to the first tab and drag it enough so that it detaches, but not
   1235   // enough that it attaches to browser2.
   1236   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1237   ASSERT_TRUE(PressInput(tab_0_center));
   1238 
   1239   gfx::Point b2_location(5, 0);
   1240   views::View::ConvertPointToScreen(tab_strip2, &b2_location);
   1241   ASSERT_TRUE(DragInputTo(b2_location));
   1242 
   1243   // Should now be attached to tab_strip2.
   1244   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1245   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1246   ASSERT_TRUE(TabDragController::IsActive());
   1247 
   1248   // Release the mouse, stopping the drag session.
   1249   ASSERT_TRUE(ReleaseInput());
   1250   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1251   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1252   ASSERT_FALSE(TabDragController::IsActive());
   1253   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   1254   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
   1255 
   1256   EXPECT_FALSE(GetIsDragged(browser()));
   1257   EXPECT_FALSE(GetIsDragged(browser2));
   1258 
   1259   // Both windows should not be maximized
   1260   EXPECT_FALSE(browser()->window()->IsMaximized());
   1261   EXPECT_FALSE(browser2->window()->IsMaximized());
   1262 }
   1263 
   1264 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   1265 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
   1266 // compositor. crbug.com/331924
   1267 #define MAYBE_DragSingleTabToSeparateWindow \
   1268   DISABLED_DragSingleTabToSeparateWindow
   1269 #else
   1270 #define MAYBE_DragSingleTabToSeparateWindow DragSingleTabToSeparateWindow
   1271 #endif
   1272 // Creates two browsers, the first browser has a single tab and drags into the
   1273 // second browser.
   1274 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
   1275                        MAYBE_DragSingleTabToSeparateWindow) {
   1276   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1277 
   1278   ResetIDs(browser()->tab_strip_model(), 0);
   1279 
   1280   // Create another browser.
   1281   Browser* browser2 = CreateAnotherWindowBrowserAndRelayout();
   1282   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1283   const gfx::Rect initial_bounds(browser2->window()->GetBounds());
   1284 
   1285   // Move to the first tab and drag it enough so that it detaches, but not
   1286   // enough that it attaches to browser2.
   1287   gfx::Point tab_0_center(
   1288       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1289   ASSERT_TRUE(PressInput(tab_0_center));
   1290   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1291       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1292       base::Bind(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2,
   1293                  native_browser_list)));
   1294   QuitWhenNotDragging();
   1295 
   1296   // Should now be attached to tab_strip2.
   1297   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1298   ASSERT_TRUE(TabDragController::IsActive());
   1299   ASSERT_EQ(1u, native_browser_list->size());
   1300 
   1301   // Release the mouse, stopping the drag session.
   1302   ASSERT_TRUE(ReleaseInput());
   1303   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1304   ASSERT_FALSE(TabDragController::IsActive());
   1305   EXPECT_EQ("100 0", IDString(browser2->tab_strip_model()));
   1306 
   1307   EXPECT_FALSE(GetIsDragged(browser2));
   1308 
   1309   // Remaining browser window should not be maximized
   1310   EXPECT_FALSE(browser2->window()->IsMaximized());
   1311 
   1312   // Make sure that the window is still managed and not user moved.
   1313   EXPECT_TRUE(IsWindowPositionManaged(browser2->window()->GetNativeWindow()));
   1314   EXPECT_FALSE(HasUserChangedWindowPositionOrSize(
   1315       browser2->window()->GetNativeWindow()));
   1316   // Also make sure that the drag to window position has not changed.
   1317   EXPECT_EQ(initial_bounds.ToString(),
   1318             browser2->window()->GetBounds().ToString());
   1319 }
   1320 
   1321 namespace {
   1322 
   1323 // Invoked from the nested message loop.
   1324 void CancelOnNewTabWhenDraggingStep2(
   1325     DetachToBrowserTabDragControllerTest* test,
   1326     const BrowserList* browser_list) {
   1327   ASSERT_TRUE(TabDragController::IsActive());
   1328   ASSERT_EQ(2u, browser_list->size());
   1329 
   1330   // Add another tab. This should trigger exiting the nested loop.
   1331   test->AddBlankTabAndShow(browser_list->GetLastActive());
   1332 }
   1333 
   1334 }  // namespace
   1335 
   1336 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   1337 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
   1338 // compositor. crbug.com/331924
   1339 #define MAYBE_CancelOnNewTabWhenDragging DISABLED_CancelOnNewTabWhenDragging
   1340 #else
   1341 #define MAYBE_CancelOnNewTabWhenDragging CancelOnNewTabWhenDragging
   1342 #endif
   1343 // Adds another tab, detaches into separate window, adds another tab and
   1344 // verifies the run loop ends.
   1345 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
   1346                        MAYBE_CancelOnNewTabWhenDragging) {
   1347   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1348 
   1349   // Add another tab to browser().
   1350   AddTabAndResetBrowser(browser());
   1351 
   1352   // Move to the first tab and drag it enough so that it detaches.
   1353   gfx::Point tab_0_center(
   1354       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1355   ASSERT_TRUE(PressInput(tab_0_center));
   1356   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1357       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1358       base::Bind(&CancelOnNewTabWhenDraggingStep2, this, native_browser_list)));
   1359   QuitWhenNotDragging();
   1360 
   1361   // Should be two windows and not dragging.
   1362   ASSERT_FALSE(TabDragController::IsActive());
   1363   ASSERT_EQ(2u, native_browser_list->size());
   1364   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
   1365     EXPECT_FALSE(GetIsDragged(*it));
   1366     // Should not be maximized
   1367     EXPECT_FALSE(it->window()->IsMaximized());
   1368   }
   1369 }
   1370 
   1371 #if defined(OS_CHROMEOS)
   1372 // TODO(sky,sad): A number of tests below are disabled as they fail due to
   1373 // resize locks with a real compositor. crbug.com/331924
   1374 namespace {
   1375 
   1376 void DragInMaximizedWindowStep2(DetachToBrowserTabDragControllerTest* test,
   1377                                 Browser* browser,
   1378                                 TabStrip* tab_strip,
   1379                                 const BrowserList* browser_list) {
   1380   // There should be another browser.
   1381   ASSERT_EQ(2u, browser_list->size());
   1382   Browser* new_browser = browser_list->get(1);
   1383   EXPECT_NE(browser, new_browser);
   1384   ASSERT_TRUE(new_browser->window()->IsActive());
   1385   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
   1386 
   1387   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1388   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1389 
   1390   // Both windows should be visible.
   1391   EXPECT_TRUE(tab_strip->GetWidget()->IsVisible());
   1392   EXPECT_TRUE(tab_strip2->GetWidget()->IsVisible());
   1393 
   1394   // Stops dragging.
   1395   ASSERT_TRUE(test->ReleaseInput());
   1396 }
   1397 
   1398 }  // namespace
   1399 
   1400 // Creates a browser with two tabs, maximizes it, drags the tab out.
   1401 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
   1402                        DISABLED_DragInMaximizedWindow) {
   1403   AddTabAndResetBrowser(browser());
   1404   browser()->window()->Maximize();
   1405 
   1406   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1407 
   1408   // Move to the first tab and drag it enough so that it detaches.
   1409   gfx::Point tab_0_center(
   1410       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1411   ASSERT_TRUE(PressInput(tab_0_center));
   1412   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1413       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1414       base::Bind(&DragInMaximizedWindowStep2, this, browser(), tab_strip,
   1415                  native_browser_list)));
   1416   QuitWhenNotDragging();
   1417 
   1418   ASSERT_FALSE(TabDragController::IsActive());
   1419 
   1420   // Should be two browsers.
   1421   ASSERT_EQ(2u, native_browser_list->size());
   1422   Browser* new_browser = native_browser_list->get(1);
   1423   ASSERT_TRUE(new_browser->window()->IsActive());
   1424 
   1425   EXPECT_TRUE(browser()->window()->GetNativeWindow()->IsVisible());
   1426   EXPECT_TRUE(new_browser->window()->GetNativeWindow()->IsVisible());
   1427 
   1428   EXPECT_FALSE(GetIsDragged(browser()));
   1429   EXPECT_FALSE(GetIsDragged(new_browser));
   1430 
   1431   // The source window should be maximized.
   1432   EXPECT_TRUE(browser()->window()->IsMaximized());
   1433   // The new window should be maximized.
   1434   EXPECT_TRUE(new_browser->window()->IsMaximized());
   1435 }
   1436 
   1437 // Subclass of DetachToBrowserTabDragControllerTest that
   1438 // creates multiple displays.
   1439 class DetachToBrowserInSeparateDisplayTabDragControllerTest
   1440     : public DetachToBrowserTabDragControllerTest {
   1441  public:
   1442   DetachToBrowserInSeparateDisplayTabDragControllerTest() {}
   1443   virtual ~DetachToBrowserInSeparateDisplayTabDragControllerTest() {}
   1444 
   1445   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
   1446     DetachToBrowserTabDragControllerTest::SetUpCommandLine(command_line);
   1447     // Make screens sufficiently wide to host 2 browsers side by side.
   1448     command_line->AppendSwitchASCII("ash-host-window-bounds",
   1449                                     "0+0-600x600,601+0-600x600");
   1450   }
   1451 
   1452  private:
   1453   DISALLOW_COPY_AND_ASSIGN(
   1454       DetachToBrowserInSeparateDisplayTabDragControllerTest);
   1455 };
   1456 
   1457 // Subclass of DetachToBrowserTabDragControllerTest that runs tests only with
   1458 // touch input.
   1459 class DetachToBrowserTabDragControllerTestTouch
   1460     : public DetachToBrowserTabDragControllerTest {
   1461  public:
   1462   DetachToBrowserTabDragControllerTestTouch() {}
   1463   virtual ~DetachToBrowserTabDragControllerTestTouch() {}
   1464 
   1465  private:
   1466   DISALLOW_COPY_AND_ASSIGN(DetachToBrowserTabDragControllerTestTouch);
   1467 };
   1468 
   1469 namespace {
   1470 
   1471 void DragSingleTabToSeparateWindowInSecondDisplayStep3(
   1472     DetachToBrowserTabDragControllerTest* test) {
   1473   ASSERT_TRUE(test->ReleaseInput());
   1474 }
   1475 
   1476 void DragSingleTabToSeparateWindowInSecondDisplayStep2(
   1477     DetachToBrowserTabDragControllerTest* test,
   1478     const gfx::Point& target_point) {
   1479   ASSERT_TRUE(test->DragInputToNotifyWhenDone(
   1480       target_point.x(), target_point.y(),
   1481       base::Bind(&DragSingleTabToSeparateWindowInSecondDisplayStep3, test)));
   1482 }
   1483 
   1484 }  // namespace
   1485 
   1486 // Drags from browser to a second display and releases input.
   1487 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
   1488                        DISABLED_DragSingleTabToSeparateWindowInSecondDisplay) {
   1489   // Add another tab.
   1490   AddTabAndResetBrowser(browser());
   1491   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1492 
   1493   // Move to the first tab and drag it enough so that it detaches.
   1494   // Then drag it to the final destination on the second screen.
   1495   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1496   ASSERT_TRUE(PressInput(tab_0_center));
   1497   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1498                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1499                   base::Bind(&DragSingleTabToSeparateWindowInSecondDisplayStep2,
   1500                              this, gfx::Point(600 + tab_0_center.x(),
   1501                                               tab_0_center.y()
   1502                                               + GetDetachY(tab_strip)))));
   1503   QuitWhenNotDragging();
   1504 
   1505   // Should no longer be dragging.
   1506   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1507   ASSERT_FALSE(TabDragController::IsActive());
   1508 
   1509   // There should now be another browser.
   1510   ASSERT_EQ(2u, native_browser_list->size());
   1511   Browser* new_browser = native_browser_list->get(1);
   1512   ASSERT_TRUE(new_browser->window()->IsActive());
   1513   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
   1514   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1515 
   1516   // This other browser should be on the second screen (with mouse drag)
   1517   // With the touch input the browser cannot be dragged from one screen
   1518   // to another and the window stays on the first screen.
   1519   if (input_source() == INPUT_SOURCE_MOUSE) {
   1520     aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   1521     ASSERT_EQ(2u, roots.size());
   1522     aura::Window* second_root = roots[1];
   1523     EXPECT_EQ(second_root,
   1524               new_browser->window()->GetNativeWindow()->GetRootWindow());
   1525   }
   1526 
   1527   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
   1528   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
   1529 
   1530   // Both windows should not be maximized
   1531   EXPECT_FALSE(browser()->window()->IsMaximized());
   1532   EXPECT_FALSE(new_browser->window()->IsMaximized());
   1533 }
   1534 
   1535 namespace {
   1536 
   1537 // Invoked from the nested message loop.
   1538 void DragTabToWindowInSeparateDisplayStep2(
   1539     DetachToBrowserTabDragControllerTest* test,
   1540     TabStrip* not_attached_tab_strip,
   1541     TabStrip* target_tab_strip) {
   1542   ASSERT_FALSE(not_attached_tab_strip->IsDragSessionActive());
   1543   ASSERT_FALSE(target_tab_strip->IsDragSessionActive());
   1544   ASSERT_TRUE(TabDragController::IsActive());
   1545 
   1546   // Drag to target_tab_strip. This should stop the nested loop from dragging
   1547   // the window.
   1548   gfx::Point target_point(
   1549       GetCenterInScreenCoordinates(target_tab_strip->tab_at(0)));
   1550 
   1551   // Move it close to the beginning of the target tabstrip.
   1552   target_point.set_x(
   1553       target_point.x() - target_tab_strip->tab_at(0)->width() / 2 + 10);
   1554   ASSERT_TRUE(test->DragInputToAsync(target_point));
   1555 }
   1556 
   1557 }  // namespace
   1558 
   1559 // Drags from browser to another browser on a second display and releases input.
   1560 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
   1561                        DISABLED_DragTabToWindowInSeparateDisplay) {
   1562   // Add another tab.
   1563   AddTabAndResetBrowser(browser());
   1564   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1565 
   1566   // Create another browser.
   1567   Browser* browser2 = CreateBrowser(browser()->profile());
   1568   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1569   ResetIDs(browser2->tab_strip_model(), 100);
   1570 
   1571   // Move the second browser to the second display.
   1572   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   1573   ASSERT_EQ(2u, roots.size());
   1574   aura::Window* second_root = roots[1];
   1575   gfx::Rect work_area = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
   1576       second_root).work_area();
   1577   browser2->window()->SetBounds(work_area);
   1578   EXPECT_EQ(second_root,
   1579             browser2->window()->GetNativeWindow()->GetRootWindow());
   1580 
   1581   // Move to the first tab and drag it enough so that it detaches, but not
   1582   // enough that it attaches to browser2.
   1583   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1584   ASSERT_TRUE(PressInput(tab_0_center));
   1585   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1586                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1587                   base::Bind(&DragTabToWindowInSeparateDisplayStep2,
   1588                              this, tab_strip, tab_strip2)));
   1589   QuitWhenNotDragging();
   1590 
   1591   // Should now be attached to tab_strip2.
   1592   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1593   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1594   ASSERT_TRUE(TabDragController::IsActive());
   1595 
   1596   // Release the mouse, stopping the drag session.
   1597   ASSERT_TRUE(ReleaseInput());
   1598   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1599   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1600   ASSERT_FALSE(TabDragController::IsActive());
   1601   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   1602   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
   1603 
   1604   // Both windows should not be maximized
   1605   EXPECT_FALSE(browser()->window()->IsMaximized());
   1606   EXPECT_FALSE(browser2->window()->IsMaximized());
   1607 }
   1608 
   1609 // Drags from browser to another browser on a second display and releases input.
   1610 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
   1611                        DISABLED_DragTabToWindowOnSecondDisplay) {
   1612   // Add another tab.
   1613   AddTabAndResetBrowser(browser());
   1614   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1615 
   1616   // Create another browser.
   1617   Browser* browser2 = CreateBrowser(browser()->profile());
   1618   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1619   ResetIDs(browser2->tab_strip_model(), 100);
   1620 
   1621   // Move both browsers to the second display.
   1622   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   1623   ASSERT_EQ(2u, roots.size());
   1624   aura::Window* second_root = roots[1];
   1625   gfx::Rect work_area = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
   1626       second_root).work_area();
   1627   browser()->window()->SetBounds(work_area);
   1628 
   1629   // position both browser windows side by side on the second screen.
   1630   gfx::Rect work_area2(work_area);
   1631   work_area.set_width(work_area.width()/2);
   1632   browser()->window()->SetBounds(work_area);
   1633   work_area2.set_x(work_area2.x() + work_area2.width()/2);
   1634   work_area2.set_width(work_area2.width()/2);
   1635   browser2->window()->SetBounds(work_area2);
   1636   EXPECT_EQ(second_root,
   1637             browser()->window()->GetNativeWindow()->GetRootWindow());
   1638   EXPECT_EQ(second_root,
   1639             browser2->window()->GetNativeWindow()->GetRootWindow());
   1640 
   1641   // Move to the first tab and drag it enough so that it detaches, but not
   1642   // enough that it attaches to browser2.
   1643   // SetEventGeneratorRootWindow sets correct (second) RootWindow
   1644   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1645   SetEventGeneratorRootWindow(tab_0_center);
   1646   ASSERT_TRUE(PressInput(tab_0_center));
   1647   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1648                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1649                   base::Bind(&DragTabToWindowInSeparateDisplayStep2,
   1650                              this, tab_strip, tab_strip2)));
   1651   QuitWhenNotDragging();
   1652 
   1653   // Should now be attached to tab_strip2.
   1654   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1655   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1656   ASSERT_TRUE(TabDragController::IsActive());
   1657 
   1658   // Release the mouse, stopping the drag session.
   1659   ASSERT_TRUE(ReleaseInput());
   1660   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1661   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1662   ASSERT_FALSE(TabDragController::IsActive());
   1663   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   1664   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
   1665 
   1666   // Both windows should not be maximized
   1667   EXPECT_FALSE(browser()->window()->IsMaximized());
   1668   EXPECT_FALSE(browser2->window()->IsMaximized());
   1669 }
   1670 
   1671 // Drags from a maximized browser to another non-maximized browser on a second
   1672 // display and releases input.
   1673 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
   1674                        DISABLED_DragMaxTabToNonMaxWindowInSeparateDisplay) {
   1675   // Add another tab.
   1676   AddTabAndResetBrowser(browser());
   1677   browser()->window()->Maximize();
   1678   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1679 
   1680   // Create another browser on the second display.
   1681   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   1682   ASSERT_EQ(2u, roots.size());
   1683   aura::Window* first_root = roots[0];
   1684   aura::Window* second_root = roots[1];
   1685   gfx::Rect work_area = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
   1686       second_root).work_area();
   1687   work_area.Inset(20, 20, 20, 60);
   1688   Browser::CreateParams params(browser()->profile(),
   1689                                browser()->host_desktop_type());
   1690   params.initial_show_state = ui::SHOW_STATE_NORMAL;
   1691   params.initial_bounds = work_area;
   1692   Browser* browser2 = new Browser(params);
   1693   AddBlankTabAndShow(browser2);
   1694 
   1695   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1696   ResetIDs(browser2->tab_strip_model(), 100);
   1697 
   1698   EXPECT_EQ(second_root,
   1699             browser2->window()->GetNativeWindow()->GetRootWindow());
   1700   EXPECT_EQ(first_root,
   1701             browser()->window()->GetNativeWindow()->GetRootWindow());
   1702   EXPECT_EQ(2, tab_strip->tab_count());
   1703   EXPECT_EQ(1, tab_strip2->tab_count());
   1704 
   1705   // Move to the first tab and drag it enough so that it detaches, but not
   1706   // enough that it attaches to browser2.
   1707   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1708   ASSERT_TRUE(PressInput(tab_0_center));
   1709   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1710                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1711                   base::Bind(&DragTabToWindowInSeparateDisplayStep2,
   1712                              this, tab_strip, tab_strip2)));
   1713   QuitWhenNotDragging();
   1714 
   1715   // Should now be attached to tab_strip2.
   1716   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1717   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1718   ASSERT_TRUE(TabDragController::IsActive());
   1719 
   1720   // Release the mouse, stopping the drag session.
   1721   ASSERT_TRUE(ReleaseInput());
   1722 
   1723   // tab should have moved
   1724   EXPECT_EQ(1, tab_strip->tab_count());
   1725   EXPECT_EQ(2, tab_strip2->tab_count());
   1726 
   1727   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1728   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1729   ASSERT_FALSE(TabDragController::IsActive());
   1730   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   1731   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
   1732 
   1733   // Source browser should still be maximized, target should not
   1734   EXPECT_TRUE(browser()->window()->IsMaximized());
   1735   EXPECT_FALSE(browser2->window()->IsMaximized());
   1736 }
   1737 
   1738 // Drags from a restored browser to an immersive fullscreen browser on a
   1739 // second display and releases input.
   1740 IN_PROC_BROWSER_TEST_P(DetachToBrowserInSeparateDisplayTabDragControllerTest,
   1741                        DISABLED_DragTabToImmersiveBrowserOnSeparateDisplay) {
   1742   // Add another tab.
   1743   AddTabAndResetBrowser(browser());
   1744   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1745 
   1746   // Create another browser.
   1747   Browser* browser2 = CreateBrowser(browser()->profile());
   1748   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   1749   ResetIDs(browser2->tab_strip_model(), 100);
   1750 
   1751   // Move the second browser to the second display.
   1752   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   1753   ASSERT_EQ(2u, roots.size());
   1754   aura::Window* second_root = roots[1];
   1755   gfx::Rect work_area = gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
   1756       second_root).work_area();
   1757   browser2->window()->SetBounds(work_area);
   1758   EXPECT_EQ(second_root,
   1759             browser2->window()->GetNativeWindow()->GetRootWindow());
   1760 
   1761   // Put the second browser into immersive fullscreen.
   1762   BrowserView* browser_view2 = BrowserView::GetBrowserViewForBrowser(browser2);
   1763   ImmersiveModeController* immersive_controller2 =
   1764       browser_view2->immersive_mode_controller();
   1765   immersive_controller2->SetupForTest();
   1766   chrome::ToggleFullscreenMode(browser2);
   1767   ASSERT_TRUE(immersive_controller2->IsEnabled());
   1768   ASSERT_FALSE(immersive_controller2->IsRevealed());
   1769   ASSERT_TRUE(tab_strip2->IsImmersiveStyle());
   1770 
   1771   // Move to the first tab and drag it enough so that it detaches, but not
   1772   // enough that it attaches to browser2.
   1773   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1774   ASSERT_TRUE(PressInput(tab_0_center));
   1775   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1776                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1777                   base::Bind(&DragTabToWindowInSeparateDisplayStep2,
   1778                              this, tab_strip, tab_strip2)));
   1779   QuitWhenNotDragging();
   1780 
   1781   // Should now be attached to tab_strip2.
   1782   ASSERT_TRUE(tab_strip2->IsDragSessionActive());
   1783   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1784   ASSERT_TRUE(TabDragController::IsActive());
   1785 
   1786   // browser2's top chrome should be revealed and the tab strip should be
   1787   // at normal height while user is tragging tabs_strip2's tabs.
   1788   ASSERT_TRUE(immersive_controller2->IsRevealed());
   1789   ASSERT_FALSE(tab_strip2->IsImmersiveStyle());
   1790 
   1791   // Release the mouse, stopping the drag session.
   1792   ASSERT_TRUE(ReleaseInput());
   1793   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   1794   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1795   ASSERT_FALSE(TabDragController::IsActive());
   1796   EXPECT_EQ("0 100", IDString(browser2->tab_strip_model()));
   1797   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
   1798 
   1799   // Move the mouse off of browser2's top chrome.
   1800   aura::Window* primary_root = roots[0];
   1801   ASSERT_TRUE(ui_test_utils::SendMouseMoveSync(
   1802                   primary_root->GetBoundsInScreen().CenterPoint()));
   1803 
   1804   // The first browser window should not be in immersive fullscreen.
   1805   // browser2 should still be in immersive fullscreen, but the top chrome should
   1806   // no longer be revealed.
   1807   BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser());
   1808   EXPECT_FALSE(browser_view->immersive_mode_controller()->IsEnabled());
   1809 
   1810   EXPECT_TRUE(immersive_controller2->IsEnabled());
   1811   EXPECT_FALSE(immersive_controller2->IsRevealed());
   1812   EXPECT_TRUE(tab_strip2->IsImmersiveStyle());
   1813 }
   1814 
   1815 // Subclass of DetachToBrowserTabDragControllerTest that
   1816 // creates multiple displays with different device scale factors.
   1817 class DifferentDeviceScaleFactorDisplayTabDragControllerTest
   1818     : public DetachToBrowserTabDragControllerTest {
   1819  public:
   1820   DifferentDeviceScaleFactorDisplayTabDragControllerTest() {}
   1821   virtual ~DifferentDeviceScaleFactorDisplayTabDragControllerTest() {}
   1822 
   1823   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
   1824     DetachToBrowserTabDragControllerTest::SetUpCommandLine(command_line);
   1825     command_line->AppendSwitchASCII("ash-host-window-bounds",
   1826                                     "400x400,0+400-800x800*2");
   1827   }
   1828 
   1829   float GetCursorDeviceScaleFactor() const {
   1830     ash::test::CursorManagerTestApi cursor_test_api(
   1831         ash::Shell::GetInstance()->cursor_manager());
   1832     return cursor_test_api.GetCurrentCursor().device_scale_factor();
   1833   }
   1834 
   1835  private:
   1836   DISALLOW_COPY_AND_ASSIGN(
   1837       DifferentDeviceScaleFactorDisplayTabDragControllerTest);
   1838 };
   1839 
   1840 namespace {
   1841 
   1842 // The points where a tab is dragged in CursorDeviceScaleFactorStep.
   1843 const struct DragPoint {
   1844   int x;
   1845   int y;
   1846 } kDragPoints[] = {
   1847   {300, 200},
   1848   {399, 200},
   1849   {500, 200},
   1850   {400, 200},
   1851   {300, 200},
   1852 };
   1853 
   1854 // The expected device scale factors before the cursor is moved to the
   1855 // corresponding kDragPoints in CursorDeviceScaleFactorStep.
   1856 const float kDeviceScaleFactorExpectations[] = {
   1857   1.0f,
   1858   1.0f,
   1859   2.0f,
   1860   2.0f,
   1861   1.0f,
   1862 };
   1863 
   1864 COMPILE_ASSERT(
   1865     arraysize(kDragPoints) == arraysize(kDeviceScaleFactorExpectations),
   1866     kDragPoints_and_kDeviceScaleFactorExpectations_must_have_same_size);
   1867 
   1868 // Drags tab to |kDragPoints[index]|, then calls the next step function.
   1869 void CursorDeviceScaleFactorStep(
   1870     DifferentDeviceScaleFactorDisplayTabDragControllerTest* test,
   1871     TabStrip* not_attached_tab_strip,
   1872     size_t index) {
   1873   ASSERT_FALSE(not_attached_tab_strip->IsDragSessionActive());
   1874   ASSERT_TRUE(TabDragController::IsActive());
   1875 
   1876   if (index < arraysize(kDragPoints)) {
   1877     EXPECT_EQ(kDeviceScaleFactorExpectations[index],
   1878               test->GetCursorDeviceScaleFactor());
   1879     const DragPoint p = kDragPoints[index];
   1880     ASSERT_TRUE(test->DragInputToNotifyWhenDone(
   1881         p.x, p.y, base::Bind(&CursorDeviceScaleFactorStep,
   1882                              test, not_attached_tab_strip, index + 1)));
   1883   } else {
   1884     // Finishes a serise of CursorDeviceScaleFactorStep calls and ends drag.
   1885     EXPECT_EQ(1.0f, test->GetCursorDeviceScaleFactor());
   1886     ASSERT_TRUE(ui_test_utils::SendMouseEventsSync(
   1887         ui_controls::LEFT, ui_controls::UP));
   1888   }
   1889 }
   1890 
   1891 }  // namespace
   1892 
   1893 // Verifies cursor's device scale factor is updated when a tab is moved across
   1894 // displays with different device scale factors (http://crbug.com/154183).
   1895 IN_PROC_BROWSER_TEST_P(DifferentDeviceScaleFactorDisplayTabDragControllerTest,
   1896                        DISABLED_CursorDeviceScaleFactor) {
   1897   // Add another tab.
   1898   AddTabAndResetBrowser(browser());
   1899   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1900 
   1901   // Move the second browser to the second display.
   1902   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   1903   ASSERT_EQ(2u, roots.size());
   1904 
   1905   // Move to the first tab and drag it enough so that it detaches.
   1906   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   1907   ASSERT_TRUE(PressInput(tab_0_center));
   1908   ASSERT_TRUE(DragInputToNotifyWhenDone(
   1909                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   1910                   base::Bind(&CursorDeviceScaleFactorStep,
   1911                              this, tab_strip, 0)));
   1912   QuitWhenNotDragging();
   1913 }
   1914 
   1915 namespace {
   1916 
   1917 class DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest
   1918     : public TabDragControllerTest {
   1919  public:
   1920   DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest() {}
   1921 
   1922   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
   1923     TabDragControllerTest::SetUpCommandLine(command_line);
   1924     command_line->AppendSwitchASCII("ash-host-window-bounds",
   1925                                     "0+0-250x250,251+0-250x250");
   1926   }
   1927 
   1928   bool Press(const gfx::Point& position) {
   1929     return ui_test_utils::SendMouseMoveSync(position) &&
   1930         ui_test_utils::SendMouseEventsSync(ui_controls::LEFT,
   1931                                            ui_controls::DOWN);
   1932   }
   1933 
   1934   bool DragTabAndExecuteTaskWhenDone(const gfx::Point& position,
   1935                                      const base::Closure& task) {
   1936     return ui_controls::SendMouseMoveNotifyWhenDone(
   1937         position.x(), position.y(), task);
   1938   }
   1939 
   1940   void QuitWhenNotDragging() {
   1941     test::QuitWhenNotDraggingImpl();
   1942     base::MessageLoop::current()->Run();
   1943   }
   1944 
   1945  private:
   1946   DISALLOW_COPY_AND_ASSIGN(
   1947       DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest);
   1948 };
   1949 
   1950 // Invoked from the nested message loop.
   1951 void CancelDragTabToWindowInSeparateDisplayStep3(
   1952     TabStrip* tab_strip,
   1953     const BrowserList* browser_list) {
   1954   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1955   ASSERT_TRUE(TabDragController::IsActive());
   1956   ASSERT_EQ(2u, browser_list->size());
   1957 
   1958   // Switching display mode should cancel the drag operation.
   1959   ash::DisplayManager* display_manager =
   1960       ash::Shell::GetInstance()->display_manager();
   1961   display_manager->AddRemoveDisplay();
   1962 }
   1963 
   1964 // Invoked from the nested message loop.
   1965 void CancelDragTabToWindowInSeparateDisplayStep2(
   1966     DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest* test,
   1967     TabStrip* tab_strip,
   1968     aura::Window* current_root,
   1969     gfx::Point final_destination,
   1970     const BrowserList* browser_list) {
   1971   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   1972   ASSERT_TRUE(TabDragController::IsActive());
   1973   ASSERT_EQ(2u, browser_list->size());
   1974 
   1975   Browser* new_browser = browser_list->get(1);
   1976   EXPECT_EQ(current_root,
   1977             new_browser->window()->GetNativeWindow()->GetRootWindow());
   1978 
   1979   ASSERT_TRUE(test->DragTabAndExecuteTaskWhenDone(
   1980       final_destination,
   1981       base::Bind(&CancelDragTabToWindowInSeparateDisplayStep3,
   1982                  tab_strip, browser_list)));
   1983 }
   1984 
   1985 }  // namespace
   1986 
   1987 // Drags from browser to a second display and releases input.
   1988 IN_PROC_BROWSER_TEST_F(
   1989     DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest,
   1990     DISABLED_CancelDragTabToWindowIn2ndDisplay) {
   1991   // Add another tab.
   1992   AddTabAndResetBrowser(browser());
   1993   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   1994 
   1995   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   1996 
   1997   // Move the second browser to the second display.
   1998   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   1999   ASSERT_EQ(2u, roots.size());
   2000   gfx::Point final_destination =
   2001       gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
   2002           roots[1]).work_area().CenterPoint();
   2003 
   2004   // Move to the first tab and drag it enough so that it detaches, but not
   2005   // enough to move to another display.
   2006   gfx::Point tab_0_dst(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   2007   ASSERT_TRUE(Press(tab_0_dst));
   2008   tab_0_dst.Offset(0, GetDetachY(tab_strip));
   2009   ASSERT_TRUE(DragTabAndExecuteTaskWhenDone(
   2010       tab_0_dst, base::Bind(&CancelDragTabToWindowInSeparateDisplayStep2,
   2011                             this, tab_strip, roots[0], final_destination,
   2012                             native_browser_list)));
   2013   QuitWhenNotDragging();
   2014 
   2015   ASSERT_EQ(1u, native_browser_list->size());
   2016   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   2017   ASSERT_FALSE(TabDragController::IsActive());
   2018   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   2019 
   2020   // Release the mouse
   2021   ASSERT_TRUE(ui_test_utils::SendMouseEventsSync(
   2022       ui_controls::LEFT, ui_controls::UP));
   2023 }
   2024 
   2025 // Drags from browser from a second display to primary and releases input.
   2026 IN_PROC_BROWSER_TEST_F(
   2027     DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest,
   2028     DISABLED_CancelDragTabToWindowIn1stDisplay) {
   2029   aura::Window::Windows roots = ash::Shell::GetAllRootWindows();
   2030   ASSERT_EQ(2u, roots.size());
   2031 
   2032   // Add another tab.
   2033   AddTabAndResetBrowser(browser());
   2034   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   2035 
   2036   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   2037   EXPECT_EQ(roots[0], browser()->window()->GetNativeWindow()->GetRootWindow());
   2038 
   2039   gfx::Rect work_area = gfx::Screen::GetNativeScreen()->
   2040       GetDisplayNearestWindow(roots[1]).work_area();
   2041   browser()->window()->SetBounds(work_area);
   2042   EXPECT_EQ(roots[1], browser()->window()->GetNativeWindow()->GetRootWindow());
   2043 
   2044   // Move the second browser to the display.
   2045   gfx::Point final_destination =
   2046       gfx::Screen::GetNativeScreen()->GetDisplayNearestWindow(
   2047           roots[0]).work_area().CenterPoint();
   2048 
   2049   // Move to the first tab and drag it enough so that it detaches, but not
   2050   // enough to move to another display.
   2051   gfx::Point tab_0_dst(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   2052   ASSERT_TRUE(Press(tab_0_dst));
   2053   tab_0_dst.Offset(0, GetDetachY(tab_strip));
   2054   ASSERT_TRUE(DragTabAndExecuteTaskWhenDone(
   2055       tab_0_dst, base::Bind(&CancelDragTabToWindowInSeparateDisplayStep2,
   2056                             this, tab_strip, roots[1], final_destination,
   2057                             native_browser_list)));
   2058   QuitWhenNotDragging();
   2059 
   2060   ASSERT_EQ(1u, native_browser_list->size());
   2061   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   2062   ASSERT_FALSE(TabDragController::IsActive());
   2063   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   2064 
   2065   // Release the mouse
   2066   ASSERT_TRUE(ui_test_utils::SendMouseEventsSync(
   2067       ui_controls::LEFT, ui_controls::UP));
   2068 }
   2069 
   2070 namespace {
   2071 
   2072 void PressSecondFingerWhileDetachedStep2(
   2073     DetachToBrowserTabDragControllerTest* test) {
   2074   ASSERT_TRUE(TabDragController::IsActive());
   2075   ASSERT_EQ(2u, test->native_browser_list->size());
   2076   Browser* new_browser = test->native_browser_list->get(1);
   2077   ASSERT_TRUE(new_browser->window()->IsActive());
   2078 
   2079   ASSERT_TRUE(test->PressInput2());
   2080 }
   2081 
   2082 }  // namespace
   2083 
   2084 // Detaches a tab and while detached presses a second finger.
   2085 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTestTouch,
   2086                        DISABLED_PressSecondFingerWhileDetached) {
   2087   gfx::Rect bounds(browser()->window()->GetBounds());
   2088   // Add another tab.
   2089   AddTabAndResetBrowser(browser());
   2090   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   2091   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   2092 
   2093   // Move to the first tab and drag it enough so that it detaches.
   2094   gfx::Point tab_0_center(
   2095       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   2096   ASSERT_TRUE(PressInput(tab_0_center));
   2097   ASSERT_TRUE(DragInputToDelayedNotifyWhenDone(
   2098                   tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   2099                   base::Bind(&PressSecondFingerWhileDetachedStep2, this),
   2100                   base::TimeDelta::FromMilliseconds(60)));
   2101   QuitWhenNotDragging();
   2102 
   2103   // The drag should have been reverted.
   2104   ASSERT_EQ(1u, native_browser_list->size());
   2105   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   2106   ASSERT_FALSE(TabDragController::IsActive());
   2107   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
   2108 
   2109   ASSERT_TRUE(ReleaseInput());
   2110   ASSERT_TRUE(ReleaseInput2());
   2111 }
   2112 
   2113 #if defined(OS_CHROMEOS)
   2114 
   2115 namespace {
   2116 
   2117 void DetachToDockedWindowNextStep(
   2118     DetachToBrowserTabDragControllerTest* test,
   2119     const gfx::Point& target_point,
   2120     int iteration) {
   2121   ASSERT_EQ(2u, test->native_browser_list->size());
   2122   Browser* new_browser = test->native_browser_list->get(1);
   2123   ASSERT_TRUE(new_browser->window()->IsActive());
   2124 
   2125   if (!iteration) {
   2126     ASSERT_TRUE(test->ReleaseInput());
   2127     return;
   2128   }
   2129   ASSERT_TRUE(test->DragInputToNotifyWhenDone(
   2130       target_point.x(), target_point.y(),
   2131       base::Bind(&DetachToDockedWindowNextStep,
   2132                  test,
   2133                  gfx::Point(target_point.x(), 1 + target_point.y()),
   2134                  iteration - 1)));
   2135 }
   2136 
   2137 }  // namespace
   2138 
   2139 // Drags from browser to separate window, docks that window and releases mouse.
   2140 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
   2141                        DISABLED_DetachToDockedWindowFromMaximizedWindow) {
   2142   // Maximize the initial browser window.
   2143   browser()->window()->Maximize();
   2144   ASSERT_TRUE(browser()->window()->IsMaximized());
   2145 
   2146   // Add another tab.
   2147   AddTabAndResetBrowser(browser());
   2148   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   2149 
   2150   // Move to the first tab and drag it enough so that it detaches.
   2151   gfx::Point tab_0_center(
   2152       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   2153   ASSERT_TRUE(PressInput(tab_0_center));
   2154 
   2155   // The following matches kMovesBeforeAdjust in snap_sizer.cc
   2156   const int kNumIterations = 25 * 5 + 10;
   2157   ASSERT_TRUE(DragInputToNotifyWhenDone(
   2158       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
   2159       base::Bind(&DetachToDockedWindowNextStep, this,
   2160                  gfx::Point(0, tab_0_center.y() + GetDetachY(tab_strip)),
   2161                  kNumIterations)));
   2162   // Continue dragging enough times to go through snapping sequence and dock
   2163   // the window.
   2164   QuitWhenNotDragging();
   2165   // Should no longer be dragging.
   2166   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   2167   ASSERT_FALSE(TabDragController::IsActive());
   2168 
   2169   // There should now be another browser.
   2170   ASSERT_EQ(2u, native_browser_list->size());
   2171   Browser* new_browser = native_browser_list->get(1);
   2172   ASSERT_TRUE(new_browser->window()->IsActive());
   2173   TabStrip* tab_strip2 = GetTabStripForBrowser(new_browser);
   2174   ASSERT_FALSE(tab_strip2->IsDragSessionActive());
   2175 
   2176   EXPECT_EQ("0", IDString(new_browser->tab_strip_model()));
   2177   EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
   2178 
   2179   // The bounds of the initial window should not have changed.
   2180   EXPECT_TRUE(browser()->window()->IsMaximized());
   2181 
   2182   EXPECT_FALSE(GetIsDragged(browser()));
   2183   EXPECT_FALSE(GetIsDragged(new_browser));
   2184   // After this both windows should still be manageable.
   2185   EXPECT_TRUE(IsWindowPositionManaged(browser()->window()->GetNativeWindow()));
   2186   EXPECT_TRUE(IsWindowPositionManaged(
   2187       new_browser->window()->GetNativeWindow()));
   2188 
   2189   ash::wm::WindowState* window_state =
   2190       ash::wm::GetWindowState(new_browser->window()->GetNativeWindow());
   2191   // The new window should not be maximized because it gets docked or snapped.
   2192   EXPECT_FALSE(new_browser->window()->IsMaximized());
   2193   // The new window should be docked and not snapped.
   2194   EXPECT_TRUE(window_state->IsDocked());
   2195   EXPECT_FALSE(window_state->IsSnapped());
   2196 }
   2197 
   2198 #endif  // OS_CHROMEOS
   2199 
   2200 #endif
   2201 
   2202 #if defined(USE_ASH) && defined(OS_CHROMEOS)  // TODO(win_ash,linux_ash)
   2203 INSTANTIATE_TEST_CASE_P(TabDragging,
   2204                         DetachToBrowserInSeparateDisplayTabDragControllerTest,
   2205                         ::testing::Values("mouse", "touch"));
   2206 INSTANTIATE_TEST_CASE_P(TabDragging,
   2207                         DifferentDeviceScaleFactorDisplayTabDragControllerTest,
   2208                         ::testing::Values("mouse"));
   2209 INSTANTIATE_TEST_CASE_P(TabDragging,
   2210                         DetachToBrowserTabDragControllerTest,
   2211                         ::testing::Values("mouse", "touch"));
   2212 INSTANTIATE_TEST_CASE_P(TabDragging,
   2213                         DetachToBrowserTabDragControllerTestTouch,
   2214                         ::testing::Values("touch"));
   2215 #elif defined(USE_ASH)
   2216 INSTANTIATE_TEST_CASE_P(TabDragging,
   2217                         DetachToBrowserTabDragControllerTest,
   2218                         ::testing::Values("mouse"));
   2219 #endif
   2220