accelerator_commands_browsertest.cc revision effb81e5f8246d0db0270817048dc992db66e9fb 
1// Copyright 2013 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/accelerators/accelerator_commands.h"
6
7#include "apps/app_window.h"
8#include "apps/ui/native_app_window.h"
9#include "ash/ash_switches.h"
10#include "ash/shell.h"
11#include "ash/wm/window_state.h"
12#include "base/command_line.h"
13#include "chrome/browser/apps/app_browsertest_util.h"
14#include "chrome/browser/ui/browser.h"
15#include "chrome/browser/ui/browser_commands.h"
16#include "chrome/browser/ui/browser_finder.h"
17#include "chrome/browser/ui/browser_window.h"
18#include "chrome/common/chrome_switches.h"
19#include "chrome/test/base/in_process_browser_test.h"
20#include "chrome/test/base/test_switches.h"
21#include "ui/aura/client/aura_constants.h"
22#include "ui/views/widget/widget.h"
23#include "ui/views/widget/widget_delegate.h"
24
25using testing::Combine;
26using testing::Values;
27using testing::WithParamInterface;
28
29namespace {
30
31// WidgetDelegateView which allows the widget to be maximized.
32class MaximizableWidgetDelegate : public views::WidgetDelegateView {
33 public:
34  MaximizableWidgetDelegate() {
35  }
36  virtual ~MaximizableWidgetDelegate() {
37  }
38
39  virtual bool CanMaximize() const OVERRIDE {
40    return true;
41  }
42
43 private:
44  DISALLOW_COPY_AND_ASSIGN(MaximizableWidgetDelegate);
45};
46
47// Returns true if |window_state|'s window is in immersive fullscreen. Infer
48// whether the window is in immersive fullscreen based on whether the shelf is
49// hidden when the window is fullscreen. (This is not quite right because the
50// shelf is hidden if a window is in both immersive fullscreen and tab
51// fullscreen.)
52bool IsInImmersiveFullscreen(ash::wm::WindowState* window_state) {
53  return window_state->IsFullscreen() &&
54      !window_state->hide_shelf_when_fullscreen();
55}
56
57}  // namespace
58
59typedef InProcessBrowserTest AcceleratorCommandsBrowserTest;
60
61// Confirm that toggling window miximized works properly
62IN_PROC_BROWSER_TEST_F(AcceleratorCommandsBrowserTest, ToggleMaximized) {
63#if defined(OS_WIN)
64  // Run the test on Win Ash only.
65  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
66    return;
67#endif
68
69  ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance";
70  ash::wm::WindowState* window_state = ash::wm::GetActiveWindowState();
71  ASSERT_TRUE(window_state);
72
73  // When not in fullscreen, accelerators::ToggleMaximized toggles Maximized.
74  EXPECT_FALSE(window_state->IsMaximized());
75  ash::accelerators::ToggleMaximized();
76  EXPECT_TRUE(window_state->IsMaximized());
77  ash::accelerators::ToggleMaximized();
78  EXPECT_FALSE(window_state->IsMaximized());
79
80  // When in fullscreen accelerators::ToggleMaximized gets out of fullscreen.
81  EXPECT_FALSE(window_state->IsFullscreen());
82  Browser* browser = chrome::FindBrowserWithWindow(window_state->window());
83  ASSERT_TRUE(browser);
84  chrome::ToggleFullscreenMode(browser);
85  EXPECT_TRUE(window_state->IsFullscreen());
86  ash::accelerators::ToggleMaximized();
87  EXPECT_FALSE(window_state->IsFullscreen());
88  EXPECT_FALSE(window_state->IsMaximized());
89  ash::accelerators::ToggleMaximized();
90  EXPECT_FALSE(window_state->IsFullscreen());
91  EXPECT_TRUE(window_state->IsMaximized());
92}
93
94class AcceleratorCommandsFullscreenBrowserTest
95    : public WithParamInterface<ui::WindowShowState>,
96      public InProcessBrowserTest {
97 public:
98  AcceleratorCommandsFullscreenBrowserTest()
99#if defined(OS_CHROMEOS)
100      : put_window_in_immersive_(true),
101#else
102      : put_window_in_immersive_(false),
103#endif
104        initial_show_state_(GetParam()) {
105  }
106  virtual ~AcceleratorCommandsFullscreenBrowserTest() {
107  }
108
109  // Sets |window_state|'s show state to |initial_show_state_|.
110  void SetToInitialShowState(ash::wm::WindowState* window_state) {
111    if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
112      window_state->Maximize();
113    else
114      window_state->Restore();
115  }
116
117  // Returns true if |window_state|'s show state is |initial_show_state_|.
118  bool IsInitialShowState(const ash::wm::WindowState* window_state) const {
119    if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
120      return window_state->IsMaximized();
121    else
122      return window_state->IsNormalStateType();
123  }
124
125  bool put_window_in_immersive() const {
126    return put_window_in_immersive_;
127  }
128
129 private:
130  bool put_window_in_immersive_;
131  ui::WindowShowState initial_show_state_;
132
133  DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsFullscreenBrowserTest);
134};
135
136// Test that toggling window fullscreen works properly.
137IN_PROC_BROWSER_TEST_P(AcceleratorCommandsFullscreenBrowserTest,
138                       ToggleFullscreen) {
139#if defined(OS_WIN)
140  // Run the test on Win Ash only.
141  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
142    return;
143#endif
144
145  ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance";
146
147  // 1) Browser windows.
148  ASSERT_TRUE(browser()->is_type_tabbed());
149  ash::wm::WindowState* window_state =
150      ash::wm::GetWindowState(browser()->window()->GetNativeWindow());
151  ASSERT_TRUE(window_state->IsActive());
152  SetToInitialShowState(window_state);
153  EXPECT_TRUE(IsInitialShowState(window_state));
154
155  ash::accelerators::ToggleFullscreen();
156  EXPECT_TRUE(window_state->IsFullscreen());
157  EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state));
158
159  ash::accelerators::ToggleFullscreen();
160  EXPECT_TRUE(IsInitialShowState(window_state));
161
162  // 2) ToggleFullscreen() should have no effect on windows which cannot be
163  // maximized.
164  window_state->window()->SetProperty(aura::client::kCanMaximizeKey, false);
165  ash::accelerators::ToggleFullscreen();
166  EXPECT_TRUE(IsInitialShowState(window_state));
167
168  // 3) Hosted apps.
169  Browser::CreateParams browser_create_params(Browser::TYPE_POPUP,
170      browser()->profile(), chrome::HOST_DESKTOP_TYPE_ASH);
171  browser_create_params.app_name = "Test";
172
173  Browser* app_host_browser = new Browser(browser_create_params);
174  ASSERT_TRUE(app_host_browser->is_app());
175  AddBlankTabAndShow(app_host_browser);
176  window_state =
177      ash::wm::GetWindowState(app_host_browser->window()->GetNativeWindow());
178  ASSERT_TRUE(window_state->IsActive());
179  SetToInitialShowState(window_state);
180  EXPECT_TRUE(IsInitialShowState(window_state));
181
182  ash::accelerators::ToggleFullscreen();
183  EXPECT_TRUE(window_state->IsFullscreen());
184  EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state));
185
186  ash::accelerators::ToggleFullscreen();
187  EXPECT_TRUE(IsInitialShowState(window_state));
188
189  // 4) Popup browser windows.
190  browser_create_params.app_name = "";
191  Browser* popup_browser = new Browser(browser_create_params);
192  ASSERT_TRUE(popup_browser->is_type_popup());
193  ASSERT_FALSE(popup_browser->is_app());
194  AddBlankTabAndShow(popup_browser);
195  window_state =
196      ash::wm::GetWindowState(popup_browser->window()->GetNativeWindow());
197  ASSERT_TRUE(window_state->IsActive());
198  SetToInitialShowState(window_state);
199  EXPECT_TRUE(IsInitialShowState(window_state));
200
201  ash::accelerators::ToggleFullscreen();
202  EXPECT_TRUE(window_state->IsFullscreen());
203  EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state));
204
205  ash::accelerators::ToggleFullscreen();
206  EXPECT_TRUE(IsInitialShowState(window_state));
207
208  // 5) Miscellaneous windows (e.g. task manager).
209  views::Widget::InitParams params;
210  params.delegate = new MaximizableWidgetDelegate();
211  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
212  scoped_ptr<views::Widget> widget(new views::Widget);
213  widget->Init(params);
214  widget->Show();
215
216  window_state = ash::wm::GetWindowState(widget->GetNativeWindow());
217  ASSERT_TRUE(window_state->IsActive());
218  SetToInitialShowState(window_state);
219  EXPECT_TRUE(IsInitialShowState(window_state));
220
221  ash::accelerators::ToggleFullscreen();
222  EXPECT_TRUE(window_state->IsFullscreen());
223  EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state));
224
225  // TODO(pkotwicz|oshima): Make toggling fullscreen restore the window to its
226  // show state prior to entering fullscreen.
227  ash::accelerators::ToggleFullscreen();
228  EXPECT_FALSE(window_state->IsFullscreen());
229}
230
231INSTANTIATE_TEST_CASE_P(InitiallyRestored,
232                        AcceleratorCommandsFullscreenBrowserTest,
233                        Values(ui::SHOW_STATE_NORMAL));
234INSTANTIATE_TEST_CASE_P(InitiallyMaximized,
235                        AcceleratorCommandsFullscreenBrowserTest,
236                        Values(ui::SHOW_STATE_MAXIMIZED));
237
238class AcceleratorCommandsPlatformAppFullscreenBrowserTest
239    : public WithParamInterface<ui::WindowShowState>,
240      public extensions::PlatformAppBrowserTest {
241 public:
242  AcceleratorCommandsPlatformAppFullscreenBrowserTest()
243#if defined(OS_CHROMEOS)
244      : put_window_in_immersive_(true),
245#else
246      : put_window_in_immersive_(false),
247#endif
248        initial_show_state_(GetParam()) {
249  }
250  virtual ~AcceleratorCommandsPlatformAppFullscreenBrowserTest() {
251  }
252
253  // Sets |app_window|'s show state to |initial_show_state_|.
254  void SetToInitialShowState(apps::AppWindow* app_window) {
255    if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
256      app_window->Maximize();
257    else
258      app_window->Restore();
259  }
260
261  // Returns true if |app_window|'s show state is |initial_show_state_|.
262  bool IsInitialShowState(apps::AppWindow* app_window) const {
263    if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
264      return app_window->GetBaseWindow()->IsMaximized();
265    else
266      return ui::BaseWindow::IsRestored(*app_window->GetBaseWindow());
267  }
268
269  bool put_window_in_immersive() const {
270    return put_window_in_immersive_;
271  }
272
273 private:
274  bool put_window_in_immersive_;
275  ui::WindowShowState initial_show_state_;
276
277  DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsPlatformAppFullscreenBrowserTest);
278};
279
280// Test the behavior of platform apps when ToggleFullscreen() is called.
281IN_PROC_BROWSER_TEST_P(AcceleratorCommandsPlatformAppFullscreenBrowserTest,
282                       ToggleFullscreen) {
283#if defined(OS_WIN)
284  // Run the test on Win Ash only.
285  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
286    return;
287#endif
288
289  ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance";
290  const extensions::Extension* extension = LoadAndLaunchPlatformApp("minimal");
291
292  {
293    // Test that ToggleFullscreen() toggles a platform's app's fullscreen
294    // state and that it additionally puts the app into immersive fullscreen
295    // if put_all_windows_in_immersive() returns true.
296    apps::AppWindow::CreateParams params;
297    params.frame = apps::AppWindow::FRAME_CHROME;
298    apps::AppWindow* app_window = CreateAppWindowFromParams(extension, params);
299    apps::NativeAppWindow* native_app_window = app_window->GetBaseWindow();
300    SetToInitialShowState(app_window);
301    ASSERT_TRUE(app_window->GetBaseWindow()->IsActive());
302    EXPECT_TRUE(IsInitialShowState(app_window));
303
304    ash::accelerators::ToggleFullscreen();
305    EXPECT_TRUE(native_app_window->IsFullscreen());
306    ash::wm::WindowState* window_state =
307        ash::wm::GetWindowState(native_app_window->GetNativeWindow());
308    EXPECT_EQ(put_window_in_immersive(),
309              IsInImmersiveFullscreen(window_state));
310
311    ash::accelerators::ToggleFullscreen();
312    EXPECT_TRUE(IsInitialShowState(app_window));
313
314    CloseAppWindow(app_window);
315  }
316
317  {
318    // Repeat the test, but make sure that frameless platform apps are never put
319    // into immersive fullscreen.
320    apps::AppWindow::CreateParams params;
321    params.frame = apps::AppWindow::FRAME_NONE;
322    apps::AppWindow* app_window = CreateAppWindowFromParams(extension, params);
323    apps::NativeAppWindow* native_app_window = app_window->GetBaseWindow();
324    ASSERT_TRUE(app_window->GetBaseWindow()->IsActive());
325    SetToInitialShowState(app_window);
326    EXPECT_TRUE(IsInitialShowState(app_window));
327
328    ash::accelerators::ToggleFullscreen();
329    EXPECT_TRUE(native_app_window->IsFullscreen());
330    ash::wm::WindowState* window_state =
331        ash::wm::GetWindowState(native_app_window->GetNativeWindow());
332    EXPECT_FALSE(IsInImmersiveFullscreen(window_state));
333
334    ash::accelerators::ToggleFullscreen();
335    EXPECT_TRUE(IsInitialShowState(app_window));
336
337    CloseAppWindow(app_window);
338  }
339}
340
341INSTANTIATE_TEST_CASE_P(InitiallyRestored,
342                        AcceleratorCommandsPlatformAppFullscreenBrowserTest,
343                        Values(ui::SHOW_STATE_NORMAL));
344INSTANTIATE_TEST_CASE_P(InitiallyMaximized,
345                        AcceleratorCommandsPlatformAppFullscreenBrowserTest,
346                        Values(ui::SHOW_STATE_MAXIMIZED));
347