Support Drag and Drop across displays.

ash/drag_drop/drag_drop_tracker_unittest.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 "ash/drag_drop/drag_drop_tracker.h"
+
+#include "ash/shell.h"
+#include "ash/shell_window_ids.h"
+#include "ash/test/ash_test_base.h"
+#include "base/memory/scoped_ptr.h"
+#include "ui/aura/root_window.h"
+#include "ui/aura/test/test_windows.h"
+#include "ui/aura/window.h"
+
+namespace ash {
+namespace test {
+
+class DragDropTrackerTest : public test::AshTestBase {

[varunjain, 2012/08/21 04:37:26]

Suggestion for a test case (should perhaps go in drag_drop_controller_unittest):
Start drag/drop in secondary root window, then destroy that root window (for
example, when the user starts drag/drop in secondary monitor and then switches
that monitor off).

[mazda, 2012/08/24 08:29:01]

Thank you for the suggestion.
I tried EventGenerator for a while and it doesn't seem to work well with multi
display. It does not work when testing even within 2nd display.
Let me add this test case later with the fix of EventGenerator.
As far as I tested the latest patch on the real machine, drag was canceled
without causing problems.

[varunjain, 2012/08/24 13:00:53]

I used EventGenerator in
tooltip_controller_unittest.cc::TooltipsOnMultiDisplayShouldNotCrash for similar
stuff and it seemed to work. You might want to look there (or, that test is also
doing the wrong thing!, in which case let me know! :) )

[mazda, 2012/08/24 18:52:37]

Thank you for the pointer! I'll take a look.
The problem I encountered was that the test gets stuck when drag started
probably because nested loop does not work well on 2nd display.

+ public:
+  virtual void SetUp() OVERRIDE {
+    AshTestBase::SetUp();
+    UpdateDisplay("0+0-200x200,0+201-200x200");
+  }
+
+  static aura::Window* CreateWindow(const gfx::Rect& bounds,
+                                    aura::Window* parent) {
+    static int window_id = 0;
+    return aura::test::CreateTestWindowWithDelegate(
+        new aura::test::TestWindowDelegate,
+        window_id++,
+        bounds,
+        parent);
+  }
+
+  static aura::Window* GetTarget(aura::RootWindow* root_window,
+                          const gfx::Point& location) {
+    scoped_ptr<internal::DragDropTracker> tracker(
+        new internal::DragDropTracker(root_window));
+    ui::MouseEvent e(ui::ET_MOUSE_DRAGGED,
+                     location,
+                     location,
+                     ui::EF_NONE);
+    aura::Window* target = tracker->GetTarget(e);
+    return target;
+  }
+
+  static ui::MouseEvent* ConvertMouseEvent(aura::RootWindow* root_window,
+                                           aura::Window* target,
+                                           const ui::MouseEvent& event) {
+    scoped_ptr<internal::DragDropTracker> tracker(
+        new internal::DragDropTracker(root_window));
+    ui::MouseEvent* converted = tracker->ConvertMouseEvent(target, event);
+    return converted;
+  }
+};
+
+TEST_F(DragDropTrackerTest, GetTarget) {
+  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
+  EXPECT_EQ(2U, root_windows.size());
+
+  aura::Window* default_container0 =
+      ash::Shell::GetContainer(root_windows[0],
+                               ash::internal::kShellWindowId_DefaultContainer);
+  EXPECT_TRUE(NULL != default_container0);
+
+  scoped_ptr<aura::Window> window0(
+      CreateWindow(gfx::Rect(0, 0, 100, 100), default_container0));
+  window0->Show();
+
+  aura::Window* default_container1 =
+      ash::Shell::GetContainer(root_windows[1],
+                               ash::internal::kShellWindowId_DefaultContainer);
+  EXPECT_TRUE(NULL != default_container1);
+
+  scoped_ptr<aura::Window> window1(
+      CreateWindow(gfx::Rect(100, 100, 100, 100), default_container1));
+  window1->Show();
+
+  // Start tracking from the RootWindow0 and check the point on RootWindow0 that
+  // |window0| covers.
+  EXPECT_EQ(window0.get(), GetTarget(root_windows[0], gfx::Point(50, 50)));
+
+  // Start tracking from the RootWindow0 and check the point on RootWindow0 that
+  // neither |window0| nor |window1| covers.
+  EXPECT_NE(window0.get(), GetTarget(root_windows[0], gfx::Point(150, 150)));
+  EXPECT_NE(window1.get(), GetTarget(root_windows[0], gfx::Point(150, 150)));
+
+  // Start tracking from the RootWindow0 and check the point on RootWindow1 that
+  // |window1| covers.
+  EXPECT_EQ(window1.get(), GetTarget(root_windows[0], gfx::Point(150, 350)));
+
+  // Start tracking from the RootWindow0 and check the point on RootWindow1 that
+  // neither |window0| nor |window1| covers.
+  EXPECT_NE(window0.get(), GetTarget(root_windows[0], gfx::Point(50, 250)));
+  EXPECT_NE(window1.get(), GetTarget(root_windows[0], gfx::Point(50, 250)));
+
+  // Start tracking from the RootWindow1 and check the point on RootWindow0 that
+  // |window0| covers.
+  EXPECT_EQ(window0.get(), GetTarget(root_windows[1], gfx::Point(50, -150)));
+
+  // Start tracking from the RootWindow1 and check the point on RootWindow0 that
+  // neither |window0| nor |window1| covers.
+  EXPECT_NE(window0.get(), GetTarget(root_windows[1], gfx::Point(150, -50)));
+  EXPECT_NE(window1.get(), GetTarget(root_windows[1], gfx::Point(150, -50)));
+
+  // Start tracking from the RootWindow1 and check the point on RootWindow1 that
+  // |window1| covers.
+  EXPECT_EQ(window1.get(), GetTarget(root_windows[1], gfx::Point(150, 150)));
+
+  // Start tracking from the RootWindow1 and check the point on RootWindow1 that
+  // neither |window0| nor |window1| covers.
+  EXPECT_NE(window0.get(), GetTarget(root_windows[1], gfx::Point(50, 50)));
+  EXPECT_NE(window1.get(), GetTarget(root_windows[1], gfx::Point(50, 50)));
+}
+
+TEST_F(DragDropTrackerTest, ConvertMouseEvent) {
+  Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
+  EXPECT_EQ(2U, root_windows.size());
+
+  aura::Window* default_container0 =
+      ash::Shell::GetContainer(root_windows[0],
+                               ash::internal::kShellWindowId_DefaultContainer);
+  EXPECT_TRUE(NULL != default_container0);
+
+  scoped_ptr<aura::Window> window0(
+      CreateWindow(gfx::Rect(0, 0, 100, 100), default_container0));
+  window0->Show();
+
+  aura::Window* default_container1 =
+      ash::Shell::GetContainer(root_windows[1],
+                               ash::internal::kShellWindowId_DefaultContainer);
+  EXPECT_TRUE(NULL != default_container1);
+
+  scoped_ptr<aura::Window> window1(
+      CreateWindow(gfx::Rect(100, 100, 100, 100), default_container1));
+  window1->Show();
+
+  // Start tracking from the RootWindow0 and converts the mouse event into
+  // |window0|'s coodinates.
+  ui::MouseEvent original00(ui::ET_MOUSE_DRAGGED,
+                            gfx::Point(50, 50),
+                            gfx::Point(50, 50),
+                            ui::EF_NONE);
+  scoped_ptr<ui::MouseEvent> converted00(ConvertMouseEvent(root_windows[0],
+                                                           window0.get(),
+                                                           original00));
+  EXPECT_EQ(original00.type(), converted00->type());
+  EXPECT_EQ(gfx::Point(50, 50), converted00->location());
+  EXPECT_EQ(gfx::Point(50, 50), converted00->root_location());
+  EXPECT_EQ(original00.flags(), converted00->flags());
+
+  // Start tracking from the RootWindow0 and converts the mouse event into
+  // |window1|'s coodinates.
+  ui::MouseEvent original01(ui::ET_MOUSE_DRAGGED,
+                            gfx::Point(150, 350),
+                            gfx::Point(150, 350),
+                            ui::EF_NONE);
+  scoped_ptr<ui::MouseEvent> converted01(ConvertMouseEvent(root_windows[0],
+                                                           window1.get(),
+                                                           original01));
+  EXPECT_EQ(original01.type(), converted01->type());
+  EXPECT_EQ(gfx::Point(50, 50), converted01->location());
+  EXPECT_EQ(gfx::Point(150, 150), converted01->root_location());
+  EXPECT_EQ(original01.flags(), converted01->flags());
+
+  // Start tracking from the RootWindow1 and converts the mouse event into
+  // |window0|'s coodinates.
+  ui::MouseEvent original10(ui::ET_MOUSE_DRAGGED,
+                            gfx::Point(50, -150),
+                            gfx::Point(50, -150),
+                            ui::EF_NONE);
+  scoped_ptr<ui::MouseEvent> converted10(ConvertMouseEvent(root_windows[1],
+                                                           window0.get(),
+                                                           original10));
+  EXPECT_EQ(original10.type(), converted10->type());
+  EXPECT_EQ(gfx::Point(50, 50), converted10->location());
+  EXPECT_EQ(gfx::Point(50, 50), converted10->root_location());
+  EXPECT_EQ(original10.flags(), converted10->flags());
+
+  // Start tracking from the RootWindow1 and converts the mouse event into
+  // |window1|'s coodinates.
+  ui::MouseEvent original11(ui::ET_MOUSE_DRAGGED,
+                            gfx::Point(150, 150),
+                            gfx::Point(150, 150),
+                            ui::EF_NONE);
+  scoped_ptr<ui::MouseEvent> converted11(ConvertMouseEvent(root_windows[1],
+                                                           window1.get(),
+                                                           original11));
+  EXPECT_EQ(original11.type(), converted11->type());
+  EXPECT_EQ(gfx::Point(50, 50), converted11->location());
+  EXPECT_EQ(gfx::Point(150, 150), converted11->root_location());
+  EXPECT_EQ(original11.flags(), converted11->flags());
+}
+
+}  // namespace test
+}  // namespace aura