MacViews: Implement Tab Dragging

chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "ash/wm/window_state.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/platform_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/native_browser_frame_factory.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
@@ skipping 144 matching lines @@
 }
 
 Browser* TabDragControllerTest::CreateAnotherWindowBrowserAndRelayout() {
   // Create another browser.
   Browser* browser2 = CreateBrowser(browser()->profile());
   ResetIDs(browser2->tab_strip_model(), 100);
 
   // Resize the two windows so they're right next to each other.
   gfx::Rect work_area =
       gfx::Screen::GetScreen()
-          ->GetDisplayNearestWindow(browser()->window()->GetNativeWindow())
+          ->GetDisplayNearestWindow(platform_util::GetViewForWindow(
+              browser()->window()->GetNativeWindow()))
           .work_area();
   gfx::Size half_size =
       gfx::Size(work_area.width() / 3 - 10, work_area.height() / 2 - 10);
   browser()->window()->SetBounds(gfx::Rect(work_area.origin(), half_size));
   browser2->window()->SetBounds(gfx::Rect(
       work_area.x() + half_size.width(), work_area.y(),
       half_size.width(), half_size.height()));
   return browser2;
 }
 
@@ skipping 47 matching lines @@
   }
 
  private:
   aura::Window* root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenEventGeneratorDelegate);
 };
 
 #endif
 
-#if !defined(OS_CHROMEOS)
+#if !defined(OS_CHROMEOS) && defined(USE_AURA)
 
 // Following classes verify a crash scenario. Specifically on Windows when focus
 // changes it can trigger capture being lost. This was causing a crash in tab
 // dragging as it wasn't set up to handle this scenario. These classes
 // synthesize this scenario.
 
 // Allows making ClearNativeFocus() invoke ReleaseCapture().
 class TestDesktopBrowserFrameAura : public DesktopBrowserFrameAura {
  public:
   TestDesktopBrowserFrameAura(
@@ skipping 102 matching lines @@
     : public TabDragControllerTest,
       public ::testing::WithParamInterface<const char*> {
  public:
   DetachToBrowserTabDragControllerTest() {}
 
   void SetUpOnMainThread() override {
 #if defined(OS_CHROMEOS)
     event_generator_.reset(
         new ui::test::EventGenerator(ash::Shell::GetPrimaryRootWindow()));
 #endif
+#if defined(OS_MACOSX)
+    // Currently MacViews' browser windows are shown in the background and could
+    // be obscured by other windows if there are any. This should be fixed in
+    // order to be consistent with other platforms.
+    EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
+#endif  // OS_MACOSX
   }
 
   InputSource input_source() const {
     return strstr(GetParam(), "mouse") ?
         INPUT_SOURCE_MOUSE : INPUT_SOURCE_TOUCH;
   }
 
   // Set root window from a point in screen coordinates
   void SetEventGeneratorRootWindow(const gfx::Point& point) {
     if (input_source() == INPUT_SOURCE_MOUSE)
@@ skipping 456 matching lines @@
   // Both windows should not be maximized
   EXPECT_FALSE(browser()->window()->IsMaximized());
   EXPECT_FALSE(new_browser->window()->IsMaximized());
 
   // The tab strip should no longer have capture because the drag was ended and
   // mouse/touch was released.
   EXPECT_FALSE(tab_strip->GetWidget()->HasCapture());
   EXPECT_FALSE(tab_strip2->GetWidget()->HasCapture());
 }
 
-#if defined(OS_CHROMEOS) || defined(OS_LINUX)
+#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_MACOSX)
 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
 // compositor. crbug.com/331924
+// TODO(tapted,mblsha): Disabled as the IsMaximized behavior is not consistent
+// with other platforms. crbug.com/603562
 #define MAYBE_DetachFromFullsizeWindow DISABLED_DetachFromFullsizeWindow
 #else
 #define MAYBE_DetachFromFullsizeWindow DetachFromFullsizeWindow
 #endif
 // Tests that a tab can be dragged from a browser window that is resized to full
 // screen.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        MAYBE_DetachFromFullsizeWindow) {
   // Resize the browser window so that it is as big as the work area.
   gfx::Rect work_area =
       gfx::Screen::GetScreen()
-          ->GetDisplayNearestWindow(browser()->window()->GetNativeWindow())
+          ->GetDisplayNearestWindow(platform_util::GetViewForWindow(
+              browser()->window()->GetNativeWindow()))
           .work_area();
   browser()->window()->SetBounds(work_area);
   const gfx::Rect initial_bounds(browser()->window()->GetBounds());
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
@@ skipping 33 matching lines @@
   // Only second window should be maximized.
   EXPECT_FALSE(browser()->window()->IsMaximized());
   EXPECT_TRUE(new_browser->window()->IsMaximized());
 
   // The tab strip should no longer have capture because the drag was ended and
   // mouse/touch was released.
   EXPECT_FALSE(tab_strip->GetWidget()->HasCapture());
   EXPECT_FALSE(tab_strip2->GetWidget()->HasCapture());
 }
 
-#if defined(OS_CHROMEOS) || defined(OS_LINUX)
+#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_MACOSX)
 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
 // compositor. crbug.com/331924
+// TODO(tapted,mblsha): Disabled as the IsMaximized behavior is not consistent
+// with other platforms. crbug.com/603562
 #define MAYBE_DetachToOwnWindowFromMaximizedWindow \
   DISABLED_DetachToOwnWindowFromMaximizedWindow
 #else
 #define MAYBE_DetachToOwnWindowFromMaximizedWindow \
   DetachToOwnWindowFromMaximizedWindow
 #endif
 // Drags from browser to a separate window and releases mouse.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        MAYBE_DetachToOwnWindowFromMaximizedWindow) {
   // Maximize the initial browser window.
@@ skipping 283 matching lines @@
 #else
 #define MAYBE_DragAll DragAll
 #endif
 // Selects multiple tabs and starts dragging the window.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest, MAYBE_DragAll) {
   // Add another tab.
   AddTabAndResetBrowser(browser());
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
   browser()->tab_strip_model()->AddTabAtToSelection(0);
   browser()->tab_strip_model()->AddTabAtToSelection(1);
+  const gfx::Rect initial_bounds = browser()->window()->GetBounds();
 
   // Move to the first tab and drag it enough so that it would normally
   // detach.
   gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
       base::Bind(&DragAllStep2, this, browser_list)));
   QuitWhenNotDragging();
 
   // Should not be dragging.
   ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
 
   // And there should only be one window.
   EXPECT_EQ(1u, browser_list->size());
 
   EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
 
   EXPECT_FALSE(GetIsDragged(browser()));
 
   // Remaining browser window should not be maximized
   EXPECT_FALSE(browser()->window()->IsMaximized());
