src/ash/wm/workspace/workspace_event_handler_unittest.cc

   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
  26 namespace ash {
  27 namespace internal {
  28
  29 class 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.
  51 class 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
  81 TEST_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::RootWindow* 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
 202 TEST_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
 226 TEST_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
 250 TEST_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
 287 TEST_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.
 312 TEST_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.
 333 TEST_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