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_util.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/wm_event.h" 13 #include "ash/wm/workspace_controller.h" 14 #include "ash/wm/workspace_controller_test_helper.h" 15 #include "ui/aura/client/aura_constants.h" 16 #include "ui/aura/test/test_window_delegate.h" 17 #include "ui/aura/window.h" 18 #include "ui/aura/window_tree_host.h" 19 #include "ui/base/hit_test.h" 20 #include "ui/events/event_processor.h" 21 #include "ui/events/test/event_generator.h" 22 #include "ui/gfx/screen.h" 23 #include "ui/wm/core/window_util.h" 24 #include "ui/wm/public/window_move_client.h" 25 26 #if defined(OS_WIN) 27 #include "base/win/windows_version.h" 28 #endif 29 30 namespace ash { 31 32 class WorkspaceEventHandlerTest : public test::AshTestBase { 33 public: 34 WorkspaceEventHandlerTest() {} 35 virtual ~WorkspaceEventHandlerTest() {} 36 37 protected: 38 aura::Window* CreateTestWindow(aura::WindowDelegate* delegate, 39 const gfx::Rect& bounds) { 40 aura::Window* window = new aura::Window(delegate); 41 window->SetType(ui::wm::WINDOW_TYPE_NORMAL); 42 window->Init(aura::WINDOW_LAYER_TEXTURED); 43 ParentWindowInPrimaryRootWindow(window); 44 window->SetBounds(bounds); 45 window->Show(); 46 return window; 47 } 48 49 private: 50 DISALLOW_COPY_AND_ASSIGN(WorkspaceEventHandlerTest); 51 }; 52 53 // Keeps track of the properties changed of a particular window. 54 class WindowPropertyObserver : public aura::WindowObserver { 55 public: 56 explicit WindowPropertyObserver(aura::Window* window) 57 : window_(window) { 58 window->AddObserver(this); 59 } 60 61 virtual ~WindowPropertyObserver() { 62 window_->RemoveObserver(this); 63 } 64 65 bool DidPropertyChange(const void* property) const { 66 return std::find(properties_changed_.begin(), 67 properties_changed_.end(), 68 property) != properties_changed_.end(); 69 } 70 71 private: 72 virtual void OnWindowPropertyChanged(aura::Window* window, 73 const void* key, 74 intptr_t old) OVERRIDE { 75 properties_changed_.push_back(key); 76 } 77 78 aura::Window* window_; 79 std::vector<const void*> properties_changed_; 80 81 DISALLOW_COPY_AND_ASSIGN(WindowPropertyObserver); 82 }; 83 84 TEST_F(WorkspaceEventHandlerTest, DoubleClickSingleAxisResizeEdge) { 85 // Double clicking the vertical resize edge of a window should maximize it 86 // vertically. 87 gfx::Rect restored_bounds(10, 10, 50, 50); 88 aura::test::TestWindowDelegate delegate; 89 scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, restored_bounds)); 90 91 wm::ActivateWindow(window.get()); 92 93 gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow( 94 window.get()).work_area(); 95 96 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), 97 window.get()); 98 99 // Double-click the top resize edge. 100 delegate.set_window_component(HTTOP); 101 // On X a double click actually generates a drag between each press/release. 102 // Explicitly trigger this path since we had bugs in dealing with it 103 // correctly. 104 generator.PressLeftButton(); 105 generator.ReleaseLeftButton(); 106 generator.set_flags(ui::EF_IS_DOUBLE_CLICK); 107 generator.PressLeftButton(); 108 generator.MoveMouseTo(generator.current_location(), 1); 109 generator.ReleaseLeftButton(); 110 gfx::Rect bounds_in_screen = window->GetBoundsInScreen(); 111 EXPECT_EQ(restored_bounds.x(), bounds_in_screen.x()); 112 EXPECT_EQ(restored_bounds.width(), bounds_in_screen.width()); 113 EXPECT_EQ(work_area.y(), bounds_in_screen.y()); 114 EXPECT_EQ(work_area.height(), bounds_in_screen.height()); 115 116 wm::WindowState* window_state = wm::GetWindowState(window.get()); 117 // Single-axis maximization is not considered real maximization. 118 EXPECT_FALSE(window_state->IsMaximized()); 119 120 // Restore. 121 generator.DoubleClickLeftButton(); 122 bounds_in_screen = window->GetBoundsInScreen(); 123 EXPECT_EQ(restored_bounds.ToString(), bounds_in_screen.ToString()); 124 // Note that it should not even be restored at this point, it should have 125 // also cleared the restore rectangle. 126 EXPECT_FALSE(window_state->HasRestoreBounds()); 127 128 // Double clicking the left resize edge should maximize horizontally. 129 delegate.set_window_component(HTLEFT); 130 generator.DoubleClickLeftButton(); 131 bounds_in_screen = window->GetBoundsInScreen(); 132 EXPECT_EQ(restored_bounds.y(), bounds_in_screen.y()); 133 EXPECT_EQ(restored_bounds.height(), bounds_in_screen.height()); 134 EXPECT_EQ(work_area.x(), bounds_in_screen.x()); 135 EXPECT_EQ(work_area.width(), bounds_in_screen.width()); 136 // Single-axis maximization is not considered real maximization. 137 EXPECT_FALSE(window_state->IsMaximized()); 138 139 // Restore. 140 generator.DoubleClickLeftButton(); 141 EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString()); 142 143 #if defined(OS_WIN) 144 // Multi display test does not run on Win8 bot. crbug.com/247427. 145 if (!SupportsMultipleDisplays()) 146 return; 147 #endif 148 149 // Verify the double clicking the resize edge works on 2nd display too. 150 UpdateDisplay("200x200,400x300"); 151 gfx::Rect work_area2 = ScreenUtil::GetSecondaryDisplay().work_area(); 152 restored_bounds.SetRect(220, 20, 50, 50); 153 window->SetBoundsInScreen(restored_bounds, ScreenUtil::GetSecondaryDisplay()); 154 aura::Window* second_root = Shell::GetAllRootWindows()[1]; 155 EXPECT_EQ(second_root, window->GetRootWindow()); 156 ui::test::EventGenerator generator2(second_root, window.get()); 157 158 // Y-axis maximization. 159 delegate.set_window_component(HTTOP); 160 generator2.PressLeftButton(); 161 generator2.ReleaseLeftButton(); 162 generator2.set_flags(ui::EF_IS_DOUBLE_CLICK); 163 generator2.PressLeftButton(); 164 generator2.MoveMouseTo(generator.current_location(), 1); 165 generator2.ReleaseLeftButton(); 166 generator.DoubleClickLeftButton(); 167 bounds_in_screen = window->GetBoundsInScreen(); 168 EXPECT_EQ(restored_bounds.x(), bounds_in_screen.x()); 169 EXPECT_EQ(restored_bounds.width(), bounds_in_screen.width()); 170 EXPECT_EQ(work_area2.y(), bounds_in_screen.y()); 171 EXPECT_EQ(work_area2.height(), bounds_in_screen.height()); 172 EXPECT_FALSE(window_state->IsMaximized()); 173 174 // Restore. 175 generator2.DoubleClickLeftButton(); 176 EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString()); 177 178 // X-axis maximization. 179 delegate.set_window_component(HTLEFT); 180 generator2.DoubleClickLeftButton(); 181 bounds_in_screen = window->GetBoundsInScreen(); 182 EXPECT_EQ(restored_bounds.y(), bounds_in_screen.y()); 183 EXPECT_EQ(restored_bounds.height(), bounds_in_screen.height()); 184 EXPECT_EQ(work_area2.x(), bounds_in_screen.x()); 185 EXPECT_EQ(work_area2.width(), bounds_in_screen.width()); 186 EXPECT_FALSE(window_state->IsMaximized()); 187 188 // Restore. 189 generator2.DoubleClickLeftButton(); 190 EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString()); 191 } 192 193 // Tests the behavior when double clicking the border of a side snapped window. 194 TEST_F(WorkspaceEventHandlerTest, DoubleClickSingleAxisWhenSideSnapped) { 195 gfx::Rect restored_bounds(10, 10, 50, 50); 196 aura::test::TestWindowDelegate delegate; 197 scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, restored_bounds)); 198 199 gfx::Rect work_area_in_screen = Shell::GetScreen()->GetDisplayNearestWindow( 200 window.get()).work_area(); 201 202 wm::WindowState* window_state = wm::GetWindowState(window.get()); 203 const wm::WMEvent snap_event(wm::WM_EVENT_SNAP_LEFT); 204 window_state->OnWMEvent(&snap_event); 205 206 gfx::Rect snapped_bounds_in_screen = window->GetBoundsInScreen(); 207 EXPECT_EQ(work_area_in_screen.x(), snapped_bounds_in_screen.x()); 208 EXPECT_EQ(work_area_in_screen.y(), snapped_bounds_in_screen.y()); 209 EXPECT_GT(work_area_in_screen.width(), snapped_bounds_in_screen.width()); 210 EXPECT_EQ(work_area_in_screen.height(), snapped_bounds_in_screen.height()); 211 212 // Double clicking the top border should not do anything for side snapped 213 // windows. (They already take up the entire workspace height and reverting 214 // to the restored bounds would be weird). 215 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), 216 window.get()); 217 delegate.set_window_component(HTTOP); 218 generator.DoubleClickLeftButton(); 219 EXPECT_EQ(wm::WINDOW_STATE_TYPE_LEFT_SNAPPED, window_state->GetStateType()); 220 EXPECT_EQ(snapped_bounds_in_screen.ToString(), 221 window->GetBoundsInScreen().ToString()); 222 223 // Double clicking the right border should exit the side snapped state and 224 // make the window take up the entire work area. 225 delegate.set_window_component(HTRIGHT); 226 generator.DoubleClickLeftButton(); 227 EXPECT_TRUE(window_state->IsNormalStateType()); 228 EXPECT_EQ(work_area_in_screen.ToString(), 229 window->GetBoundsInScreen().ToString()); 230 } 231 232 TEST_F(WorkspaceEventHandlerTest, 233 DoubleClickSingleAxisDoesntResizeVerticalEdgeIfConstrained) { 234 gfx::Rect restored_bounds(10, 10, 50, 50); 235 aura::test::TestWindowDelegate delegate; 236 scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, restored_bounds)); 237 238 wm::ActivateWindow(window.get()); 239 240 gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow( 241 window.get()).work_area(); 242 243 delegate.set_maximum_size(gfx::Size(0, 100)); 244 245 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), 246 window.get()); 247 // Double-click the top resize edge. 248 delegate.set_window_component(HTTOP); 249 generator.DoubleClickLeftButton(); 250 251 // The size of the window should be unchanged. 252 EXPECT_EQ(restored_bounds.y(), window->bounds().y()); 253 EXPECT_EQ(restored_bounds.height(), window->bounds().height()); 254 } 255 256 TEST_F(WorkspaceEventHandlerTest, 257 DoubleClickSingleAxisDoesntResizeHorizontalEdgeIfConstrained) { 258 gfx::Rect restored_bounds(10, 10, 50, 50); 259 aura::test::TestWindowDelegate delegate; 260 scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, restored_bounds)); 261 262 wm::ActivateWindow(window.get()); 263 264 gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow( 265 window.get()).work_area(); 266 267 delegate.set_maximum_size(gfx::Size(100, 0)); 268 269 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), 270 window.get()); 271 // Double-click the top resize edge. 272 delegate.set_window_component(HTRIGHT); 273 generator.DoubleClickLeftButton(); 274 275 // The size of the window should be unchanged. 276 EXPECT_EQ(restored_bounds.x(), window->bounds().x()); 277 EXPECT_EQ(restored_bounds.width(), window->bounds().width()); 278 } 279 280 TEST_F(WorkspaceEventHandlerTest, 281 DoubleClickOrTapWithModalChildDoesntMaximize) { 282 aura::test::TestWindowDelegate delegate1; 283 aura::test::TestWindowDelegate delegate2; 284 scoped_ptr<aura::Window> window( 285 CreateTestWindow(&delegate1, gfx::Rect(10, 20, 30, 40))); 286 scoped_ptr<aura::Window> child( 287 CreateTestWindow(&delegate2, gfx::Rect(0, 0, 1, 1))); 288 window->SetProperty(aura::client::kCanMaximizeKey, true); 289 delegate1.set_window_component(HTCAPTION); 290 291 child->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW); 292 ::wm::AddTransientChild(window.get(), child.get()); 293 294 wm::WindowState* window_state = wm::GetWindowState(window.get()); 295 EXPECT_FALSE(window_state->IsMaximized()); 296 aura::Window* root = Shell::GetPrimaryRootWindow(); 297 ui::test::EventGenerator generator(root, window.get()); 298 generator.DoubleClickLeftButton(); 299 EXPECT_EQ("10,20 30x40", window->bounds().ToString()); 300 EXPECT_FALSE(window_state->IsMaximized()); 301 302 generator.GestureTapAt(gfx::Point(25, 25)); 303 generator.GestureTapAt(gfx::Point(25, 25)); 304 RunAllPendingInMessageLoop(); 305 EXPECT_EQ("10,20 30x40", window->bounds().ToString()); 306 EXPECT_FALSE(window_state->IsMaximized()); 307 } 308 309 // Test the behavior as a result of double clicking the window header. 310 TEST_F(WorkspaceEventHandlerTest, DoubleClickCaptionTogglesMaximize) { 311 aura::test::TestWindowDelegate delegate; 312 scoped_ptr<aura::Window> window( 313 CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40))); 314 window->SetProperty(aura::client::kCanMaximizeKey, true); 315 316 wm::WindowState* window_state = wm::GetWindowState(window.get()); 317 gfx::Rect restore_bounds = window->bounds(); 318 gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent( 319 window.get()); 320 321 EXPECT_FALSE(window_state->IsMaximized()); 322 323 // 1) Double clicking a normal window should maximize. 324 delegate.set_window_component(HTCAPTION); 325 aura::Window* root = Shell::GetPrimaryRootWindow(); 326 ui::test::EventGenerator generator(root, window.get()); 327 generator.ClickLeftButton(); 328 generator.DoubleClickLeftButton(); 329 EXPECT_NE(restore_bounds.ToString(), window->bounds().ToString()); 330 EXPECT_TRUE(window_state->IsMaximized()); 331 332 generator.ClickLeftButton(); 333 generator.DoubleClickLeftButton(); 334 EXPECT_TRUE(window_state->IsNormalStateType()); 335 EXPECT_EQ(restore_bounds.ToString(), window->bounds().ToString()); 336 337 // 2) Double clicking a horizontally maximized window should maximize. 338 delegate.set_window_component(HTLEFT); 339 generator.ClickLeftButton(); 340 generator.DoubleClickLeftButton(); 341 EXPECT_TRUE(window_state->IsNormalStateType()); 342 EXPECT_EQ(work_area_in_parent.x(), window->bounds().x()); 343 EXPECT_EQ(restore_bounds.y(), window->bounds().y()); 344 EXPECT_EQ(work_area_in_parent.width(), window->bounds().width()); 345 EXPECT_EQ(restore_bounds.height(), window->bounds().height()); 346 347 delegate.set_window_component(HTCAPTION); 348 generator.ClickLeftButton(); 349 generator.DoubleClickLeftButton(); 350 EXPECT_TRUE(window_state->IsMaximized()); 351 352 generator.ClickLeftButton(); 353 generator.DoubleClickLeftButton(); 354 EXPECT_TRUE(window_state->IsNormalStateType()); 355 EXPECT_EQ(restore_bounds.ToString(), window->bounds().ToString()); 356 357 // 3) Double clicking a snapped window should maximize. 358 const wm::WMEvent snap_event(wm::WM_EVENT_SNAP_LEFT); 359 window_state->OnWMEvent(&snap_event); 360 EXPECT_TRUE(window_state->IsSnapped()); 361 generator.MoveMouseTo(window->GetBoundsInRootWindow().CenterPoint()); 362 generator.ClickLeftButton(); 363 generator.DoubleClickLeftButton(); 364 EXPECT_TRUE(window_state->IsMaximized()); 365 366 generator.ClickLeftButton(); 367 generator.DoubleClickLeftButton(); 368 EXPECT_TRUE(window_state->IsNormalStateType()); 369 EXPECT_EQ(restore_bounds.ToString(), window->bounds().ToString()); 370 } 371 372 // Test that double clicking the middle button on the window header does not 373 // toggle the maximized state. 374 TEST_F(WorkspaceEventHandlerTest, 375 DoubleClickMiddleButtonDoesNotToggleMaximize) { 376 aura::test::TestWindowDelegate delegate; 377 scoped_ptr<aura::Window> window( 378 CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40))); 379 window->SetProperty(aura::client::kCanMaximizeKey, true); 380 delegate.set_window_component(HTCAPTION); 381 aura::Window* root = Shell::GetPrimaryRootWindow(); 382 ui::test::EventGenerator generator(root, window.get()); 383 384 WindowPropertyObserver observer(window.get()); 385 ui::MouseEvent press(ui::ET_MOUSE_PRESSED, generator.current_location(), 386 generator.current_location(), 387 ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK, 388 ui::EF_MIDDLE_MOUSE_BUTTON); 389 ui::EventProcessor* dispatcher = root->GetHost()->event_processor(); 390 ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&press); 391 ASSERT_FALSE(details.dispatcher_destroyed); 392 ui::MouseEvent release(ui::ET_MOUSE_RELEASED, generator.current_location(), 393 generator.current_location(), 394 ui::EF_IS_DOUBLE_CLICK, 395 ui::EF_MIDDLE_MOUSE_BUTTON); 396 details = dispatcher->OnEventFromSource(&release); 397 ASSERT_FALSE(details.dispatcher_destroyed); 398 399 EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized()); 400 EXPECT_EQ("1,2 30x40", window->bounds().ToString()); 401 EXPECT_FALSE(observer.DidPropertyChange(aura::client::kShowStateKey)); 402 } 403 404 TEST_F(WorkspaceEventHandlerTest, DoubleTapCaptionTogglesMaximize) { 405 aura::test::TestWindowDelegate delegate; 406 gfx::Rect bounds(10, 20, 30, 40); 407 scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, bounds)); 408 window->SetProperty(aura::client::kCanMaximizeKey, true); 409 delegate.set_window_component(HTCAPTION); 410 411 wm::WindowState* window_state = wm::GetWindowState(window.get()); 412 EXPECT_FALSE(window_state->IsMaximized()); 413 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(), 414 window.get()); 415 generator.GestureTapAt(gfx::Point(25, 25)); 416 generator.GestureTapAt(gfx::Point(25, 25)); 417 RunAllPendingInMessageLoop(); 418 EXPECT_NE(bounds.ToString(), window->bounds().ToString()); 419 EXPECT_TRUE(window_state->IsMaximized()); 420 421 generator.GestureTapAt(gfx::Point(5, 5)); 422 generator.GestureTapAt(gfx::Point(10, 10)); 423 424 EXPECT_FALSE(window_state->IsMaximized()); 425 EXPECT_EQ(bounds.ToString(), window->bounds().ToString()); 426 } 427 428 // Verifies deleting the window while dragging doesn't crash. 429 TEST_F(WorkspaceEventHandlerTest, DeleteWhenDragging) { 430 // Create a large window in the background. This is necessary so that when we 431 // delete |window| WorkspaceEventHandler is still the active event handler. 432 aura::test::TestWindowDelegate delegate2; 433 scoped_ptr<aura::Window> window2( 434 CreateTestWindow(&delegate2, gfx::Rect(0, 0, 500, 500))); 435 436 aura::test::TestWindowDelegate delegate; 437 const gfx::Rect bounds(10, 20, 30, 40); 438 scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, bounds)); 439 delegate.set_window_component(HTCAPTION); 440 ui::test::EventGenerator generator(window->GetRootWindow()); 441 generator.MoveMouseToCenterOf(window.get()); 442 generator.PressLeftButton(); 443 generator.MoveMouseTo(generator.current_location() + gfx::Vector2d(50, 50)); 444 DCHECK_NE(bounds.origin().ToString(), window->bounds().origin().ToString()); 445 window.reset(); 446 generator.MoveMouseTo(generator.current_location() + gfx::Vector2d(50, 50)); 447 } 448 449 // Verifies deleting the window while in a run loop doesn't crash. 450 TEST_F(WorkspaceEventHandlerTest, DeleteWhileInRunLoop) { 451 aura::test::TestWindowDelegate delegate; 452 const gfx::Rect bounds(10, 20, 30, 40); 453 scoped_ptr<aura::Window> window(CreateTestWindow(&delegate, bounds)); 454 delegate.set_window_component(HTCAPTION); 455 456 ASSERT_TRUE(aura::client::GetWindowMoveClient(window->GetRootWindow())); 457 base::MessageLoop::current()->DeleteSoon(FROM_HERE, window.get()); 458 aura::client::GetWindowMoveClient(window->GetRootWindow()) 459 ->RunMoveLoop(window.release(), 460 gfx::Vector2d(), 461 aura::client::WINDOW_MOVE_SOURCE_MOUSE); 462 } 463 464 // Verifies that double clicking in the header does not maximize if the target 465 // component has changed. 466 TEST_F(WorkspaceEventHandlerTest, 467 DoubleClickTwoDifferentTargetsDoesntMaximize) { 468 aura::test::TestWindowDelegate delegate; 469 scoped_ptr<aura::Window> window( 470 CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40))); 471 window->SetProperty(aura::client::kCanMaximizeKey, true); 472 473 wm::WindowState* window_state = wm::GetWindowState(window.get()); 474 gfx::Rect restore_bounds = window->bounds(); 475 gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent( 476 window.get()); 477 478 EXPECT_FALSE(window_state->IsMaximized()); 479 480 // First click will go to a client 481 delegate.set_window_component(HTCLIENT); 482 aura::Window* root = Shell::GetPrimaryRootWindow(); 483 ui::test::EventGenerator generator(root, window.get()); 484 generator.ClickLeftButton(); 485 EXPECT_FALSE(window_state->IsMaximized()); 486 487 // Second click will go to the header 488 delegate.set_window_component(HTCAPTION); 489 generator.DoubleClickLeftButton(); 490 EXPECT_FALSE(window_state->IsMaximized()); 491 } 492 493 // Verifies that double tapping in the header does not maximize if the target 494 // component has changed. 495 TEST_F(WorkspaceEventHandlerTest, DoubleTapTwoDifferentTargetsDoesntMaximize) { 496 aura::test::TestWindowDelegate delegate; 497 scoped_ptr<aura::Window> window( 498 CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40))); 499 window->SetProperty(aura::client::kCanMaximizeKey, true); 500 501 wm::WindowState* window_state = wm::GetWindowState(window.get()); 502 gfx::Rect restore_bounds = window->bounds(); 503 gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent( 504 window.get()); 505 506 EXPECT_FALSE(window_state->IsMaximized()); 507 508 // First tap will go to a client 509 delegate.set_window_component(HTCLIENT); 510 aura::Window* root = Shell::GetPrimaryRootWindow(); 511 ui::test::EventGenerator generator(root, window.get()); 512 generator.GestureTapAt(gfx::Point(25, 25)); 513 EXPECT_FALSE(window_state->IsMaximized()); 514 515 // Second tap will go to the header 516 delegate.set_window_component(HTCAPTION); 517 generator.GestureTapAt(gfx::Point(25, 25)); 518 EXPECT_FALSE(window_state->IsMaximized()); 519 } 520 521 TEST_F(WorkspaceEventHandlerTest, 522 RightClickDuringDoubleClickDoesntMaximize) { 523 aura::test::TestWindowDelegate delegate; 524 scoped_ptr<aura::Window> window( 525 CreateTestWindow(&delegate, gfx::Rect(1, 2, 30, 40))); 526 window->SetProperty(aura::client::kCanMaximizeKey, true); 527 528 wm::WindowState* window_state = wm::GetWindowState(window.get()); 529 gfx::Rect restore_bounds = window->bounds(); 530 gfx::Rect work_area_in_parent = ScreenUtil::GetDisplayWorkAreaBoundsInParent( 531 window.get()); 532 533 EXPECT_FALSE(window_state->IsMaximized()); 534 535 // First click will go to a client 536 delegate.set_window_component(HTCLIENT); 537 aura::Window* root = Shell::GetPrimaryRootWindow(); 538 ui::test::EventGenerator generator(root, window.get()); 539 generator.ClickLeftButton(); 540 EXPECT_FALSE(window_state->IsMaximized()); 541 542 // Second click will go to the header 543 delegate.set_window_component(HTCAPTION); 544 generator.PressRightButton(); 545 generator.ReleaseRightButton(); 546 EXPECT_FALSE(window_state->IsMaximized()); 547 generator.DoubleClickLeftButton(); 548 EXPECT_FALSE(window_state->IsMaximized()); 549 } 550 551 } // namespace ash 552