Home | History | Annotate | Download | only in workspace 
      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