OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ash/accelerators/accelerator_commands.h" | 5 #include "ash/accelerators/accelerator_commands.h" |
6 | 6 |
7 #include "apps/app_window.h" | 7 #include "apps/app_window.h" |
8 #include "apps/ui/native_app_window.h" | 8 #include "apps/ui/native_app_window.h" |
9 #include "ash/ash_switches.h" | 9 #include "ash/ash_switches.h" |
10 #include "ash/shell.h" | 10 #include "ash/shell.h" |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 EXPECT_TRUE(window_state->IsFullscreen()); | 85 EXPECT_TRUE(window_state->IsFullscreen()); |
86 ash::accelerators::ToggleMaximized(); | 86 ash::accelerators::ToggleMaximized(); |
87 EXPECT_FALSE(window_state->IsFullscreen()); | 87 EXPECT_FALSE(window_state->IsFullscreen()); |
88 EXPECT_FALSE(window_state->IsMaximized()); | 88 EXPECT_FALSE(window_state->IsMaximized()); |
89 ash::accelerators::ToggleMaximized(); | 89 ash::accelerators::ToggleMaximized(); |
90 EXPECT_FALSE(window_state->IsFullscreen()); | 90 EXPECT_FALSE(window_state->IsFullscreen()); |
91 EXPECT_TRUE(window_state->IsMaximized()); | 91 EXPECT_TRUE(window_state->IsMaximized()); |
92 } | 92 } |
93 | 93 |
94 class AcceleratorCommandsFullscreenBrowserTest | 94 class AcceleratorCommandsFullscreenBrowserTest |
95 : public WithParamInterface<std::tr1::tuple<bool, ui::WindowShowState> >, | 95 : public WithParamInterface<ui::WindowShowState>, |
96 public InProcessBrowserTest { | 96 public InProcessBrowserTest { |
97 public: | 97 public: |
98 AcceleratorCommandsFullscreenBrowserTest() | 98 AcceleratorCommandsFullscreenBrowserTest() |
99 #if defined(OS_CHROMEOS) | 99 #if defined(OS_CHROMEOS) |
100 : put_browser_in_immersive_(true), | 100 : put_window_in_immersive_(true), |
101 put_all_windows_in_immersive_(std::tr1::get<0>(GetParam())), | |
102 #else | 101 #else |
103 : put_browser_in_immersive_(false), | 102 : put_window_in_immersive_(false), |
104 put_all_windows_in_immersive_(false), | |
105 #endif | 103 #endif |
106 initial_show_state_(std::tr1::get<1>(GetParam())) { | 104 initial_show_state_(GetParam()) { |
107 } | 105 } |
108 virtual ~AcceleratorCommandsFullscreenBrowserTest() { | 106 virtual ~AcceleratorCommandsFullscreenBrowserTest() { |
109 } | 107 } |
110 | 108 |
111 // BrowserTestBase override: | |
112 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { | |
113 InProcessBrowserTest::SetUpCommandLine(command_line); | |
114 if (put_all_windows_in_immersive_) { | |
115 CommandLine::ForCurrentProcess()->AppendSwitch( | |
116 ash::switches::kAshEnableImmersiveFullscreenForAllWindows); | |
117 } else { | |
118 CommandLine::ForCurrentProcess()->AppendSwitch( | |
119 ash::switches::kAshEnableImmersiveFullscreenForBrowserOnly); | |
120 } | |
121 } | |
122 | |
123 // Sets |window_state|'s show state to |initial_show_state_|. | 109 // Sets |window_state|'s show state to |initial_show_state_|. |
124 void SetToInitialShowState(ash::wm::WindowState* window_state) { | 110 void SetToInitialShowState(ash::wm::WindowState* window_state) { |
125 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) | 111 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) |
126 window_state->Maximize(); | 112 window_state->Maximize(); |
127 else | 113 else |
128 window_state->Restore(); | 114 window_state->Restore(); |
129 } | 115 } |
130 | 116 |
131 // Returns true if |window_state|'s show state is |initial_show_state_|. | 117 // Returns true if |window_state|'s show state is |initial_show_state_|. |
132 bool IsInitialShowState(const ash::wm::WindowState* window_state) const { | 118 bool IsInitialShowState(const ash::wm::WindowState* window_state) const { |
133 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) | 119 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) |
134 return window_state->IsMaximized(); | 120 return window_state->IsMaximized(); |
135 else | 121 else |
136 return window_state->IsNormalStateType(); | 122 return window_state->IsNormalStateType(); |
137 } | 123 } |
138 | 124 |
139 bool put_browser_in_immersive() const { | 125 bool put_window_in_immersive() const { |
140 return put_browser_in_immersive_; | 126 return put_window_in_immersive_; |
141 } | |
142 | |
143 bool put_all_windows_in_immersive() const { | |
144 return put_all_windows_in_immersive_; | |
145 } | 127 } |
146 | 128 |
147 private: | 129 private: |
148 bool put_browser_in_immersive_; | 130 bool put_window_in_immersive_; |
149 bool put_all_windows_in_immersive_; | |
150 ui::WindowShowState initial_show_state_; | 131 ui::WindowShowState initial_show_state_; |
151 | 132 |
152 DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsFullscreenBrowserTest); | 133 DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsFullscreenBrowserTest); |
153 }; | 134 }; |
154 | 135 |
155 // Test that toggling window fullscreen works properly. | 136 // Test that toggling window fullscreen works properly. |
156 IN_PROC_BROWSER_TEST_P(AcceleratorCommandsFullscreenBrowserTest, | 137 IN_PROC_BROWSER_TEST_P(AcceleratorCommandsFullscreenBrowserTest, |
157 ToggleFullscreen) { | 138 ToggleFullscreen) { |
158 #if defined(OS_WIN) | 139 #if defined(OS_WIN) |
159 // Run the test on Win Ash only. | 140 // Run the test on Win Ash only. |
160 if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests)) | 141 if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests)) |
161 return; | 142 return; |
162 #endif | 143 #endif |
163 | 144 |
164 ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance"; | 145 ASSERT_TRUE(ash::Shell::HasInstance()) << "No Instance"; |
165 | 146 |
166 // 1) Browser windows. | 147 // 1) Browser windows. |
167 ASSERT_TRUE(browser()->is_type_tabbed()); | 148 ASSERT_TRUE(browser()->is_type_tabbed()); |
168 ash::wm::WindowState* window_state = | 149 ash::wm::WindowState* window_state = |
169 ash::wm::GetWindowState(browser()->window()->GetNativeWindow()); | 150 ash::wm::GetWindowState(browser()->window()->GetNativeWindow()); |
170 ASSERT_TRUE(window_state->IsActive()); | 151 ASSERT_TRUE(window_state->IsActive()); |
171 SetToInitialShowState(window_state); | 152 SetToInitialShowState(window_state); |
172 EXPECT_TRUE(IsInitialShowState(window_state)); | 153 EXPECT_TRUE(IsInitialShowState(window_state)); |
173 | 154 |
174 ash::accelerators::ToggleFullscreen(); | 155 ash::accelerators::ToggleFullscreen(); |
175 EXPECT_TRUE(window_state->IsFullscreen()); | 156 EXPECT_TRUE(window_state->IsFullscreen()); |
176 EXPECT_EQ(put_browser_in_immersive(), IsInImmersiveFullscreen(window_state)); | 157 EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state)); |
177 | 158 |
178 ash::accelerators::ToggleFullscreen(); | 159 ash::accelerators::ToggleFullscreen(); |
179 EXPECT_TRUE(IsInitialShowState(window_state)); | 160 EXPECT_TRUE(IsInitialShowState(window_state)); |
180 | 161 |
181 // 2) ToggleFullscreen() should have no effect on windows which cannot be | 162 // 2) ToggleFullscreen() should have no effect on windows which cannot be |
182 // maximized. | 163 // maximized. |
183 window_state->window()->SetProperty(aura::client::kCanMaximizeKey, false); | 164 window_state->window()->SetProperty(aura::client::kCanMaximizeKey, false); |
184 ash::accelerators::ToggleFullscreen(); | 165 ash::accelerators::ToggleFullscreen(); |
185 EXPECT_TRUE(IsInitialShowState(window_state)); | 166 EXPECT_TRUE(IsInitialShowState(window_state)); |
186 | 167 |
187 // 3) Hosted apps. | 168 // 3) Hosted apps. |
188 Browser::CreateParams browser_create_params(Browser::TYPE_POPUP, | 169 Browser::CreateParams browser_create_params(Browser::TYPE_POPUP, |
189 browser()->profile(), chrome::HOST_DESKTOP_TYPE_ASH); | 170 browser()->profile(), chrome::HOST_DESKTOP_TYPE_ASH); |
190 browser_create_params.app_name = "Test"; | 171 browser_create_params.app_name = "Test"; |
191 | 172 |
192 Browser* app_host_browser = new Browser(browser_create_params); | 173 Browser* app_host_browser = new Browser(browser_create_params); |
193 ASSERT_TRUE(app_host_browser->is_app()); | 174 ASSERT_TRUE(app_host_browser->is_app()); |
194 AddBlankTabAndShow(app_host_browser); | 175 AddBlankTabAndShow(app_host_browser); |
195 window_state = | 176 window_state = |
196 ash::wm::GetWindowState(app_host_browser->window()->GetNativeWindow()); | 177 ash::wm::GetWindowState(app_host_browser->window()->GetNativeWindow()); |
197 ASSERT_TRUE(window_state->IsActive()); | 178 ASSERT_TRUE(window_state->IsActive()); |
198 SetToInitialShowState(window_state); | 179 SetToInitialShowState(window_state); |
199 EXPECT_TRUE(IsInitialShowState(window_state)); | 180 EXPECT_TRUE(IsInitialShowState(window_state)); |
200 | 181 |
201 ash::accelerators::ToggleFullscreen(); | 182 ash::accelerators::ToggleFullscreen(); |
202 EXPECT_TRUE(window_state->IsFullscreen()); | 183 EXPECT_TRUE(window_state->IsFullscreen()); |
203 EXPECT_EQ(put_all_windows_in_immersive(), | 184 EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state)); |
204 IsInImmersiveFullscreen(window_state)); | |
205 | 185 |
206 ash::accelerators::ToggleFullscreen(); | 186 ash::accelerators::ToggleFullscreen(); |
207 EXPECT_TRUE(IsInitialShowState(window_state)); | 187 EXPECT_TRUE(IsInitialShowState(window_state)); |
208 | 188 |
209 // 4) Popup browser windows. | 189 // 4) Popup browser windows. |
210 browser_create_params.app_name = ""; | 190 browser_create_params.app_name = ""; |
211 Browser* popup_browser = new Browser(browser_create_params); | 191 Browser* popup_browser = new Browser(browser_create_params); |
212 ASSERT_TRUE(popup_browser->is_type_popup()); | 192 ASSERT_TRUE(popup_browser->is_type_popup()); |
213 ASSERT_FALSE(popup_browser->is_app()); | 193 ASSERT_FALSE(popup_browser->is_app()); |
214 AddBlankTabAndShow(popup_browser); | 194 AddBlankTabAndShow(popup_browser); |
215 window_state = | 195 window_state = |
216 ash::wm::GetWindowState(popup_browser->window()->GetNativeWindow()); | 196 ash::wm::GetWindowState(popup_browser->window()->GetNativeWindow()); |
217 ASSERT_TRUE(window_state->IsActive()); | 197 ASSERT_TRUE(window_state->IsActive()); |
218 SetToInitialShowState(window_state); | 198 SetToInitialShowState(window_state); |
219 EXPECT_TRUE(IsInitialShowState(window_state)); | 199 EXPECT_TRUE(IsInitialShowState(window_state)); |
220 | 200 |
221 ash::accelerators::ToggleFullscreen(); | 201 ash::accelerators::ToggleFullscreen(); |
222 EXPECT_TRUE(window_state->IsFullscreen()); | 202 EXPECT_TRUE(window_state->IsFullscreen()); |
223 EXPECT_EQ(put_all_windows_in_immersive(), | 203 EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state)); |
224 IsInImmersiveFullscreen(window_state)); | |
225 | 204 |
226 ash::accelerators::ToggleFullscreen(); | 205 ash::accelerators::ToggleFullscreen(); |
227 EXPECT_TRUE(IsInitialShowState(window_state)); | 206 EXPECT_TRUE(IsInitialShowState(window_state)); |
228 | 207 |
229 // 5) Miscellaneous windows (e.g. task manager). | 208 // 5) Miscellaneous windows (e.g. task manager). |
230 views::Widget::InitParams params; | 209 views::Widget::InitParams params; |
231 params.delegate = new MaximizableWidgetDelegate(); | 210 params.delegate = new MaximizableWidgetDelegate(); |
232 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; | 211 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; |
233 scoped_ptr<views::Widget> widget(new views::Widget); | 212 scoped_ptr<views::Widget> widget(new views::Widget); |
234 widget->Init(params); | 213 widget->Init(params); |
235 widget->Show(); | 214 widget->Show(); |
236 | 215 |
237 window_state = ash::wm::GetWindowState(widget->GetNativeWindow()); | 216 window_state = ash::wm::GetWindowState(widget->GetNativeWindow()); |
238 ASSERT_TRUE(window_state->IsActive()); | 217 ASSERT_TRUE(window_state->IsActive()); |
239 SetToInitialShowState(window_state); | 218 SetToInitialShowState(window_state); |
240 EXPECT_TRUE(IsInitialShowState(window_state)); | 219 EXPECT_TRUE(IsInitialShowState(window_state)); |
241 | 220 |
242 ash::accelerators::ToggleFullscreen(); | 221 ash::accelerators::ToggleFullscreen(); |
243 EXPECT_TRUE(window_state->IsFullscreen()); | 222 EXPECT_TRUE(window_state->IsFullscreen()); |
244 EXPECT_EQ(put_all_windows_in_immersive(), | 223 EXPECT_EQ(put_window_in_immersive(), IsInImmersiveFullscreen(window_state)); |
245 IsInImmersiveFullscreen(window_state)); | |
246 | 224 |
247 // TODO(pkotwicz|oshima): Make toggling fullscreen restore the window to its | 225 // TODO(pkotwicz|oshima): Make toggling fullscreen restore the window to its |
248 // show state prior to entering fullscreen. | 226 // show state prior to entering fullscreen. |
249 ash::accelerators::ToggleFullscreen(); | 227 ash::accelerators::ToggleFullscreen(); |
250 EXPECT_FALSE(window_state->IsFullscreen()); | 228 EXPECT_FALSE(window_state->IsFullscreen()); |
251 } | 229 } |
252 | 230 |
253 #if defined(OS_CHROMEOS) | |
254 INSTANTIATE_TEST_CASE_P(InitiallyRestored, | 231 INSTANTIATE_TEST_CASE_P(InitiallyRestored, |
255 AcceleratorCommandsFullscreenBrowserTest, | 232 AcceleratorCommandsFullscreenBrowserTest, |
256 Combine(Values(false, true), | 233 Values(ui::SHOW_STATE_NORMAL)); |
257 Values(ui::SHOW_STATE_NORMAL))); | |
258 INSTANTIATE_TEST_CASE_P(InitiallyMaximized, | 234 INSTANTIATE_TEST_CASE_P(InitiallyMaximized, |
259 AcceleratorCommandsFullscreenBrowserTest, | 235 AcceleratorCommandsFullscreenBrowserTest, |
260 Combine(Values(false, true), | 236 Values(ui::SHOW_STATE_MAXIMIZED)); |
261 Values(ui::SHOW_STATE_MAXIMIZED))); | |
262 #else | |
263 // The kAshEnableImmersiveFullscreenForAllWindows flag should have no effect on | |
264 // Windows. Do not run the tests with and without the flag to spare some | |
265 // cycles. | |
266 INSTANTIATE_TEST_CASE_P(InitiallyRestored, | |
267 AcceleratorCommandsFullscreenBrowserTest, | |
268 Combine(Values(false), | |
269 Values(ui::SHOW_STATE_NORMAL))); | |
270 INSTANTIATE_TEST_CASE_P(InitiallyMaximized, | |
271 AcceleratorCommandsFullscreenBrowserTest, | |
272 Combine(Values(false), | |
273 Values(ui::SHOW_STATE_MAXIMIZED))); | |
274 #endif | |
275 | 237 |
276 class AcceleratorCommandsPlatformAppFullscreenBrowserTest | 238 class AcceleratorCommandsPlatformAppFullscreenBrowserTest |
277 : public WithParamInterface<std::tr1::tuple<bool, ui::WindowShowState> >, | 239 : public WithParamInterface<ui::WindowShowState>, |
278 public extensions::PlatformAppBrowserTest { | 240 public extensions::PlatformAppBrowserTest { |
279 public: | 241 public: |
280 AcceleratorCommandsPlatformAppFullscreenBrowserTest() | 242 AcceleratorCommandsPlatformAppFullscreenBrowserTest() |
281 #if defined(OS_CHROMEOS) | 243 #if defined(OS_CHROMEOS) |
282 : put_all_windows_in_immersive_(std::tr1::get<0>(GetParam())), | 244 : put_window_in_immersive_(true), |
283 #else | 245 #else |
284 : put_all_windows_in_immersive_(false), | 246 : put_window_in_immersive_(false), |
285 #endif | 247 #endif |
286 initial_show_state_(std::tr1::get<1>(GetParam())) { | 248 initial_show_state_(GetParam()) { |
287 } | 249 } |
288 virtual ~AcceleratorCommandsPlatformAppFullscreenBrowserTest() { | 250 virtual ~AcceleratorCommandsPlatformAppFullscreenBrowserTest() { |
289 } | 251 } |
290 | 252 |
291 // Sets |app_window|'s show state to |initial_show_state_|. | 253 // Sets |app_window|'s show state to |initial_show_state_|. |
292 void SetToInitialShowState(apps::AppWindow* app_window) { | 254 void SetToInitialShowState(apps::AppWindow* app_window) { |
293 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) | 255 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) |
294 app_window->Maximize(); | 256 app_window->Maximize(); |
295 else | 257 else |
296 app_window->Restore(); | 258 app_window->Restore(); |
297 } | 259 } |
298 | 260 |
299 // Returns true if |app_window|'s show state is |initial_show_state_|. | 261 // Returns true if |app_window|'s show state is |initial_show_state_|. |
300 bool IsInitialShowState(apps::AppWindow* app_window) const { | 262 bool IsInitialShowState(apps::AppWindow* app_window) const { |
301 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) | 263 if (initial_show_state_ == ui::SHOW_STATE_MAXIMIZED) |
302 return app_window->GetBaseWindow()->IsMaximized(); | 264 return app_window->GetBaseWindow()->IsMaximized(); |
303 else | 265 else |
304 return ui::BaseWindow::IsRestored(*app_window->GetBaseWindow()); | 266 return ui::BaseWindow::IsRestored(*app_window->GetBaseWindow()); |
305 } | 267 } |
306 | 268 |
307 // content::BrowserTestBase override: | 269 bool put_window_in_immersive() const { |
308 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { | 270 return put_window_in_immersive_; |
309 if (put_all_windows_in_immersive_) { | |
310 CommandLine::ForCurrentProcess()->AppendSwitch( | |
311 ash::switches::kAshEnableImmersiveFullscreenForAllWindows); | |
312 } else { | |
313 CommandLine::ForCurrentProcess()->AppendSwitch( | |
314 ash::switches::kAshEnableImmersiveFullscreenForBrowserOnly); | |
315 } | |
316 extensions::PlatformAppBrowserTest::SetUpCommandLine(command_line); | |
317 } | |
318 | |
319 bool put_all_windows_in_immersive() const { | |
320 return put_all_windows_in_immersive_; | |
321 } | 271 } |
322 | 272 |
323 private: | 273 private: |
324 bool put_all_windows_in_immersive_; | 274 bool put_window_in_immersive_; |
325 ui::WindowShowState initial_show_state_; | 275 ui::WindowShowState initial_show_state_; |
326 | 276 |
327 DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsPlatformAppFullscreenBrowserTest); | 277 DISALLOW_COPY_AND_ASSIGN(AcceleratorCommandsPlatformAppFullscreenBrowserTest); |
328 }; | 278 }; |
329 | 279 |
330 // Test the behavior of platform apps when ToggleFullscreen() is called. | 280 // Test the behavior of platform apps when ToggleFullscreen() is called. |
331 IN_PROC_BROWSER_TEST_P(AcceleratorCommandsPlatformAppFullscreenBrowserTest, | 281 IN_PROC_BROWSER_TEST_P(AcceleratorCommandsPlatformAppFullscreenBrowserTest, |
332 ToggleFullscreen) { | 282 ToggleFullscreen) { |
333 #if defined(OS_WIN) | 283 #if defined(OS_WIN) |
334 // Run the test on Win Ash only. | 284 // Run the test on Win Ash only. |
(...skipping 13 matching lines...) Expand all Loading... |
348 apps::AppWindow* app_window = CreateAppWindowFromParams(extension, params); | 298 apps::AppWindow* app_window = CreateAppWindowFromParams(extension, params); |
349 apps::NativeAppWindow* native_app_window = app_window->GetBaseWindow(); | 299 apps::NativeAppWindow* native_app_window = app_window->GetBaseWindow(); |
350 SetToInitialShowState(app_window); | 300 SetToInitialShowState(app_window); |
351 ASSERT_TRUE(app_window->GetBaseWindow()->IsActive()); | 301 ASSERT_TRUE(app_window->GetBaseWindow()->IsActive()); |
352 EXPECT_TRUE(IsInitialShowState(app_window)); | 302 EXPECT_TRUE(IsInitialShowState(app_window)); |
353 | 303 |
354 ash::accelerators::ToggleFullscreen(); | 304 ash::accelerators::ToggleFullscreen(); |
355 EXPECT_TRUE(native_app_window->IsFullscreen()); | 305 EXPECT_TRUE(native_app_window->IsFullscreen()); |
356 ash::wm::WindowState* window_state = | 306 ash::wm::WindowState* window_state = |
357 ash::wm::GetWindowState(native_app_window->GetNativeWindow()); | 307 ash::wm::GetWindowState(native_app_window->GetNativeWindow()); |
358 EXPECT_EQ(put_all_windows_in_immersive(), | 308 EXPECT_EQ(put_window_in_immersive(), |
359 IsInImmersiveFullscreen(window_state)); | 309 IsInImmersiveFullscreen(window_state)); |
360 | 310 |
361 ash::accelerators::ToggleFullscreen(); | 311 ash::accelerators::ToggleFullscreen(); |
362 EXPECT_TRUE(IsInitialShowState(app_window)); | 312 EXPECT_TRUE(IsInitialShowState(app_window)); |
363 | 313 |
364 CloseAppWindow(app_window); | 314 CloseAppWindow(app_window); |
365 } | 315 } |
366 | 316 |
367 { | 317 { |
368 // Repeat the test, but make sure that frameless platform apps are never put | 318 // Repeat the test, but make sure that frameless platform apps are never put |
(...skipping 12 matching lines...) Expand all Loading... |
381 ash::wm::GetWindowState(native_app_window->GetNativeWindow()); | 331 ash::wm::GetWindowState(native_app_window->GetNativeWindow()); |
382 EXPECT_FALSE(IsInImmersiveFullscreen(window_state)); | 332 EXPECT_FALSE(IsInImmersiveFullscreen(window_state)); |
383 | 333 |
384 ash::accelerators::ToggleFullscreen(); | 334 ash::accelerators::ToggleFullscreen(); |
385 EXPECT_TRUE(IsInitialShowState(app_window)); | 335 EXPECT_TRUE(IsInitialShowState(app_window)); |
386 | 336 |
387 CloseAppWindow(app_window); | 337 CloseAppWindow(app_window); |
388 } | 338 } |
389 } | 339 } |
390 | 340 |
391 #if defined(OS_CHROMEOS) | |
392 INSTANTIATE_TEST_CASE_P(InitiallyRestored, | 341 INSTANTIATE_TEST_CASE_P(InitiallyRestored, |
393 AcceleratorCommandsPlatformAppFullscreenBrowserTest, | 342 AcceleratorCommandsPlatformAppFullscreenBrowserTest, |
394 Combine(Values(false, true), | 343 Values(ui::SHOW_STATE_NORMAL)); |
395 Values(ui::SHOW_STATE_NORMAL))); | |
396 INSTANTIATE_TEST_CASE_P(InitiallyMaximized, | 344 INSTANTIATE_TEST_CASE_P(InitiallyMaximized, |
397 AcceleratorCommandsPlatformAppFullscreenBrowserTest, | 345 AcceleratorCommandsPlatformAppFullscreenBrowserTest, |
398 Combine(Values(false, true), | 346 Values(ui::SHOW_STATE_MAXIMIZED)); |
399 Values(ui::SHOW_STATE_MAXIMIZED))); | |
400 #else | |
401 // The kAshEnableImmersiveFullscreenForAllWindows flag should have no effect on | |
402 // Windows. Do not run the tests with and without the flag to spare some | |
403 // cycles. | |
404 INSTANTIATE_TEST_CASE_P(InitiallyRestored, | |
405 AcceleratorCommandsPlatformAppFullscreenBrowserTest, | |
406 Combine(Values(false), | |
407 Values(ui::SHOW_STATE_NORMAL))); | |
408 INSTANTIATE_TEST_CASE_P(InitiallyMaximized, | |
409 AcceleratorCommandsPlatformAppFullscreenBrowserTest, | |
410 Combine(Values(false), | |
411 Values(ui::SHOW_STATE_MAXIMIZED))); | |
412 #endif | |
OLD | NEW |