ash/wm/ash_focus_rules_unittest.cc

   1 // Copyright 2015 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/session/session_state_delegate.h"
   6 #include "ash/shell.h"
   7 #include "ash/shell_window_ids.h"
   8 #include "ash/test/ash_test_base.h"
   9 #include "ash/test/ash_test_helper.h"
  10 #include "ash/test/test_session_state_delegate.h"
  11 #include "ash/test/test_shell_delegate.h"
  12 #include "ash/wm/lock_state_controller.h"
  13 #include "ash/wm/window_state.h"
  14 #include "ash/wm/window_util.h"
  15 #include "ui/aura/client/aura_constants.h"
  16 #include "ui/aura/client/window_tree_client.h"
  17 #include "ui/views/view.h"
  18 #include "ui/views/widget/widget.h"
  19
  20 namespace ash {
  21 namespace test {
  22
  23 namespace {
  24
  25 // Defines a |SessionStateDelegate| that is used to create and destroy the
  26 // test lock screen widget.
  27 class LockScreenSessionStateDelegate : public TestSessionStateDelegate {
  28  public:
  29   LockScreenSessionStateDelegate() {}
  30   ~LockScreenSessionStateDelegate() override {}
  31
  32   void LockScreen() override {
  33     TestSessionStateDelegate::LockScreen();
  34     CreateLockScreen();
  35     Shell::GetInstance()->UpdateShelfVisibility();
  36   }
  37
  38   void UnlockScreen() override {
  39     TestSessionStateDelegate::UnlockScreen();
  40     if (lock_screen_widget_.get()) {
  41       lock_screen_widget_->Close();
  42       lock_screen_widget_.reset(nullptr);
  43     }
  44
  45     Shell::GetInstance()->UpdateShelfVisibility();
  46   }
  47
  48  private:
  49   void CreateLockScreen() {
  50     views::View* lock_view = new views::View;
  51     lock_screen_widget_.reset(new views::Widget);
  52     views::Widget::InitParams params(
  53         views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
  54     gfx::Size ps = lock_view->GetPreferredSize();
  55
  56     gfx::Size root_window_size = Shell::GetPrimaryRootWindow()->bounds().size();
  57     params.bounds = gfx::Rect((root_window_size.width() - ps.width()) / 2,
  58                               (root_window_size.height() - ps.height()) / 2,
  59                               ps.width(), ps.height());
  60     params.parent = Shell::GetContainer(Shell::GetPrimaryRootWindow(),
  61                                         kShellWindowId_LockScreenContainer);
  62     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
  63     lock_screen_widget_->Init(params);
  64     lock_screen_widget_->SetContentsView(lock_view);
  65     lock_screen_widget_->Show();
  66     lock_screen_widget_->GetNativeView()->SetName("LockView");
  67     lock_screen_widget_->GetNativeView()->Focus();
  68   }
  69
  70   scoped_ptr<views::Widget> lock_screen_widget_;
  71
  72   DISALLOW_COPY_AND_ASSIGN(LockScreenSessionStateDelegate);
  73 };
  74
  75 ////////////////////////////////////////////////////////////////////////////////
  76
  77 // Defines a |ShellDelegate| that is used to construct our lock screen
  78 // |SessionStateDelegate|.
  79 class LockScreenShellDelegate : public test::TestShellDelegate {
  80  public:
  81   LockScreenShellDelegate() {}
  82   ~LockScreenShellDelegate() override {}
  83
  84   TestSessionStateDelegate* CreateSessionStateDelegate() override {
  85     return new LockScreenSessionStateDelegate();
  86   }
  87
  88  private:
  89   DISALLOW_COPY_AND_ASSIGN(LockScreenShellDelegate);
  90 };
  91
  92 ////////////////////////////////////////////////////////////////////////////////
  93
  94 // Defines a class that will be used to test the correct behavior of
  95 // |AshFocusRules| when locking and unlocking the screen.
  96 class LockScreenAshFocusRulesTest : public AshTestBase {
  97  public:
  98   LockScreenAshFocusRulesTest() {}
  99   ~LockScreenAshFocusRulesTest() override {}
 100
 101   void SetUp() override {
 102     ash_test_helper()->set_test_shell_delegate(new LockScreenShellDelegate);
 103     AshTestBase::SetUp();
 104   }
 105
 106   void TearDown() override { AshTestBase::TearDown(); }
 107
 108   aura::Window* CreateWindowInDefaultContainer() {
 109     return CreateWindowInContainer(kShellWindowId_DefaultContainer);
 110   }
 111
 112   aura::Window* CreateWindowInAlwaysOnTopContainer() {
 113     aura::Window* window =
 114         CreateWindowInContainer(kShellWindowId_AlwaysOnTopContainer);
 115     window->SetProperty(aura::client::kAlwaysOnTopKey, true);
 116     return window;
 117   }
 118
 119   Shell* shell() const { return Shell::GetInstance(); }
 120
 121  private:
 122   aura::Window* CreateWindowInContainer(int container_id) {
 123     aura::Window* root_window = Shell::GetPrimaryRootWindow();
 124     aura::Window* container = Shell::GetContainer(root_window, container_id);
 125     aura::Window* window = new aura::Window(nullptr);
 126     window->set_id(0);
 127     window->SetType(ui::wm::WINDOW_TYPE_NORMAL);
 128     window->Init(ui::LAYER_TEXTURED);
 129     window->Show();
 130
 131     aura::client::ParentWindowWithContext(window, container,
 132                                           gfx::Rect(0, 0, 400, 400));
 133
 134     window->SetProperty(aura::client::kCanMaximizeKey, true);
 135     window->SetProperty(aura::client::kCanMinimizeKey, true);
 136     return window;
 137   }
 138
 139   DISALLOW_COPY_AND_ASSIGN(LockScreenAshFocusRulesTest);
 140 };
 141
 142 }  // namespace
 143
 144 // Verifies focus is returned (after unlocking the screen) to the most recent
 145 // window that had it before locking the screen.
 146 TEST_F(LockScreenAshFocusRulesTest, RegainFocusAfterUnlock) {
 147   scoped_ptr<aura::Window> normal_window(CreateWindowInDefaultContainer());
 148   scoped_ptr<aura::Window> always_on_top_window(
 149       CreateWindowInAlwaysOnTopContainer());
 150
 151   wm::ActivateWindow(always_on_top_window.get());
 152   wm::ActivateWindow(normal_window.get());
 153
 154   EXPECT_TRUE(wm::IsActiveWindow(normal_window.get()));
 155   EXPECT_TRUE(normal_window->IsVisible());
 156   EXPECT_TRUE(always_on_top_window->IsVisible());
 157   EXPECT_TRUE(normal_window->HasFocus());
 158   EXPECT_FALSE(always_on_top_window->HasFocus());
 159
 160   wm::WindowState* normal_window_state =
 161       wm::GetWindowState(normal_window.get());
 162   wm::WindowState* always_on_top_window_state =
 163       wm::GetWindowState(always_on_top_window.get());
 164
 165   EXPECT_TRUE(normal_window_state->CanActivate());
 166   EXPECT_TRUE(always_on_top_window_state->CanActivate());
 167
 168   BlockUserSession(BLOCKED_BY_LOCK_SCREEN);
 169
 170   EXPECT_TRUE(shell()->session_state_delegate()->IsScreenLocked());
 171   EXPECT_FALSE(normal_window->HasFocus());
 172   EXPECT_FALSE(always_on_top_window->HasFocus());
 173   EXPECT_FALSE(normal_window_state->IsMinimized());
 174   EXPECT_FALSE(always_on_top_window_state->IsMinimized());
 175   EXPECT_FALSE(normal_window_state->CanActivate());
 176   EXPECT_FALSE(always_on_top_window_state->CanActivate());
 177
 178   UnblockUserSession();
 179
 180   EXPECT_FALSE(shell()->session_state_delegate()->IsScreenLocked());
 181   EXPECT_FALSE(normal_window_state->IsMinimized());
 182   EXPECT_FALSE(always_on_top_window_state->IsMinimized());
 183   EXPECT_TRUE(normal_window_state->CanActivate());
 184   EXPECT_TRUE(always_on_top_window_state->CanActivate());
 185   EXPECT_FALSE(always_on_top_window->HasFocus());
 186   EXPECT_TRUE(normal_window->HasFocus());
 187 }
 188
 189 }  // namespace test
 190 }  // namespace ash