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
25 using testing::Combine;
26 using testing::Values;
27 using testing::WithParamInterface;
28
29 namespace {
30
31 // WidgetDelegateView which allows the widget to be maximized.
32 class MaximizableWidgetDelegate : public views::WidgetDelegateView {
33 public:
MaximizableWidgetDelegate()34 MaximizableWidgetDelegate() {
35 }
~MaximizableWidgetDelegate()36 virtual ~MaximizableWidgetDelegate() {
37 }
38
CanMaximize() const39 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.)
IsInImmersiveFullscreen(ash::wm::WindowState * window_state)52 bool IsInImmersiveFullscreen(ash::wm::WindowState* window_state) {
53 return window_state->IsFullscreen() &&
54 !window_state->hide_shelf_when_fullscreen();
55 }
56
57 } // namespace
58
59 typedef InProcessBrowserTest AcceleratorCommandsBrowserTest;
60
61 // Confirm that toggling window miximized works properly
IN_PROC_BROWSER_TEST_F(AcceleratorCommandsBrowserTest,ToggleMaximized)62 IN_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
94 class AcceleratorCommandsFullscreenBrowserTest
95 : public WithParamInterface<ui::WindowShowState>,
96 public InProcessBrowserTest {
97 public:
AcceleratorCommandsFullscreenBrowserTest()98 AcceleratorCommandsFullscreenBrowserTest()
99 : initial_show_state_(GetParam()) {
100 }
~AcceleratorCommandsFullscreenBrowserTest()101 virtual ~AcceleratorCommandsFullscreenBrowserTest() {
102 }
103
104 // Sets |window_state|'s show state to |initial_show_state_|.
SetToInitialShowState(ash::wm::WindowState * window_state)105 void SetToInitialShowState(ash::wm::WindowState* window_state) {
106 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
107 window_state->Maximize();
108 else
109 window_state->Restore();
110 }
111
112 // Returns true if |window_state|'s show state is |initial_show_state_|.
IsInitialShowState(const ash::wm::WindowState * window_state) const113 bool IsInitialShowState(const ash::wm::WindowState* window_state) const {
114 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
115 return window_state->IsMaximized();
116 else
117 return window_state->IsNormalStateType();
118 }
119
120 private:
121 ui::WindowShowState initial_show_state_;
122
123 DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsFullscreenBrowserTest);
124 };
125
126 // Test that toggling window fullscreen works properly.
IN_PROC_BROWSER_TEST_P(AcceleratorCommandsFullscreenBrowserTest,ToggleFullscreen)127 IN_PROC_BROWSER_TEST_P(AcceleratorCommandsFullscreenBrowserTest,
128 ToggleFullscreen) {
129 #if defined(OS_WIN)
130 // Run the test on Win Ash only.
131 if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
132 return;
133 #endif
134
135 ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance";
136
137 // 1) Browser windows.
138 ASSERT_TRUE(browser()->is_type_tabbed());
139 ash::wm::WindowState* window_state =
140 ash::wm::GetWindowState(browser()->window()->GetNativeWindow());
141 ASSERT_TRUE(window_state->IsActive());
142 SetToInitialShowState(window_state);
143 EXPECT_TRUE(IsInitialShowState(window_state));
144
145 ash::accelerators::ToggleFullscreen();
146 EXPECT_TRUE(window_state->IsFullscreen());
147 EXPECT_TRUE(IsInImmersiveFullscreen(window_state));
148
149 ash::accelerators::ToggleFullscreen();
150 EXPECT_TRUE(IsInitialShowState(window_state));
151
152 // 2) ToggleFullscreen() should have no effect on windows which cannot be
153 // maximized.
154 window_state->window()->SetProperty(aura::client::kCanMaximizeKey, false);
155 ash::accelerators::ToggleFullscreen();
156 EXPECT_TRUE(IsInitialShowState(window_state));
157
158 // 3) Hosted apps.
159 Browser::CreateParams browser_create_params(
160 Browser::CreateParams::CreateForApp("Test",
161 true /* trusted_source */,
162 gfx::Rect(),
163 browser()->profile(),
164 chrome::HOST_DESKTOP_TYPE_ASH));
165
166 Browser* app_host_browser = new Browser(browser_create_params);
167 ASSERT_TRUE(app_host_browser->is_app());
168 AddBlankTabAndShow(app_host_browser);
169 window_state =
170 ash::wm::GetWindowState(app_host_browser->window()->GetNativeWindow());
171 ASSERT_TRUE(window_state->IsActive());
172 SetToInitialShowState(window_state);
173 EXPECT_TRUE(IsInitialShowState(window_state));
174
175 ash::accelerators::ToggleFullscreen();
176 EXPECT_TRUE(window_state->IsFullscreen());
177 EXPECT_TRUE(IsInImmersiveFullscreen(window_state));
178
179 ash::accelerators::ToggleFullscreen();
180 EXPECT_TRUE(IsInitialShowState(window_state));
181
182 // 4) Popup browser windows.
183 browser_create_params = Browser::CreateParams(
184 Browser::TYPE_POPUP, browser()->profile(), chrome::HOST_DESKTOP_TYPE_ASH);
185 Browser* popup_browser = new Browser(browser_create_params);
186 ASSERT_TRUE(popup_browser->is_type_popup());
187 ASSERT_FALSE(popup_browser->is_app());
188 AddBlankTabAndShow(popup_browser);
189 window_state =
190 ash::wm::GetWindowState(popup_browser->window()->GetNativeWindow());
191 ASSERT_TRUE(window_state->IsActive());
192 SetToInitialShowState(window_state);
193 EXPECT_TRUE(IsInitialShowState(window_state));
194
195 ash::accelerators::ToggleFullscreen();
196 EXPECT_TRUE(window_state->IsFullscreen());
197 EXPECT_TRUE(IsInImmersiveFullscreen(window_state));
198
199 ash::accelerators::ToggleFullscreen();
200 EXPECT_TRUE(IsInitialShowState(window_state));
201
202 // 5) Miscellaneous windows (e.g. task manager).
203 views::Widget::InitParams params;
204 params.delegate = new MaximizableWidgetDelegate();
205 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
206 scoped_ptr<views::Widget> widget(new views::Widget);
207 widget->Init(params);
208 widget->Show();
209
210 window_state = ash::wm::GetWindowState(widget->GetNativeWindow());
211 ASSERT_TRUE(window_state->IsActive());
212 SetToInitialShowState(window_state);
213 EXPECT_TRUE(IsInitialShowState(window_state));
214
215 ash::accelerators::ToggleFullscreen();
216 EXPECT_TRUE(window_state->IsFullscreen());
217 EXPECT_TRUE(IsInImmersiveFullscreen(window_state));
218
219 // TODO(pkotwicz|oshima): Make toggling fullscreen restore the window to its
220 // show state prior to entering fullscreen.
221 ash::accelerators::ToggleFullscreen();
222 EXPECT_FALSE(window_state->IsFullscreen());
223 }
224
225 INSTANTIATE_TEST_CASE_P(InitiallyRestored,
226 AcceleratorCommandsFullscreenBrowserTest,
227 Values(ui::SHOW_STATE_NORMAL));
228 INSTANTIATE_TEST_CASE_P(InitiallyMaximized,
229 AcceleratorCommandsFullscreenBrowserTest,
230 Values(ui::SHOW_STATE_MAXIMIZED));
231
232 class AcceleratorCommandsPlatformAppFullscreenBrowserTest
233 : public WithParamInterface<ui::WindowShowState>,
234 public extensions::PlatformAppBrowserTest {
235 public:
AcceleratorCommandsPlatformAppFullscreenBrowserTest()236 AcceleratorCommandsPlatformAppFullscreenBrowserTest()
237 : initial_show_state_(GetParam()) {
238 }
~AcceleratorCommandsPlatformAppFullscreenBrowserTest()239 virtual ~AcceleratorCommandsPlatformAppFullscreenBrowserTest() {
240 }
241
242 // Sets |app_window|'s show state to |initial_show_state_|.
SetToInitialShowState(apps::AppWindow * app_window)243 void SetToInitialShowState(apps::AppWindow* app_window) {
244 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
245 app_window->Maximize();
246 else
247 app_window->Restore();
248 }
249
250 // Returns true if |app_window|'s show state is |initial_show_state_|.
IsInitialShowState(apps::AppWindow * app_window) const251 bool IsInitialShowState(apps::AppWindow* app_window) const {
252 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED)
253 return app_window->GetBaseWindow()->IsMaximized();
254 else
255 return ui::BaseWindow::IsRestored(*app_window->GetBaseWindow());
256 }
257
258 private:
259 ui::WindowShowState initial_show_state_;
260
261 DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsPlatformAppFullscreenBrowserTest);
262 };
263
264 // Test the behavior of platform apps when ToggleFullscreen() is called.
IN_PROC_BROWSER_TEST_P(AcceleratorCommandsPlatformAppFullscreenBrowserTest,ToggleFullscreen)265 IN_PROC_BROWSER_TEST_P(AcceleratorCommandsPlatformAppFullscreenBrowserTest,
266 ToggleFullscreen) {
267 #if defined(OS_WIN)
268 // Run the test on Win Ash only.
269 if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
270 return;
271 #endif
272
273 ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance";
274 const extensions::Extension* extension = LoadAndLaunchPlatformApp("minimal",
275 "Launched");
276
277 {
278 // Test that ToggleFullscreen() toggles a platform's app's fullscreen
279 // state and that it additionally puts the app into immersive fullscreen
280 // if put_all_windows_in_immersive() returns true.
281 apps::AppWindow::CreateParams params;
282 params.frame = apps::AppWindow::FRAME_CHROME;
283 apps::AppWindow* app_window = CreateAppWindowFromParams(extension, params);
284 apps::NativeAppWindow* native_app_window = app_window->GetBaseWindow();
285 SetToInitialShowState(app_window);
286 ASSERT_TRUE(app_window->GetBaseWindow()->IsActive());
287 EXPECT_TRUE(IsInitialShowState(app_window));
288
289 ash::accelerators::ToggleFullscreen();
290 EXPECT_TRUE(native_app_window->IsFullscreen());
291 ash::wm::WindowState* window_state =
292 ash::wm::GetWindowState(native_app_window->GetNativeWindow());
293 EXPECT_TRUE(IsInImmersiveFullscreen(window_state));
294
295 ash::accelerators::ToggleFullscreen();
296 EXPECT_TRUE(IsInitialShowState(app_window));
297
298 CloseAppWindow(app_window);
299 }
300
301 {
302 // Repeat the test, but make sure that frameless platform apps are never put
303 // into immersive fullscreen.
304 apps::AppWindow::CreateParams params;
305 params.frame = apps::AppWindow::FRAME_NONE;
306 apps::AppWindow* app_window = CreateAppWindowFromParams(extension, params);
307 apps::NativeAppWindow* native_app_window = app_window->GetBaseWindow();
308 ASSERT_TRUE(app_window->GetBaseWindow()->IsActive());
309 SetToInitialShowState(app_window);
310 EXPECT_TRUE(IsInitialShowState(app_window));
311
312 ash::accelerators::ToggleFullscreen();
313 EXPECT_TRUE(native_app_window->IsFullscreen());
314 ash::wm::WindowState* window_state =
315 ash::wm::GetWindowState(native_app_window->GetNativeWindow());
316 EXPECT_FALSE(IsInImmersiveFullscreen(window_state));
317
318 ash::accelerators::ToggleFullscreen();
319 EXPECT_TRUE(IsInitialShowState(app_window));
320
321 CloseAppWindow(app_window);
322 }
323 }
324
325 INSTANTIATE_TEST_CASE_P(InitiallyRestored,
326 AcceleratorCommandsPlatformAppFullscreenBrowserTest,
327 Values(ui::SHOW_STATE_NORMAL));
328 INSTANTIATE_TEST_CASE_P(InitiallyMaximized,
329 AcceleratorCommandsPlatformAppFullscreenBrowserTest,
330 Values(ui::SHOW_STATE_MAXIMIZED));
331