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 "ash/wm/workspace/workspace_event_handler.h"
6
7#include "ash/screen_ash.h"
8#include "ash/shell.h"
9#include "ash/test/ash_test_base.h"
10#include "ash/wm/window_state.h"
11#include "ash/wm/window_util.h"
12#include "ash/wm/workspace_controller.h"
13#include "ash/wm/workspace_controller_test_helper.h"
14#include "ui/aura/client/aura_constants.h"
15#include "ui/aura/root_window.h"
16#include "ui/aura/test/event_generator.h"
17#include "ui/aura/test/test_window_delegate.h"
18#include "ui/aura/window.h"
19#include "ui/base/hit_test.h"
20#include "ui/gfx/screen.h"
21
22#if defined(OS_WIN)
23#include "base/win/windows_version.h"
24#endif
25
26namespace ash {
27namespace internal {
28
29class WorkspaceEventHandlerTest : public test::AshTestBase {
30 public:
31  WorkspaceEventHandlerTest() {}
32  virtual ~WorkspaceEventHandlerTest() {}
33
34 protected:
35  aura::Window* CreateTestWindow(aura::WindowDelegate* delegate,
36                                 const gfx::Rect& bounds) {
37    aura::Window* window = new aura::Window(delegate);
38    window->SetType(aura::client::WINDOW_TYPE_NORMAL);
39    window->Init(ui::LAYER_TEXTURED);
40    ParentWindowInPrimaryRootWindow(window);
41    window->SetBounds(bounds);
42    window->Show();
43    return window;
44  }
45
46 private:
47  DISALLOW_COPY_AND_ASSIGN(WorkspaceEventHandlerTest);
48};
49
50// Keeps track of the properties changed of a particular window.
51class WindowPropertyObserver : public aura::WindowObserver {
52 public:
53  explicit WindowPropertyObserver(aura::Window* window)
54      : window_(window) {
55    window->AddObserver(this);
56  }
57
58  virtual ~WindowPropertyObserver() {
59    window_->RemoveObserver(this);
60  }
61
62  bool DidPropertyChange(const void* property) const {
63    return std::find(properties_changed_.begin(),
64                     properties_changed_.end(),
65                     property) != properties_changed_.end();
66  }
67
68 private:
69  virtual void OnWindowPropertyChanged(aura::Window* window,
70                                       const void* key,
71                                       intptr_t old) OVERRIDE {
72    properties_changed_.push_back(key);
73  }
74
75  aura::Window* window_;
76  std::vector<const void*> properties_changed_;
77
78  DISALLOW_COPY_AND_ASSIGN(WindowPropertyObserver);
79};
80
81TEST_F(WorkspaceEventHandlerTest, DoubleClickSingleAxisResizeEdge) {
82  // Double clicking the vertical resize edge of a window should maximize it
83  // vertically.
84  gfx::Rect restored_bounds(10, 10, 50, 50);
85  aura::test::TestWindowDelegate wd;
86  scoped_ptr<aura::Window> window(CreateTestWindow(&wd, restored_bounds));
87
88  wm::ActivateWindow(window.get());
89
90  gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
91      window.get()).work_area();
92
93  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
94                                       window.get());
95
96  // Double-click the top resize edge.
97  wd.set_window_component(HTTOP);
98  // On X a double click actually generates a drag between each press/release.
99  // Explicitly trigger this path since we had bugs in dealing with it
100  // correctly.
101  generator.PressLeftButton();
102  generator.ReleaseLeftButton();
103  generator.set_flags(ui::EF_IS_DOUBLE_CLICK);
104  generator.PressLeftButton();
105  generator.MoveMouseTo(generator.current_location(), 1);
106  generator.ReleaseLeftButton();
107  gfx::Rect bounds_in_screen = window->GetBoundsInScreen();
108  EXPECT_EQ(restored_bounds.x(), bounds_in_screen.x());
109  EXPECT_EQ(restored_bounds.width(), bounds_in_screen.width());
110  EXPECT_EQ(work_area.y(), bounds_in_screen.y());
111  EXPECT_EQ(work_area.height(), bounds_in_screen.height());
112
113  wm::WindowState* window_state = wm::GetWindowState(window.get());
114  // Single-axis maximization is not considered real maximization.
115  EXPECT_FALSE(window_state->IsMaximized());
116
117  // Restore.
118  generator.DoubleClickLeftButton();
119  bounds_in_screen = window->GetBoundsInScreen();
120  EXPECT_EQ(restored_bounds.ToString(), bounds_in_screen.ToString());
121  // Note that it should not even be restored at this point, it should have
122  // also cleared the restore rectangle.
123  EXPECT_FALSE(window_state->HasRestoreBounds());
124
125  // Double-click the top resize edge again to maximize vertically, then double
126  // click again to restore.
127  generator.DoubleClickLeftButton();
128  wd.set_window_component(HTCAPTION);
129  generator.DoubleClickLeftButton();
130  EXPECT_FALSE(window_state->IsMaximized());
131  bounds_in_screen = window->GetBoundsInScreen();
132  EXPECT_EQ(restored_bounds.ToString(), bounds_in_screen.ToString());
133
134  // Double clicking the left resize edge should maximize horizontally.
135  wd.set_window_component(HTLEFT);
136  generator.DoubleClickLeftButton();
137  bounds_in_screen = window->GetBoundsInScreen();
138  EXPECT_EQ(restored_bounds.y(), bounds_in_screen.y());
139  EXPECT_EQ(restored_bounds.height(), bounds_in_screen.height());
140  EXPECT_EQ(work_area.x(), bounds_in_screen.x());
141  EXPECT_EQ(work_area.width(), bounds_in_screen.width());
142  // Single-axis maximization is not considered real maximization.
143  EXPECT_FALSE(window_state->IsMaximized());
144
145  // Restore.
146  wd.set_window_component(HTCAPTION);
147  generator.DoubleClickLeftButton();
148  EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString());
149
150#if defined(OS_WIN)
151  // Multi display test does not run on Win8 bot. crbug.com/247427.
152  if (base::win::GetVersion() >= base::win::VERSION_WIN8)
153    return;
154#endif
155
156  // Verify the double clicking the resize edge works on 2nd display too.
157  UpdateDisplay("200x200,400x300");
158  gfx::Rect work_area2 = ScreenAsh::GetSecondaryDisplay().work_area();
159  restored_bounds.SetRect(220,20, 50, 50);
160  window->SetBoundsInScreen(restored_bounds, ScreenAsh::GetSecondaryDisplay());
161  aura::Window* second_root = Shell::GetAllRootWindows()[1];
162  EXPECT_EQ(second_root, window->GetRootWindow());
163  aura::test::EventGenerator generator2(second_root, window.get());
164
165  // Y-axis maximization.
166  wd.set_window_component(HTTOP);
167  generator2.PressLeftButton();
168  generator2.ReleaseLeftButton();
169  generator2.set_flags(ui::EF_IS_DOUBLE_CLICK);
170  generator2.PressLeftButton();
171  generator2.MoveMouseTo(generator.current_location(), 1);
172  generator2.ReleaseLeftButton();
173  generator.DoubleClickLeftButton();
174  bounds_in_screen = window->GetBoundsInScreen();
175  EXPECT_EQ(restored_bounds.x(), bounds_in_screen.x());
176  EXPECT_EQ(restored_bounds.width(), bounds_in_screen.width());
177  EXPECT_EQ(work_area2.y(), bounds_in_screen.y());
178  EXPECT_EQ(work_area2.height(), bounds_in_screen.height());
179  EXPECT_FALSE(window_state->IsMaximized());
180
181  // Restore.
182  wd.set_window_component(HTCAPTION);
183  generator2.DoubleClickLeftButton();
184  EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString());
185
186  // X-axis maximization.
187  wd.set_window_component(HTLEFT);
188  generator2.DoubleClickLeftButton();
189  bounds_in_screen = window->GetBoundsInScreen();
190  EXPECT_EQ(restored_bounds.y(), bounds_in_screen.y());
191  EXPECT_EQ(restored_bounds.height(), bounds_in_screen.height());
192  EXPECT_EQ(work_area2.x(), bounds_in_screen.x());
193  EXPECT_EQ(work_area2.width(), bounds_in_screen.width());
194  EXPECT_FALSE(window_state->IsMaximized());
195
196  // Restore.
197  wd.set_window_component(HTCAPTION);
198  generator2.DoubleClickLeftButton();
199  EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString());
200}
201
202TEST_F(WorkspaceEventHandlerTest,
203    DoubleClickSingleAxisDoesntResizeVerticalEdgeIfConstrained) {
204  gfx::Rect restored_bounds(10, 10, 50, 50);
205  aura::test::TestWindowDelegate wd;
206  scoped_ptr<aura::Window> window(CreateTestWindow(&wd, restored_bounds));
207
208  wm::ActivateWindow(window.get());
209
210  gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
211      window.get()).work_area();
212
213  wd.set_maximum_size(gfx::Size(0, 100));
214
215  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
216                                       window.get());
217  // Double-click the top resize edge.
218  wd.set_window_component(HTTOP);
219  generator.DoubleClickLeftButton();
220
221  // The size of the window should be unchanged.
222  EXPECT_EQ(restored_bounds.y(), window->bounds().y());
223  EXPECT_EQ(restored_bounds.height(), window->bounds().height());
224}
225
226TEST_F(WorkspaceEventHandlerTest,
227    DoubleClickSingleAxisDoesntResizeHorizontalEdgeIfConstrained) {
228  gfx::Rect restored_bounds(10, 10, 50, 50);
229  aura::test::TestWindowDelegate wd;
230  scoped_ptr<aura::Window> window(CreateTestWindow(&wd, restored_bounds));
231
232  wm::ActivateWindow(window.get());
233
234  gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
235      window.get()).work_area();
236
237  wd.set_maximum_size(gfx::Size(100, 0));
238
239  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
240                                       window.get());
241  // Double-click the top resize edge.
242  wd.set_window_component(HTRIGHT);
243  generator.DoubleClickLeftButton();
244
245  // The size of the window should be unchanged.
246  EXPECT_EQ(restored_bounds.x(), window->bounds().x());
247  EXPECT_EQ(restored_bounds.width(), window->bounds().width());
248}
249
250TEST_F(WorkspaceEventHandlerTest, DoubleClickCaptionTogglesMaximize) {
251  aura::test::TestWindowDelegate wd;
252  scoped_ptr<aura::Window> window(
253      CreateTestWindow(&wd, gfx::Rect(1, 2, 30, 40)));
254  window->SetProperty(aura::client::kCanMaximizeKey, true);
255  wd.set_window_component(HTCAPTION);
256
257  wm::WindowState* window_state = wm::GetWindowState(window.get());
258  EXPECT_FALSE(window_state->IsMaximized());
259  aura::Window* root = Shell::GetPrimaryRootWindow();
260  aura::test::EventGenerator generator(root, window.get());
261  generator.DoubleClickLeftButton();
262  EXPECT_NE("1,2 30x40", window->bounds().ToString());
263
264  EXPECT_TRUE(window_state->IsMaximized());
265  generator.DoubleClickLeftButton();
266
267  EXPECT_FALSE(window_state->IsMaximized());
268  EXPECT_EQ("1,2 30x40", window->bounds().ToString());
269
270  // Double-clicking the middle button shouldn't toggle the maximized state.
271  WindowPropertyObserver observer(window.get());
272  ui::MouseEvent press(ui::ET_MOUSE_PRESSED, generator.current_location(),
273                       generator.current_location(),
274                       ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK);
275  aura::WindowEventDispatcher* dispatcher = root->GetDispatcher();
276  dispatcher->AsRootWindowHostDelegate()->OnHostMouseEvent(&press);
277  ui::MouseEvent release(ui::ET_MOUSE_RELEASED, generator.current_location(),
278                         generator.current_location(),
279                         ui::EF_IS_DOUBLE_CLICK);
280  dispatcher->AsRootWindowHostDelegate()->OnHostMouseEvent(&release);
281
282  EXPECT_FALSE(window_state->IsMaximized());
283  EXPECT_EQ("1,2 30x40", window->bounds().ToString());
284  EXPECT_FALSE(observer.DidPropertyChange(aura::client::kShowStateKey));
285}
286
287TEST_F(WorkspaceEventHandlerTest, DoubleTapCaptionTogglesMaximize) {
288  aura::test::TestWindowDelegate wd;
289  gfx::Rect bounds(10, 20, 30, 40);
290  scoped_ptr<aura::Window> window(CreateTestWindow(&wd, bounds));
291  window->SetProperty(aura::client::kCanMaximizeKey, true);
292  wd.set_window_component(HTCAPTION);
293
294  wm::WindowState* window_state = wm::GetWindowState(window.get());
295  EXPECT_FALSE(window_state->IsMaximized());
296  aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
297                                       window.get());
298  generator.GestureTapAt(gfx::Point(25, 25));
299  generator.GestureTapAt(gfx::Point(25, 25));
300  RunAllPendingInMessageLoop();
301  EXPECT_NE(bounds.ToString(), window->bounds().ToString());
302  EXPECT_TRUE(window_state->IsMaximized());
303
304  generator.GestureTapAt(gfx::Point(5, 5));
305  generator.GestureTapAt(gfx::Point(10, 10));
306
307  EXPECT_FALSE(window_state->IsMaximized());
308  EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
309}
310
311// Verifies deleting the window while dragging doesn't crash.
312TEST_F(WorkspaceEventHandlerTest, DeleteWhenDragging) {
313  // Create a large window in the background. This is necessary so that when we
314  // delete |window| WorkspaceEventHandler is still the active event handler.
315  aura::test::TestWindowDelegate wd2;
316  scoped_ptr<aura::Window> window2(
317      CreateTestWindow(&wd2, gfx::Rect(0, 0, 500, 500)));
318
319  aura::test::TestWindowDelegate wd;
320  const gfx::Rect bounds(10, 20, 30, 40);
321  scoped_ptr<aura::Window> window(CreateTestWindow(&wd, bounds));
322  wd.set_window_component(HTCAPTION);
323  aura::test::EventGenerator generator(window->GetRootWindow());
324  generator.MoveMouseToCenterOf(window.get());
325  generator.PressLeftButton();
326  generator.MoveMouseTo(generator.current_location() + gfx::Vector2d(50, 50));
327  DCHECK_NE(bounds.origin().ToString(), window->bounds().origin().ToString());
328  window.reset();
329  generator.MoveMouseTo(generator.current_location() + gfx::Vector2d(50, 50));
330}
331
332// Verifies deleting the window while in a run loop doesn't crash.
333TEST_F(WorkspaceEventHandlerTest, DeleteWhileInRunLoop) {
334  aura::test::TestWindowDelegate wd;
335  const gfx::Rect bounds(10, 20, 30, 40);
336  scoped_ptr<aura::Window> window(CreateTestWindow(&wd, bounds));
337  wd.set_window_component(HTCAPTION);
338
339  ASSERT_TRUE(aura::client::GetWindowMoveClient(window->parent()));
340  base::MessageLoop::current()->DeleteSoon(FROM_HERE, window.get());
341  aura::client::GetWindowMoveClient(window->parent())
342      ->RunMoveLoop(window.release(),
343                    gfx::Vector2d(),
344                    aura::client::WINDOW_MOVE_SOURCE_MOUSE);
345}
346
347}  // namespace internal
348}  // namespace ash
349