+
+  const gfx::Rect final_bounds = browser()->window()->GetBounds();
+  // Size unchanged, but it should have moved down.
+  EXPECT_EQ(initial_bounds.size(), final_bounds.size());
+  EXPECT_EQ(initial_bounds.origin().x(), final_bounds.origin().x());
+  EXPECT_EQ(initial_bounds.origin().y() + GetDetachY(tab_strip),
+            final_bounds.origin().y());
 }
 
+#if defined(OS_MACOSX)
+// Makes sure we can drag the window using WindowServer by dragging on a tab.
+//
+// All other tests move the windows without relying on the WindowServer, because
+// BridgedNativeWidget::RunMoveLoop() immediately offsets the window on first
+// mouse drag. If we generate more mouse move events after that, it's presumed
+// that the WindowServer will move the window. In order for that to work we need
+// to generate global CGEvents instead of app-specific NSEvents, that's what
+// ui_test_utils::DragAndDrop() is for.
+//
+// If the WindowServer fails to move the window, the final window bounds won't
+// match the expected ones.
+//
+// Note that Mac doesn't simply rely on NSEvents, since they would not allow
+// correct interactions with the window server. E.g., a window could not be
+// dragged to another desktop Space.
+
+// Test dragging all the tabs in the window, this should move the entire window.
+IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
+                       MacDragsWindowUsingCocoaMoveLoop) {
+  // Add another tab.
+  AddTabAndResetBrowser(browser());
+
+  TabStrip* tab_strip = GetTabStripForBrowser(browser());
+  browser()->tab_strip_model()->AddTabAtToSelection(0);
+  browser()->tab_strip_model()->AddTabAtToSelection(1);
+  const gfx::Rect initial_bounds = browser()->window()->GetBounds();
+
+  // Move to the first tab and drag it enough so that it would normally
+  // detach.
+  gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
+
+  // If we don't make the interactive_ui_tests the active application, we won't
+  // be able to monitor NSMouseMoved events and ui_test_utils::DragAndDrop()
+  // will deadlock.
+  EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
+
+  // We need to move the window using multiple intermediate events in order
+  // to verify that CocoaWindowMoveLoop is working correctly.
+  const int steps = 10;
+  ui_test_utils::DragAndDrop(
+      tab_0_center,
+      gfx::Point(tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip)),
+      steps);
+
+  // Should not be dragging.
+  EXPECT_FALSE(tab_strip->IsDragSessionActive());
+  EXPECT_FALSE(TabDragController::IsActive());
+  EXPECT_FALSE(GetIsDragged(browser()));
+
+  // And there should only be one window.
+  EXPECT_EQ(1u, browser_list->size());
+  EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
+
+  // Remaining browser window should not be maximized
+  EXPECT_FALSE(browser()->window()->IsMaximized());
+
+  const gfx::Rect final_bounds = browser()->window()->GetBounds();
+  EXPECT_EQ(initial_bounds.size(), final_bounds.size());
+  EXPECT_EQ(initial_bounds.origin().x(), final_bounds.origin().x());
+  EXPECT_EQ(initial_bounds.origin().y() + GetDetachY(tab_strip),
+            final_bounds.origin().y());
+}
+
+// Tests that when the first mouse event that starts RunMoveLoop does not
+// overlap the Mac menu bar. BridgedNativeWidget::RunMoveLoop() shifts both the
+// mouse position and the expected window frame after detachment.
+IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
+                       MacDetachesWindowOnTopOfMacMenuBar) {
+  // Add another tab.
+  AddTabAndResetBrowser(browser());
+
+  // Make sure there's enough space to trigger detachment.
+  TabStrip* tab_strip = GetTabStripForBrowser(browser());
+  browser()->window()->SetBounds(gfx::Rect(100, 100, 400, 200));
+  DCHECK_GT(browser()->window()->GetBounds().y(), GetDetachY(tab_strip));
+
+  // If we don't make the interactive_ui_tests the active application, we won't
+  // be able to monitor NSMouseMoved events and ui_test_utils::DragAndDrop()
+  // will deadlock.
+  EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
+
+  const gfx::Rect work_area =
+      gfx::Screen::GetScreen()
+          ->GetDisplayNearestWindow(platform_util::GetViewForWindow(
+              browser()->window()->GetNativeWindow()))
+          .work_area();
+  EXPECT_GE(work_area.y(), 22)
+      << "Without the MenuBar on top of work_area this test is pointless.";
+
+  gfx::Point tab_0_center(GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
+  gfx::Point on_top_of_menu_bar(tab_0_center.x(), 0);
+  ui_test_utils::DragAndDrop(tab_0_center, on_top_of_menu_bar);
+
+  // Should not be dragging.
+  EXPECT_FALSE(tab_strip->IsDragSessionActive());
+  EXPECT_FALSE(TabDragController::IsActive());
+  EXPECT_FALSE(GetIsDragged(browser()));
+
+  // Second tab should successfully detach.
+  EXPECT_EQ(2u, browser_list->size());
+  EXPECT_EQ("1", IDString(browser()->tab_strip_model()));
+}
+
+// Detaches and reattaches second tab. Will fail if detached window is not moved
+// synchronously at the start of BridgedNativeWidget::RunMoveLoop(): the check
+// for expected WindowServerFrame() will fail.
+IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
+                       MacDetachesAndReattachesSecondTab) {
+  // Add another tab.
+  AddTabAndResetBrowser(browser());
+
+  TabStrip* tab_strip = GetTabStripForBrowser(browser());
+  browser()->window()->SetBounds(gfx::Rect(100, 100, 400, 200));
+  const gfx::Rect initial_bounds = browser()->window()->GetBounds();
+
+  gfx::Point tab_1_center(GetCenterInScreenCoordinates(tab_strip->tab_at(1)));
+  gfx::Point tab_1_shake(tab_1_center.x(),
+                         tab_1_center.y() + GetDetachY(tab_strip) * 2);
+
+  EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
+
+  using ui_test_utils::DragAndDropOperation;
+  std::list<DragAndDropOperation> operations;
+  operations.push_back(DragAndDropOperation::Move(tab_1_center));
+  operations.push_back(DragAndDropOperation::MouseDown());
+  operations.push_back(DragAndDropOperation::Move(tab_1_shake));
+  operations.push_back(DragAndDropOperation::Move(tab_1_center));
+  operations.push_back(DragAndDropOperation::MouseUp());
+
+  ui_test_utils::DragAndDrop(operations);
+
+  // Should not be dragging.
+  EXPECT_FALSE(tab_strip->IsDragSessionActive());
+  EXPECT_FALSE(TabDragController::IsActive());
+  EXPECT_FALSE(GetIsDragged(browser()));
+
+  // And there should only be one window.
+  EXPECT_EQ(1u, browser_list->size());
+  EXPECT_EQ("0 1", IDString(browser()->tab_strip_model()));
+
+  // The window should remain in its original place.
+  const gfx::Rect final_bounds = browser()->window()->GetBounds();
+  EXPECT_EQ(initial_bounds, final_bounds);
+}
+#endif  // OS_MACOSX
+
 namespace {
 
 // Invoked from the nested message loop.
 void DragAllToSeparateWindowStep2(DetachToBrowserTabDragControllerTest* test,
                                   TabStrip* attached_tab_strip,
                                   TabStrip* target_tab_strip,
                                   const BrowserList* browser_list) {
   ASSERT_TRUE(attached_tab_strip->IsDragSessionActive());
   ASSERT_FALSE(target_tab_strip->IsDragSessionActive());
   ASSERT_TRUE(TabDragController::IsActive());
@@ skipping 208 matching lines @@
                        MAYBE_DragSingleTabToSeparateWindow) {
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   ResetIDs(browser()->tab_strip_model(), 0);
 
   // Create another browser.
   Browser* browser2 = CreateAnotherWindowBrowserAndRelayout();
   TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
   const gfx::Rect initial_bounds(browser2->window()->GetBounds());
 
+  EXPECT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
+
   // Move to the first tab and drag it enough so that it detaches, but not
   // enough that it attaches to browser2.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
       base::Bind(&DragAllToSeparateWindowStep2, this, tab_strip, tab_strip2,
                  browser_list)));
   QuitWhenNotDragging();
