athena/screen/screen_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 <algorithm>
   6 #include <string>
   7
   8 #include "athena/screen/screen_manager_impl.h"
   9 #include "athena/test/base/athena_test_base.h"
  10 #include "athena/test/base/test_windows.h"
  11 #include "athena/util/container_priorities.h"
  12 #include "ui/aura/test/test_window_delegate.h"
  13 #include "ui/aura/window.h"
  14 #include "ui/aura/window_targeter.h"
  15 #include "ui/events/test/event_generator.h"
  16 #include "ui/wm/core/window_util.h"
  17
  18 using ScreenManagerTest = athena::test::AthenaTestBase;
  19 using AthenaFocusRuleTest = athena::test::AthenaTestBase;
  20
  21 namespace athena {
  22 namespace {
  23
  24 const int kTestZOrderPriority = 10;
  25
  26 aura::Window* Create(const std::string& name, int z_order_priority) {
  27   ScreenManager::ContainerParams params(name, z_order_priority);
  28   return ScreenManager::Get()->CreateContainer(params);
  29 }
  30
  31 aura::Window* CreateWindow(aura::Window* container,
  32                            aura::WindowDelegate* delegate,
  33                            const gfx::Rect& bounds) {
  34   aura::Window* window = new aura::Window(delegate);
  35   window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
  36   window->Init(aura::WINDOW_LAYER_TEXTURED);
  37   container->AddChild(window);
  38   window->Show();
  39   window->SetBounds(bounds);
  40   return window;
  41 }
  42
  43 void CheckZOrder(aura::Window* w1, aura::Window* w2) {
  44   aura::Window* parent = w1->parent();
  45   const aura::Window::Windows& children = parent->children();
  46   aura::Window::Windows::const_iterator begin_iter = children.begin();
  47   aura::Window::Windows::const_iterator end_iter = children.end();
  48
  49   aura::Window::Windows::const_iterator w1_iter =
  50       std::find(begin_iter, end_iter, w1);
  51   aura::Window::Windows::const_iterator w2_iter =
  52       std::find(begin_iter, end_iter, w2);
  53   EXPECT_NE(end_iter, w1_iter);
  54   EXPECT_NE(end_iter, w2_iter);
  55   EXPECT_TRUE(w1_iter < w2_iter);
  56 }
  57
  58 }  // namespace
  59
  60 TEST_F(ScreenManagerTest, CreateContainer) {
  61   size_t num_containers = root_window()->children().size();
  62
  63   aura::Window* container = Create("test", kTestZOrderPriority);
  64   EXPECT_EQ("test", container->name());
  65
  66   const aura::Window::Windows& containers = root_window()->children();
  67   EXPECT_EQ(num_containers + 1, containers.size());
  68   EXPECT_NE(containers.end(),
  69             std::find(containers.begin(), containers.end(), container));
  70 }
  71
  72 TEST_F(ScreenManagerTest, Zorder) {
  73   aura::Window* window_10 = Create("test10", 10);
  74   aura::Window* window_11 = Create("test11", 11);
  75   aura::Window* window_12 = Create("test12", 12);
  76
  77   {
  78     SCOPED_TRACE("Init");
  79     CheckZOrder(window_10, window_11);
  80     CheckZOrder(window_11, window_12);
  81   }
  82   {
  83     SCOPED_TRACE("Delete");
  84     delete window_11;
  85     CheckZOrder(window_10, window_12);
  86   }
  87   {
  88     SCOPED_TRACE("Insert");
  89     window_11 = Create("test11", 11);
  90     CheckZOrder(window_10, window_11);
  91     CheckZOrder(window_11, window_12);
  92   }
  93 }
  94
  95 TEST_F(ScreenManagerTest, NonActivatableContainer) {
  96   ScreenManager::ContainerParams non_activatable(
  97       "non_activatable", kTestZOrderPriority);
  98   non_activatable.can_activate_children = false;
  99   aura::Window* no_activatable_container =
 100       ScreenManager::Get()->CreateContainer(non_activatable);
 101
 102   ScreenManager::ContainerParams activatable(
 103       "activatable", kTestZOrderPriority + 1);
 104   activatable.can_activate_children = true;
 105   aura::Window* activatable_container =
 106       ScreenManager::Get()->CreateContainer(activatable);
 107
 108   scoped_ptr<aura::Window> window(CreateWindow(
 109       no_activatable_container, nullptr, gfx::Rect(0, 0, 100, 100)));
 110   EXPECT_FALSE(wm::CanActivateWindow(window.get()));
 111
 112   activatable_container->AddChild(window.get());
 113   EXPECT_TRUE(wm::CanActivateWindow(window.get()));
 114 }
 115
 116 TEST_F(ScreenManagerTest, BlockInputsShouldNotBlockVirtualKeyboard) {
 117   ScreenManager::ContainerParams block_params("blocking", kTestZOrderPriority);
 118   block_params.can_activate_children = true;
 119   block_params.block_events = true;
 120   aura::Window* block_container =
 121       ScreenManager::Get()->CreateContainer(block_params);
 122
 123   aura::test::EventCountDelegate block_delegate;
 124   scoped_ptr<aura::Window> block_window(CreateWindow(
 125       block_container, &block_delegate, gfx::Rect(0, 0, 100, 100)));
 126   EXPECT_TRUE(wm::CanActivateWindow(block_window.get()));
 127
 128   // Create a normal container appearing over the |block_container|. This is
 129   // essentially the case of virtual keyboard.
 130   ScreenManager::ContainerParams vk_params("virtual keyboard",
 131                                            kTestZOrderPriority + 1);
 132   vk_params.can_activate_children = true;
 133   aura::Window* vk_container = ScreenManager::Get()->CreateContainer(vk_params);
 134
 135   aura::test::EventCountDelegate vk_delegate;
 136   scoped_ptr<aura::Window> vk_window(
 137       CreateWindow(vk_container, &vk_delegate, gfx::Rect(0, 20, 100, 80)));
 138   EXPECT_TRUE(wm::CanActivateWindow(vk_window.get()));
 139
 140   ui::test::EventGenerator event_generator(root_window());
 141   event_generator.MoveMouseTo(10, 25);
 142   event_generator.ClickLeftButton();
 143   EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset());
 144   EXPECT_EQ("1 1", vk_delegate.GetMouseButtonCountsAndReset());
 145 }
 146
 147 TEST_F(ScreenManagerTest, DefaultContainer) {
 148   ScreenManagerImpl* impl =
 149       static_cast<ScreenManagerImpl*>(ScreenManager::Get());
 150   aura::Window* original_default = impl->FindContainerByPriority(CP_DEFAULT);
 151   aura::Window* parent = original_default->parent();
 152   // Temporarily remove the original default container from tree.
 153   parent->RemoveChild(original_default);
 154
 155   ScreenManager::ContainerParams params("new_default", CP_END + 1);
 156   params.default_parent = true;
 157   params.modal_container_priority = CP_END + 2;
 158   aura::Window* new_default = ScreenManager::Get()->CreateContainer(params);
 159   aura::Window* w = test::CreateNormalWindow(nullptr, nullptr).release();
 160   EXPECT_EQ(new_default, w->parent());
 161   delete new_default;
 162
 163   // Add the original back to shutdown properly.
 164   parent->AddChild(original_default);
 165 }
 166
 167 TEST_F(AthenaFocusRuleTest, FocusTravarsalFromSameContainer) {
 168   ScreenManager::ContainerParams params("contaier", kTestZOrderPriority);
 169   params.can_activate_children = true;
 170   scoped_ptr<aura::Window>
 171       container(ScreenManager::Get()->CreateContainer(params));
 172
 173   scoped_ptr<aura::Window> w1(CreateWindow(
 174       container.get(), nullptr, gfx::Rect(0, 0, 100, 100)));
 175   wm::ActivateWindow(w1.get());
 176   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 177
 178   scoped_ptr<aura::Window> w2(CreateWindow(
 179       container.get(), nullptr, gfx::Rect(0, 0, 100, 100)));
 180   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 181
 182   container->RemoveChild(w1.get());
 183   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 184 }
 185
 186 TEST_F(AthenaFocusRuleTest, FocusTravarsalFromOtherContainer) {
 187   ScreenManager::ContainerParams params2("contaier2", kTestZOrderPriority + 1);
 188   params2.can_activate_children = true;
 189   scoped_ptr<aura::Window>
 190       container2(ScreenManager::Get()->CreateContainer(params2));
 191   scoped_ptr<aura::Window> w2(CreateWindow(
 192       container2.get(), nullptr, gfx::Rect(0, 0, 100, 100)));
 193   wm::ActivateWindow(w2.get());
 194   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 195
 196   ScreenManager::ContainerParams params1("contaier1", kTestZOrderPriority);
 197   params1.can_activate_children = true;
 198   scoped_ptr<aura::Window>
 199       container1(ScreenManager::Get()->CreateContainer(params1));
 200   ScreenManager::ContainerParams params3("contaier3", kTestZOrderPriority + 2);
 201   params3.can_activate_children = true;
 202   scoped_ptr<aura::Window>
 203       container3(ScreenManager::Get()->CreateContainer(params3));
 204   scoped_ptr<aura::Window> w1(CreateWindow(
 205       container1.get(), nullptr, gfx::Rect(0, 0, 100, 100)));
 206   scoped_ptr<aura::Window> w3(CreateWindow(
 207       container3.get(), nullptr, gfx::Rect(0, 0, 100, 100)));
 208
 209   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 210
 211   container2->RemoveChild(w2.get());
 212   // Focus moves to a window in the front contaier.
 213   EXPECT_TRUE(wm::IsActiveWindow(w3.get()));
 214
 215   container3->RemoveChild(w3.get());
 216   // Focus moves to a window in the back contaier.
 217   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 218 }
 219
 220 TEST_F(AthenaFocusRuleTest, FocusTravarsalFromEventBlockedContainer) {
 221   ScreenManager::ContainerParams params1("contaier1", kTestZOrderPriority + 1);
 222   params1.can_activate_children = true;
 223   scoped_ptr<aura::Window>
 224       container1(ScreenManager::Get()->CreateContainer(params1));
 225
 226   ScreenManager::ContainerParams params2("contaier2", kTestZOrderPriority + 2);
 227   params2.can_activate_children = true;
 228   params2.block_events = true;
 229   scoped_ptr<aura::Window>
 230       container2(ScreenManager::Get()->CreateContainer(params2));
 231
 232   scoped_ptr<aura::Window> w1(CreateWindow(
 233       container1.get(), nullptr, gfx::Rect(0, 0, 100, 100)));
 234   scoped_ptr<aura::Window> w2(CreateWindow(
 235       container2.get(), nullptr, gfx::Rect(0, 0, 100, 100)));
 236
 237   wm::ActivateWindow(w2.get());
 238   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 239
 240   // Confirm that w1 can't get the focus.
 241   wm::ActivateWindow(w1.get());
 242   EXPECT_FALSE(wm::IsActiveWindow(w1.get()));
 243   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 244
 245   container2->Hide();
 246   w2.reset();
 247   container2.reset();
 248
 249   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 250 }
 251
 252 namespace {
 253
 254 class ScreenManagerTargeterTest
 255     : public athena::test::AthenaTestBase,
 256       public testing::WithParamInterface<bool> {
 257  public:
 258   ScreenManagerTargeterTest()
 259       : targeter_(GetParam() ? nullptr : new aura::WindowTargeter) {}
 260   ~ScreenManagerTargeterTest() override {}
 261
 262  protected:
 263   scoped_ptr<ui::EventTargeter> targeter_;
 264
 265  private:
 266   DISALLOW_COPY_AND_ASSIGN(ScreenManagerTargeterTest);
 267 };
 268
 269 }  // namespace
 270
 271 TEST_P(ScreenManagerTargeterTest, BlockContainer) {
 272   ScreenManager::ContainerParams normal_params(
 273       "normal", kTestZOrderPriority);
 274   normal_params.can_activate_children = true;
 275   aura::Window* normal_container =
 276       ScreenManager::Get()->CreateContainer(normal_params);
 277   normal_container->SetEventTargeter(targeter_.Pass());
 278
 279   aura::test::EventCountDelegate normal_delegate;
 280   scoped_ptr<aura::Window> normal_window(CreateWindow(
 281       normal_container, &normal_delegate, gfx::Rect(0, 0, 100, 100)));
 282
 283   EXPECT_TRUE(wm::CanActivateWindow(normal_window.get()));
 284   wm::ActivateWindow(normal_window.get());
 285   ui::test::EventGenerator event_generator(root_window());
 286   event_generator.MoveMouseTo(0, 0);
 287   event_generator.ClickLeftButton();
 288   EXPECT_EQ("1 1", normal_delegate.GetMouseButtonCountsAndReset());
 289   event_generator.PressKey(ui::VKEY_A, ui::EF_NONE);
 290   event_generator.ReleaseKey(ui::VKEY_A, ui::EF_NONE);
 291   EXPECT_EQ("1 1", normal_delegate.GetKeyCountsAndReset());
 292
 293   ScreenManager::ContainerParams block_params("blocking",
 294                                               kTestZOrderPriority + 1);
 295   block_params.can_activate_children = true;
 296   block_params.block_events = true;
 297   aura::Window* block_container =
 298       ScreenManager::Get()->CreateContainer(block_params);
 299
 300   EXPECT_FALSE(wm::CanActivateWindow(normal_window.get()));
 301
 302   aura::test::EventCountDelegate block_delegate;
 303   scoped_ptr<aura::Window> block_window(CreateWindow(
 304       block_container, &block_delegate, gfx::Rect(10, 10, 100, 100)));
 305   EXPECT_TRUE(wm::CanActivateWindow(block_window.get()));
 306
 307   wm::ActivateWindow(block_window.get());
 308
 309   // (0, 0) is still on normal_window, but the event should not go there
 310   // because blockbing_container prevents it.
 311   event_generator.MoveMouseTo(0, 0);
 312   event_generator.ClickLeftButton();
 313   EXPECT_EQ("0 0", normal_delegate.GetMouseButtonCountsAndReset());
 314   EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset());
 315   event_generator.MoveMouseWheel(0, 10);
 316   // EXPECT_EQ(0, normal_event_counter.num_scroll_events());
 317
 318   event_generator.MoveMouseTo(20, 20);
 319   event_generator.ClickLeftButton();
 320   EXPECT_EQ("1 1", block_delegate.GetMouseButtonCountsAndReset());
 321
 322   event_generator.PressKey(ui::VKEY_A, ui::EF_NONE);
 323   event_generator.ReleaseKey(ui::VKEY_A, ui::EF_NONE);
 324   EXPECT_EQ("0 0", normal_delegate.GetKeyCountsAndReset());
 325   EXPECT_EQ("1 1", block_delegate.GetKeyCountsAndReset());
 326 }
 327
 328 TEST_P(ScreenManagerTargeterTest, BlockAndMouseCapture) {
 329   ScreenManager::ContainerParams normal_params(
 330       "normal", kTestZOrderPriority);
 331   normal_params.can_activate_children = true;
 332   aura::Window* normal_container =
 333       ScreenManager::Get()->CreateContainer(normal_params);
 334   normal_container->SetEventTargeter(targeter_.Pass());
 335
 336   aura::test::EventCountDelegate normal_delegate;
 337   scoped_ptr<aura::Window> normal_window(CreateWindow(
 338       normal_container, &normal_delegate, gfx::Rect(0, 0, 100, 100)));
 339
 340   ui::test::EventGenerator event_generator(root_window());
 341   event_generator.MoveMouseTo(0, 0);
 342   event_generator.PressLeftButton();
 343
 344   // Creating blocking container while mouse pressing.
 345   ScreenManager::ContainerParams block_params("blocking",
 346                                               kTestZOrderPriority + 1);
 347   block_params.can_activate_children = true;
 348   block_params.block_events = true;
 349   aura::Window* block_container =
 350       ScreenManager::Get()->CreateContainer(block_params);
 351
 352   aura::test::EventCountDelegate block_delegate;
 353   scoped_ptr<aura::Window> block_window(CreateWindow(
 354       block_container, &block_delegate, gfx::Rect(10, 10, 100, 100)));
 355
 356   // Release event should be sent to |normal_window| because it captures the
 357   // mouse event.
 358   event_generator.ReleaseLeftButton();
 359   EXPECT_EQ("1 1", normal_delegate.GetMouseButtonCountsAndReset());
 360   EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset());
 361
 362   // After release, further mouse events should not be sent to |normal_window|
 363   // because block_container blocks the input.
 364   event_generator.ClickLeftButton();
 365   EXPECT_EQ("0 0", normal_delegate.GetMouseButtonCountsAndReset());
 366   EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset());
 367 }
 368
 369 INSTANTIATE_TEST_CASE_P(WithOrWithoutTargeter,
 370                         ScreenManagerTargeterTest,
 371                         testing::Values(false, true));
 372
 373 }  // namespace athena