athena/wm/window_manager_unittest.cc

   1 // Copyright 2014 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 "athena/wm/public/window_manager.h"
   6
   7 #include "athena/screen/public/screen_manager.h"
   8 #include "athena/test/athena_test_base.h"
   9 #include "athena/wm/public/window_list_provider.h"
  10 #include "athena/wm/split_view_controller.h"
  11 #include "athena/wm/test/window_manager_impl_test_api.h"
  12 #include "athena/wm/window_manager_impl.h"
  13 #include "ui/aura/client/window_tree_client.h"
  14 #include "ui/aura/test/test_window_delegate.h"
  15 #include "ui/aura/window.h"
  16 #include "ui/base/hit_test.h"
  17 #include "ui/events/test/event_generator.h"
  18 #include "ui/gfx/display.h"
  19 #include "ui/gfx/screen.h"
  20 #include "ui/wm/core/window_util.h"
  21
  22 namespace {
  23
  24 scoped_ptr<aura::Window> CreateWindow(aura::WindowDelegate* delegate) {
  25   scoped_ptr<aura::Window> window(new aura::Window(delegate));
  26   window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
  27   window->Init(aura::WINDOW_LAYER_SOLID_COLOR);
  28   window->Show();
  29   return window.Pass();
  30 }
  31
  32 }  // namespace
  33
  34 namespace athena {
  35
  36 typedef test::AthenaTestBase WindowManagerTest;
  37
  38 TEST_F(WindowManagerTest, Empty) {
  39 }
  40
  41 TEST_F(WindowManagerTest, OverviewModeBasics) {
  42   aura::test::TestWindowDelegate delegate;
  43   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
  44   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
  45
  46   test::WindowManagerImplTestApi wm_api;
  47   aura::client::ParentWindowWithContext(
  48       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
  49   aura::client::ParentWindowWithContext(
  50       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
  51
  52   ASSERT_FALSE(WindowManager::GetInstance()->IsOverviewModeActive());
  53   EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
  54   EXPECT_EQ(gfx::Screen::GetNativeScreen()
  55                 ->GetPrimaryDisplay()
  56                 .work_area()
  57                 .size()
  58                 .ToString(),
  59             first->bounds().size().ToString());
  60   EXPECT_FALSE(WindowManager::GetInstance()->IsOverviewModeActive());
  61
  62   // Tests that going into overview mode does not change the window bounds.
  63   WindowManager::GetInstance()->ToggleOverview();
  64   ASSERT_TRUE(WindowManager::GetInstance()->IsOverviewModeActive());
  65   EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
  66   EXPECT_EQ(gfx::Screen::GetNativeScreen()
  67                 ->GetPrimaryDisplay()
  68                 .work_area()
  69                 .size()
  70                 .ToString(),
  71             first->bounds().size().ToString());
  72 }
  73
  74 TEST_F(WindowManagerTest, BezelGestureToSplitViewMode) {
  75   aura::test::TestWindowDelegate delegate;
  76   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
  77   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
  78   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
  79
  80   test::WindowManagerImplTestApi wm_api;
  81   aura::client::ParentWindowWithContext(
  82       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
  83   aura::client::ParentWindowWithContext(
  84       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
  85   aura::client::ParentWindowWithContext(
  86       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
  87
  88   // Test that going into split-view mode with two-finger gesture selects the
  89   // correct windows on left and right splits.
  90   ui::test::EventGenerator generator(root_window());
  91   const gfx::Point start_points[2] = {
  92       gfx::Point(2, 10), gfx::Point(4, 20),
  93   };
  94   const int kEventTimeSepration = 16;
  95   int x_middle = root_window()->bounds().width() / 2;
  96   generator.GestureMultiFingerScroll(
  97       2, start_points, kEventTimeSepration, 1, x_middle, 0);
  98   ASSERT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
  99   EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
 100   EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window());
 101   EXPECT_EQ(second->bounds().size().ToString(),
 102             third->bounds().size().ToString());
 103 }
 104
 105 TEST_F(WindowManagerTest, BezelGestureToSwitchBetweenWindows) {
 106   aura::test::TestWindowDelegate delegate;
 107   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
 108   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
 109   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
 110
 111   test::WindowManagerImplTestApi wm_api;
 112   aura::client::ParentWindowWithContext(
 113       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 114   aura::client::ParentWindowWithContext(
 115       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 116   aura::client::ParentWindowWithContext(
 117       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 118
 119   EXPECT_EQ(third.get(),
 120             wm_api.GetWindowListProvider()->GetWindowList().back());
 121
 122   // Do a two-finger swipe from the left bezel.
 123   ui::test::EventGenerator generator(root_window());
 124   const gfx::Point left_bezel_points[2] = {
 125       gfx::Point(2, 10), gfx::Point(4, 20),
 126   };
 127   const int kEventTimeSepration = 16;
 128   int width = root_window()->bounds().width();
 129   generator.GestureMultiFingerScroll(
 130       2, left_bezel_points, kEventTimeSepration, 1, width, 0);
 131   EXPECT_TRUE(wm::IsActiveWindow(second.get()));
 132   EXPECT_EQ(second.get(),
 133             wm_api.GetWindowListProvider()->GetWindowList().back());
 134 }
 135
 136 TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
 137   aura::test::TestWindowDelegate delegate;
 138   delegate.set_window_component(HTCAPTION);
 139   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
 140   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
 141   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
 142
 143   test::WindowManagerImplTestApi wm_api;
 144   aura::client::ParentWindowWithContext(
 145       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 146   aura::client::ParentWindowWithContext(
 147       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 148   aura::client::ParentWindowWithContext(
 149       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 150
 151   EXPECT_EQ(third.get(),
 152             wm_api.GetWindowListProvider()->GetWindowList().back());
 153
 154   // Do a title-swipe from the top to switch to the previous window.
 155   ui::test::EventGenerator generator(root_window());
 156   generator.GestureScrollSequence(gfx::Point(20, 10),
 157                                   gfx::Point(20, 400),
 158                                   base::TimeDelta::FromMilliseconds(20),
 159                                   5);
 160   EXPECT_TRUE(wm::IsActiveWindow(second.get()));
 161   EXPECT_EQ(second.get(),
 162             wm_api.GetWindowListProvider()->GetWindowList().back());
 163   EXPECT_TRUE(second->IsVisible());
 164   EXPECT_FALSE(third->IsVisible());
 165
 166   // Performing the same gesture again will switch back to |third|.
 167   generator.GestureScrollSequence(gfx::Point(20, 10),
 168                                   gfx::Point(20, 400),
 169                                   base::TimeDelta::FromMilliseconds(20),
 170                                   5);
 171   EXPECT_TRUE(wm::IsActiveWindow(third.get()));
 172   EXPECT_EQ(third.get(),
 173             wm_api.GetWindowListProvider()->GetWindowList().back());
 174   EXPECT_FALSE(second->IsVisible());
 175   EXPECT_TRUE(third->IsVisible());
 176
 177   // Perform a swipe that doesn't go enough to perform the window switch.
 178   generator.GestureScrollSequence(gfx::Point(20, 10),
 179                                   gfx::Point(20, 90),
 180                                   base::TimeDelta::FromMilliseconds(20),
 181                                   5);
 182   EXPECT_TRUE(wm::IsActiveWindow(third.get()));
 183   EXPECT_EQ(third.get(),
 184             wm_api.GetWindowListProvider()->GetWindowList().back());
 185   EXPECT_FALSE(second->IsVisible());
 186   EXPECT_TRUE(third->IsVisible());
 187 }
 188
 189 TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindowsInSplitViewMode) {
 190   aura::test::TestWindowDelegate delegate;
 191   delegate.set_window_component(HTCAPTION);
 192   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
 193   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
 194   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
 195   scoped_ptr<aura::Window> fourth(CreateWindow(&delegate));
 196
 197   test::WindowManagerImplTestApi wm_api;
 198   aura::client::ParentWindowWithContext(
 199       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 200   aura::client::ParentWindowWithContext(
 201       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 202   aura::client::ParentWindowWithContext(
 203       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 204   aura::client::ParentWindowWithContext(
 205       fourth.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 206
 207   // Test that going into split-view mode with two-finger gesture selects the
 208   // correct windows on left and right splits.
 209   ui::test::EventGenerator generator(root_window());
 210   const gfx::Point start_points[2] = {
 211       gfx::Point(2, 10), gfx::Point(4, 20),
 212   };
 213   const int kEventTimeSepration = 16;
 214   int x_middle = root_window()->bounds().width() / 2;
 215   generator.GestureMultiFingerScroll(
 216       2, start_points, kEventTimeSepration, 1, x_middle, 0);
 217   ASSERT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
 218   EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->left_window());
 219   EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->right_window());
 220
 221   // Swipe the title of the left window. It should switch to |second|.
 222   generator.GestureScrollSequence(gfx::Point(20, 10),
 223                                   gfx::Point(20, 400),
 224                                   base::TimeDelta::FromMilliseconds(20),
 225                                   5);
 226   EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
 227   EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->right_window());
 228   aura::Window::Windows windows =
 229       wm_api.GetWindowListProvider()->GetWindowList();
 230   ASSERT_EQ(4u, windows.size());
 231   EXPECT_EQ(second.get(), windows[3]);
 232   EXPECT_EQ(third.get(), windows[2]);
 233   EXPECT_EQ(fourth.get(), windows[1]);
 234
 235   // Swipe the title of the right window now. It should switch to |third|.
 236   generator.GestureScrollSequence(gfx::Point(x_middle + 20, 10),
 237                                   gfx::Point(x_middle + 20, 400),
 238                                   base::TimeDelta::FromMilliseconds(20),
 239                                   5);
 240   EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
 241   EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window());
 242 }
 243
 244 TEST_F(WindowManagerTest, NewWindowBounds) {
 245   aura::test::TestWindowDelegate delegate;
 246   scoped_ptr<aura::Window> first(CreateWindow(&delegate));
 247
 248   test::WindowManagerImplTestApi wm_api;
 249   aura::client::ParentWindowWithContext(
 250       first.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 251   // The window should have the same size as the container.
 252   const gfx::Size work_area =
 253       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
 254   EXPECT_EQ(work_area.ToString(),
 255             first->bounds().size().ToString());
 256   EXPECT_TRUE(first->bounds().origin().IsOrigin());
 257
 258   // A second window should have the same bounds as the first one.
 259   scoped_ptr<aura::Window> second(CreateWindow(&delegate));
 260   aura::client::ParentWindowWithContext(
 261       second.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 262   EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
 263
 264   // Get into split view.
 265   wm_api.GetSplitViewController()->ActivateSplitMode(NULL, NULL);
 266   const gfx::Rect left_bounds =
 267       wm_api.GetSplitViewController()->left_window()->bounds();
 268   EXPECT_NE(work_area.ToString(),
 269             left_bounds.size().ToString());
 270
 271   scoped_ptr<aura::Window> third(CreateWindow(&delegate));
 272   aura::client::ParentWindowWithContext(
 273       third.get(), ScreenManager::Get()->GetContext(), gfx::Rect());
 274   EXPECT_NE(wm_api.GetSplitViewController()->left_window(), third.get());
 275   EXPECT_EQ(left_bounds.ToString(), third->bounds().ToString());
 276
 277   third->Hide();
 278   EXPECT_EQ(
 279       left_bounds.ToString(),
 280       wm_api.GetSplitViewController()->left_window()->bounds().ToString());
 281 }
 282
 283 TEST_F(WindowManagerTest, SplitModeActivationByShortcut) {
 284   test::WindowManagerImplTestApi wm_api;
 285
 286   aura::test::TestWindowDelegate delegate;
 287   scoped_ptr<aura::Window> w1(CreateTestWindow(&delegate, gfx::Rect()));
 288   w1->Show();
 289
 290   ui::test::EventGenerator generator(root_window());
 291
 292   // Splitview mode needs at least two windows.
 293   generator.PressKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
 294   generator.ReleaseKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
 295   EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
 296
 297   scoped_ptr<aura::Window> w2(CreateTestWindow(&delegate, gfx::Rect()));
 298   w2->Show();
 299
 300   generator.PressKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
 301   generator.ReleaseKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
 302   EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
 303   int width =
 304       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().width();
 305
 306   EXPECT_EQ(width / 2, w1->bounds().width());
 307   EXPECT_EQ(width / 2, w2->bounds().width());
 308
 309   // Toggle back to normal mode.
 310   generator.PressKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
 311   generator.ReleaseKey(ui::VKEY_F6, ui::EF_CONTROL_DOWN);
 312   EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
 313
 314   EXPECT_EQ(width, w1->bounds().width());
 315   EXPECT_EQ(width, w2->bounds().width());
 316 }
 317
 318 }  // namespace athena