ash/shell_unittest.cc

   1 // Copyright (c) 2011 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/ash_switches.h"
   6 #include "ash/shell.h"
   7 #include "ash/shell_window_ids.h"
   8 #include "ash/test/aura_shell_test_base.h"
   9 #include "base/command_line.h"
  10 #include "base/utf_string_conversions.h"
  11 #include "ui/aura/test/aura_test_base.h"
  12 #include "ui/aura/root_window.h"
  13 #include "ui/aura/window.h"
  14 #include "ui/gfx/size.h"
  15 #include "ui/views/widget/widget.h"
  16 #include "ui/views/widget/widget_delegate.h"
  17
  18 namespace ash {
  19
  20 namespace {
  21
  22 views::Widget* CreateTestWindow(const views::Widget::InitParams& params) {
  23   views::Widget* widget = new views::Widget;
  24   widget->Init(params);
  25   return widget;
  26 }
  27
  28 aura::Window* GetDefaultContainer() {
  29   return Shell::GetInstance()->GetContainer(
  30         ash::internal::kShellWindowId_DefaultContainer);
  31 }
  32
  33 aura::Window* GetAlwaysOnTopContainer() {
  34   return Shell::GetInstance()->GetContainer(
  35         ash::internal::kShellWindowId_AlwaysOnTopContainer);
  36 }
  37
  38 void TestCreateWindow(views::Widget::InitParams::Type type,
  39                       bool always_on_top,
  40                       aura::Window* expected_container) {
  41   views::Widget::InitParams widget_params(type);
  42   widget_params.keep_on_top = always_on_top;
  43
  44   views::Widget* widget = CreateTestWindow(widget_params);
  45   widget->Show();
  46
  47   EXPECT_EQ(expected_container, widget->GetNativeWindow()->parent()) <<
  48       "TestCreateWindow: type=" << type << ", always_on_top=" << always_on_top;
  49
  50   widget->Close();
  51 }
  52
  53 class ModalWindow : public views::WidgetDelegateView {
  54  public:
  55   ModalWindow() {}
  56   virtual ~ModalWindow() {}
  57
  58   // Overridden from views::WidgetDelegate:
  59   virtual views::View* GetContentsView() OVERRIDE {
  60     return this;
  61   }
  62   virtual bool CanResize() const OVERRIDE {
  63     return true;
  64   }
  65   virtual string16 GetWindowTitle() const OVERRIDE {
  66     return ASCIIToUTF16("Modal Window");
  67   }
  68   virtual bool IsModal() const OVERRIDE {
  69     return true;
  70   }
  71
  72  private:
  73   DISALLOW_COPY_AND_ASSIGN(ModalWindow);
  74 };
  75
  76 // After base::AutoReset<> but via setter and getter.
  77 class AutoResetUseFullscreenHostWindow {
  78  public:
  79   AutoResetUseFullscreenHostWindow(bool new_value) {
  80     old_value_ = aura::RootWindow::use_fullscreen_host_window();
  81     aura::RootWindow::set_use_fullscreen_host_window(new_value);
  82   }
  83   ~AutoResetUseFullscreenHostWindow() {
  84     aura::RootWindow::set_use_fullscreen_host_window(old_value_);
  85   }
  86  private:
  87   bool old_value_;
  88 };
  89
  90 }  // namespace
  91
  92 class ShellTest : public test::AuraShellTestBase {
  93  public:
  94   ShellTest() {}
  95   virtual ~ShellTest() {}
  96
  97  private:
  98   DISALLOW_COPY_AND_ASSIGN(ShellTest);
  99 };
 100
 101 TEST_F(ShellTest, CreateWindow) {
 102   // Normal window should be created in default container.
 103   TestCreateWindow(views::Widget::InitParams::TYPE_WINDOW,
 104                    false,  // always_on_top
 105                    GetDefaultContainer());
 106   TestCreateWindow(views::Widget::InitParams::TYPE_POPUP,
 107                    false,  // always_on_top
 108                    GetDefaultContainer());
 109
 110   // Always-on-top window and popup are created in always-on-top container.
 111   TestCreateWindow(views::Widget::InitParams::TYPE_WINDOW,
 112                    true,  // always_on_top
 113                    GetAlwaysOnTopContainer());
 114   TestCreateWindow(views::Widget::InitParams::TYPE_POPUP,
 115                    true,  // always_on_top
 116                    GetAlwaysOnTopContainer());
 117 }
 118
 119 TEST_F(ShellTest, ChangeAlwaysOnTop) {
 120   views::Widget::InitParams widget_params(
 121       views::Widget::InitParams::TYPE_WINDOW);
 122
 123   // Creates a normal window
 124   views::Widget* widget = CreateTestWindow(widget_params);
 125   widget->Show();
 126
 127   // It should be in default container.
 128   EXPECT_EQ(GetDefaultContainer(), widget->GetNativeWindow()->parent());
 129
 130   // Flip always-on-top flag.
 131   widget->SetAlwaysOnTop(true);
 132   // And it should in always on top container now.
 133   EXPECT_EQ(GetAlwaysOnTopContainer(), widget->GetNativeWindow()->parent());
 134
 135   // Flip always-on-top flag.
 136   widget->SetAlwaysOnTop(false);
 137   // It should go back to default container.
 138   EXPECT_EQ(GetDefaultContainer(), widget->GetNativeWindow()->parent());
 139
 140   // Set the same always-on-top flag again.
 141   widget->SetAlwaysOnTop(false);
 142   // Should have no effect and we are still in the default container.
 143   EXPECT_EQ(GetDefaultContainer(), widget->GetNativeWindow()->parent());
 144
 145   widget->Close();
 146 }
 147
 148 TEST_F(ShellTest, CreateModalWindow) {
 149   views::Widget::InitParams widget_params(
 150       views::Widget::InitParams::TYPE_WINDOW);
 151
 152   // Create a normal window.
 153   views::Widget* widget = CreateTestWindow(widget_params);
 154   widget->Show();
 155
 156   // It should be in default container.
 157   EXPECT_EQ(GetDefaultContainer(), widget->GetNativeWindow()->parent());
 158
 159   // Create a modal window.
 160   views::Widget* modal_widget = views::Widget::CreateWindowWithParent(
 161       new ModalWindow(), widget->GetNativeView());
 162   modal_widget->Show();
 163
 164   // It should be in modal container.
 165   aura::Window* modal_container = Shell::GetInstance()->GetContainer(
 166       ash::internal::kShellWindowId_ModalContainer);
 167   EXPECT_EQ(modal_container, modal_widget->GetNativeWindow()->parent());
 168
 169   modal_widget->Close();
 170   widget->Close();
 171 }
 172
 173 TEST_F(ShellTest, CreateLockScreenModalWindow) {
 174   views::Widget::InitParams widget_params(
 175       views::Widget::InitParams::TYPE_WINDOW);
 176
 177   // Create a normal window.
 178   views::Widget* widget = CreateTestWindow(widget_params);
 179   widget->Show();
 180
 181   // It should be in default container.
 182   EXPECT_EQ(GetDefaultContainer(), widget->GetNativeWindow()->parent());
 183
 184   // Create a LockScreen window.
 185   views::Widget* lock_widget = CreateTestWindow(widget_params);
 186   ash::Shell::GetInstance()->GetContainer(
 187       ash::internal::kShellWindowId_LockScreenContainer)->
 188       AddChild(lock_widget->GetNativeView());
 189   lock_widget->Show();
 190
 191   // It should be in LockScreen container.
 192   aura::Window* lock_screen = Shell::GetInstance()->GetContainer(
 193       ash::internal::kShellWindowId_LockScreenContainer);
 194   EXPECT_EQ(lock_screen, lock_widget->GetNativeWindow()->parent());
 195
 196   // Create a modal window with a lock window as parent.
 197   views::Widget* lock_modal_widget = views::Widget::CreateWindowWithParent(
 198       new ModalWindow(), lock_widget->GetNativeView());
 199   lock_modal_widget->Show();
 200
 201   // It should be in LockScreen modal container.
 202   aura::Window* lock_modal_container = Shell::GetInstance()->GetContainer(
 203       ash::internal::kShellWindowId_LockModalContainer);
 204   EXPECT_EQ(lock_modal_container,
 205             lock_modal_widget->GetNativeWindow()->parent());
 206
 207   // Create a modal window with a normal window as parent.
 208   views::Widget* modal_widget = views::Widget::CreateWindowWithParent(
 209       new ModalWindow(), widget->GetNativeView());
 210   modal_widget->Show();
 211
 212   // It should be in non-LockScreen modal container.
 213   aura::Window* modal_container = Shell::GetInstance()->GetContainer(
 214       ash::internal::kShellWindowId_ModalContainer);
 215   EXPECT_EQ(modal_container, modal_widget->GetNativeWindow()->parent());
 216
 217   modal_widget->Close();
 218   lock_modal_widget->Close();
 219   lock_widget->Close();
 220   widget->Close();
 221 }
 222
 223 TEST_F(ShellTest, IsScreenLocked) {
 224   views::Widget::InitParams widget_params(
 225       views::Widget::InitParams::TYPE_WINDOW);
 226
 227   // A normal window does not lock the screen.
 228   views::Widget* widget = CreateTestWindow(widget_params);
 229   widget->Show();
 230   EXPECT_FALSE(Shell::GetInstance()->IsScreenLocked());
 231   widget->Hide();
 232   EXPECT_FALSE(Shell::GetInstance()->IsScreenLocked());
 233
 234   // A modal window with a normal window as parent does not locks the screen.
 235   views::Widget* modal_widget = views::Widget::CreateWindowWithParent(
 236       new ModalWindow(), widget->GetNativeView());
 237   modal_widget->Show();
 238   EXPECT_FALSE(Shell::GetInstance()->IsScreenLocked());
 239   modal_widget->Close();
 240   EXPECT_FALSE(Shell::GetInstance()->IsScreenLocked());
 241   widget->Close();
 242
 243   // A lock screen window locks the screen.
 244   views::Widget* lock_widget = CreateTestWindow(widget_params);
 245   ash::Shell::GetInstance()->GetContainer(
 246       ash::internal::kShellWindowId_LockScreenContainer)->
 247       AddChild(lock_widget->GetNativeView());
 248   lock_widget->Show();
 249   EXPECT_TRUE(Shell::GetInstance()->IsScreenLocked());
 250   lock_widget->Hide();
 251   EXPECT_FALSE(Shell::GetInstance()->IsScreenLocked());
 252
 253   // A modal window with a lock window as parent does not lock the screen. The
 254   // screen is locked only when a lock windown is visible.
 255   views::Widget* lock_modal_widget = views::Widget::CreateWindowWithParent(
 256       new ModalWindow(), lock_widget->GetNativeView());
 257   lock_modal_widget->Show();
 258   EXPECT_FALSE(Shell::GetInstance()->IsScreenLocked());
 259   lock_widget->Show();
 260   EXPECT_TRUE(Shell::GetInstance()->IsScreenLocked());
 261   lock_modal_widget->Close();
 262   EXPECT_TRUE(Shell::GetInstance()->IsScreenLocked());
 263   lock_widget->Close();
 264   EXPECT_FALSE(Shell::GetInstance()->IsScreenLocked());
 265 }
 266
 267 TEST_F(ShellTest, DefaultToCompactWindowMode) {
 268   // We only change default window mode with full-screen host windows.
 269   AutoResetUseFullscreenHostWindow use_fullscreen_host_window(true);
 270
 271   // Wide screens use normal window mode.
 272   Shell* shell = Shell::GetInstance();
 273   gfx::Size monitor_size(1440, 900);
 274   CommandLine command_line(CommandLine::NO_PROGRAM);
 275   EXPECT_FALSE(shell->DefaultToCompactWindowMode(monitor_size, &command_line));
 276
 277   // Alex-sized screens need compact mode.
 278   monitor_size.SetSize(1280, 800);
 279   EXPECT_TRUE(shell->DefaultToCompactWindowMode(monitor_size, &command_line));
 280
 281   // ZGB-sized screens need compact mode.
 282   monitor_size.SetSize(1366, 768);
 283   EXPECT_TRUE(shell->DefaultToCompactWindowMode(monitor_size, &command_line));
 284
 285   // Even for a small screen, the user can force normal mode.
 286   monitor_size.SetSize(800, 600);
 287   command_line.AppendSwitchASCII(ash::switches::kAuraWindowMode,
 288                                  ash::switches::kAuraWindowModeNormal);
 289   EXPECT_FALSE(shell->DefaultToCompactWindowMode(monitor_size, &command_line));
 290 }
 291
 292 }  // namespace ash