@@ skipping 25 matching lines @@
 
 namespace {
 
 // Invoked from the nested message loop.
 void CancelOnNewTabWhenDraggingStep2(
     DetachToBrowserTabDragControllerTest* test,
     const BrowserList* browser_list) {
   ASSERT_TRUE(TabDragController::IsActive());
   ASSERT_EQ(2u, browser_list->size());
 
-  // Add another tab. This should trigger exiting the nested loop. Add at the
-  // to exercise past crash when model/tabstrip got out of sync (474082).
-  content::WindowedNotificationObserver observer(
-      content::NOTIFICATION_LOAD_STOP,
-      content::NotificationService::AllSources());
   chrome::AddTabAt(browser_list->GetLastActive(), GURL(url::kAboutBlankURL),
                    0, false);
-  observer.Wait();
 }
 
 }  // namespace
 
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
 // TODO(sky,sad): Disabled as it fails due to resize locks with a real
 // compositor. crbug.com/331924
 #define MAYBE_CancelOnNewTabWhenDragging DISABLED_CancelOnNewTabWhenDragging
 #else
 #define MAYBE_CancelOnNewTabWhenDragging CancelOnNewTabWhenDragging
 #endif
 // Adds another tab, detaches into separate window, adds another tab and
 // verifies the run loop ends.
 IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTest,
                        MAYBE_CancelOnNewTabWhenDragging) {
   TabStrip* tab_strip = GetTabStripForBrowser(browser());
 
   // Add another tab to browser().
   AddTabAndResetBrowser(browser());
 
   // Move to the first tab and drag it enough so that it detaches.
   gfx::Point tab_0_center(
       GetCenterInScreenCoordinates(tab_strip->tab_at(0)));
   ASSERT_TRUE(PressInput(tab_0_center));
+
+  // Add another tab. This should trigger exiting the nested loop. Add at the
+  // to exercise past crash when model/tabstrip got out of sync (474082).
+  content::WindowedNotificationObserver observer(
+      content::NOTIFICATION_LOAD_STOP,
+      content::NotificationService::AllSources());
   ASSERT_TRUE(DragInputToNotifyWhenDone(
       tab_0_center.x(), tab_0_center.y() + GetDetachY(tab_strip),
       base::Bind(&CancelOnNewTabWhenDraggingStep2, this, browser_list)));
-  QuitWhenNotDragging();
+  observer.Wait();
 
   // Should be two windows and not dragging.
+  ASSERT_FALSE(tab_strip->IsDragSessionActive());
   ASSERT_FALSE(TabDragController::IsActive());
   ASSERT_EQ(2u, browser_list->size());
   for (auto* browser : *BrowserList::GetInstance()) {
     EXPECT_FALSE(GetIsDragged(browser));
     // Should not be maximized
     EXPECT_FALSE(browser->window()->IsMaximized());
   }
 }
 
 #if defined(OS_CHROMEOS)
@@ skipping 563 matching lines @@
                                            ui_controls::DOWN);
   }
 
   bool DragTabAndExecuteTaskWhenDone(const gfx::Point& position,
                                      const base::Closure& task) {
     return ui_controls::SendMouseMoveNotifyWhenDone(
         position.x(), position.y(), task);
   }
 
   void QuitWhenNotDragging() {
+    DCHECK(TabDragController::IsActive());
     test::QuitWhenNotDraggingImpl();
     base::MessageLoop::current()->Run();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       DetachToBrowserInSeparateDisplayAndCancelTabDragControllerTest);
 };
 
 // Invoked from the nested message loop.
@@ skipping 257 matching lines @@
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse", "touch"));
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTestTouch,
                         ::testing::Values("touch"));
 #else
 INSTANTIATE_TEST_CASE_P(TabDragging,
                         DetachToBrowserTabDragControllerTest,
                         ::testing::Values("mouse"));
 #endif