1 // Copyright (c) 2012 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 "build/build_config.h" 6 #include "chrome/browser/content_settings/host_content_settings_map.h" 7 #include "chrome/browser/fullscreen.h" 8 #include "chrome/browser/profiles/profile.h" 9 #include "chrome/browser/ui/browser.h" 10 #include "chrome/browser/ui/browser_commands.h" 11 #include "chrome/browser/ui/browser_window.h" 12 #include "chrome/browser/ui/fullscreen/fullscreen_controller_test.h" 13 #include "chrome/browser/ui/tabs/tab_strip_model.h" 14 #include "chrome/test/base/interactive_test_utils.h" 15 #include "chrome/test/base/ui_test_utils.h" 16 #include "content/public/browser/render_view_host.h" 17 #include "content/public/browser/render_widget_host_view.h" 18 #include "content/public/browser/web_contents.h" 19 #include "content/public/common/url_constants.h" 20 21 #if defined(OS_MACOSX) 22 #include "base/mac/mac_util.h" 23 #endif 24 25 using url::kAboutBlankURL; 26 using content::WebContents; 27 using ui::PAGE_TRANSITION_TYPED; 28 29 namespace { 30 31 const base::FilePath::CharType* kSimpleFile = FILE_PATH_LITERAL("simple.html"); 32 33 } // namespace 34 35 class FullscreenControllerInteractiveTest 36 : public FullscreenControllerTest { 37 protected: 38 39 // Tests that actually make the browser fullscreen have been flaky when 40 // run sharded, and so are restricted here to interactive ui tests. 41 void ToggleTabFullscreen(bool enter_fullscreen); 42 void ToggleTabFullscreenNoRetries(bool enter_fullscreen); 43 void ToggleBrowserFullscreen(bool enter_fullscreen); 44 45 // IsMouseLocked verifies that the FullscreenController state believes 46 // the mouse is locked. This is possible only for tests that initiate 47 // mouse lock from a renderer process, and uses logic that tests that the 48 // browser has focus. Thus, this can only be used in interactive ui tests 49 // and not on sharded tests. 50 bool IsMouseLocked() { 51 // Verify that IsMouseLocked is consistent between the 52 // Fullscreen Controller and the Render View Host View. 53 EXPECT_TRUE(browser()->IsMouseLocked() == 54 browser()->tab_strip_model()->GetActiveWebContents()-> 55 GetRenderViewHost()->GetView()->IsMouseLocked()); 56 return browser()->IsMouseLocked(); 57 } 58 59 void TestFullscreenMouseLockContentSettings(); 60 61 private: 62 void ToggleTabFullscreen_Internal(bool enter_fullscreen, 63 bool retry_until_success); 64 }; 65 66 void FullscreenControllerInteractiveTest::ToggleTabFullscreen( 67 bool enter_fullscreen) { 68 ToggleTabFullscreen_Internal(enter_fullscreen, true); 69 } 70 71 // |ToggleTabFullscreen| should not need to tolerate the transition failing. 72 // Most fullscreen tests run sharded in fullscreen_controller_browsertest.cc 73 // and some flakiness has occurred when calling |ToggleTabFullscreen|, so that 74 // method has been made robust by retrying if the transition fails. 75 // The root cause of that flakiness should still be tracked down, see 76 // http://crbug.com/133831. In the mean time, this method 77 // allows a fullscreen_controller_interactive_browsertest.cc test to verify 78 // that when running serially there is no flakiness in the transition. 79 void FullscreenControllerInteractiveTest::ToggleTabFullscreenNoRetries( 80 bool enter_fullscreen) { 81 ToggleTabFullscreen_Internal(enter_fullscreen, false); 82 } 83 84 void FullscreenControllerInteractiveTest::ToggleBrowserFullscreen( 85 bool enter_fullscreen) { 86 ASSERT_EQ(browser()->window()->IsFullscreen(), !enter_fullscreen); 87 FullscreenNotificationObserver fullscreen_observer; 88 89 chrome::ToggleFullscreenMode(browser()); 90 91 fullscreen_observer.Wait(); 92 ASSERT_EQ(browser()->window()->IsFullscreen(), enter_fullscreen); 93 ASSERT_EQ(IsFullscreenForBrowser(), enter_fullscreen); 94 } 95 96 // Helper method to be called by multiple tests. 97 // Tests Fullscreen and Mouse Lock with varying content settings ALLOW & BLOCK. 98 void 99 FullscreenControllerInteractiveTest::TestFullscreenMouseLockContentSettings() { 100 GURL url = test_server()->GetURL("simple.html"); 101 AddTabAtIndex(0, url, PAGE_TRANSITION_TYPED); 102 103 // Validate that going fullscreen for a URL defaults to asking permision. 104 ASSERT_FALSE(IsFullscreenPermissionRequested()); 105 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 106 ASSERT_TRUE(IsFullscreenPermissionRequested()); 107 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(false)); 108 109 // Add content setting to ALLOW fullscreen. 110 HostContentSettingsMap* settings_map = 111 browser()->profile()->GetHostContentSettingsMap(); 112 ContentSettingsPattern pattern = 113 ContentSettingsPattern::FromURL(url); 114 settings_map->SetContentSetting( 115 pattern, ContentSettingsPattern::Wildcard(), 116 CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string(), 117 CONTENT_SETTING_ALLOW); 118 119 // Now, fullscreen should not prompt for permission. 120 ASSERT_FALSE(IsFullscreenPermissionRequested()); 121 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 122 ASSERT_FALSE(IsFullscreenPermissionRequested()); 123 124 // Leaving tab in fullscreen, now test mouse lock ALLOW: 125 126 // Validate that mouse lock defaults to asking permision. 127 ASSERT_FALSE(IsMouseLockPermissionRequested()); 128 RequestToLockMouse(true, false); 129 ASSERT_TRUE(IsMouseLockPermissionRequested()); 130 LostMouseLock(); 131 132 // Add content setting to ALLOW mouse lock. 133 settings_map->SetContentSetting( 134 pattern, ContentSettingsPattern::Wildcard(), 135 CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string(), 136 CONTENT_SETTING_ALLOW); 137 138 // Now, mouse lock should not prompt for permission. 139 ASSERT_FALSE(IsMouseLockPermissionRequested()); 140 RequestToLockMouse(true, false); 141 ASSERT_FALSE(IsMouseLockPermissionRequested()); 142 LostMouseLock(); 143 144 // Leaving tab in fullscreen, now test mouse lock BLOCK: 145 146 // Add content setting to BLOCK mouse lock. 147 settings_map->SetContentSetting( 148 pattern, ContentSettingsPattern::Wildcard(), 149 CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string(), 150 CONTENT_SETTING_BLOCK); 151 152 // Now, mouse lock should not be pending. 153 ASSERT_FALSE(IsMouseLockPermissionRequested()); 154 RequestToLockMouse(true, false); 155 ASSERT_FALSE(IsMouseLockPermissionRequested()); 156 } 157 158 void FullscreenControllerInteractiveTest::ToggleTabFullscreen_Internal( 159 bool enter_fullscreen, bool retry_until_success) { 160 WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); 161 do { 162 FullscreenNotificationObserver fullscreen_observer; 163 browser()->ToggleFullscreenModeForTab(tab, enter_fullscreen); 164 fullscreen_observer.Wait(); 165 // Repeat ToggleFullscreenModeForTab until the correct state is entered. 166 // This addresses flakiness on test bots running many fullscreen 167 // tests in parallel. 168 } while (retry_until_success && 169 !IsFullscreenForBrowser() && 170 browser()->window()->IsFullscreen() != enter_fullscreen); 171 ASSERT_EQ(IsWindowFullscreenForTabOrPending(), enter_fullscreen); 172 if (!IsFullscreenForBrowser()) 173 ASSERT_EQ(browser()->window()->IsFullscreen(), enter_fullscreen); 174 } 175 176 // Tests /////////////////////////////////////////////////////////////////////// 177 178 // Tests that while in fullscreen creating a new tab will exit fullscreen. 179 // Test is flaky: http://crbug.com/146006 180 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 181 DISABLED_TestNewTabExitsFullscreen) { 182 ASSERT_TRUE(test_server()->Start()); 183 184 AddTabAtIndex(0, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 185 186 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 187 188 { 189 FullscreenNotificationObserver fullscreen_observer; 190 AddTabAtIndex(1, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 191 fullscreen_observer.Wait(); 192 ASSERT_FALSE(browser()->window()->IsFullscreen()); 193 } 194 } 195 196 // Tests a tab exiting fullscreen will bring the browser out of fullscreen. 197 // Test is flaky: http://crbug.com/146006 198 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 199 DISABLED_TestTabExitsItselfFromFullscreen) { 200 ASSERT_TRUE(test_server()->Start()); 201 202 AddTabAtIndex(0, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 203 204 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 205 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(false)); 206 } 207 208 // Tests entering fullscreen and then requesting mouse lock results in 209 // buttons for the user, and that after confirming the buttons are dismissed. 210 // Test is flaky: http://crbug.com/146006 211 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 212 DISABLED_TestFullscreenBubbleMouseLockState) { 213 ASSERT_TRUE(test_server()->Start()); 214 215 AddTabAtIndex(0, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 216 AddTabAtIndex(1, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 217 218 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 219 220 // Request mouse lock and verify the bubble is waiting for user confirmation. 221 RequestToLockMouse(true, false); 222 ASSERT_TRUE(IsMouseLockPermissionRequested()); 223 224 // Accept mouse lock and verify bubble no longer shows confirmation buttons. 225 AcceptCurrentFullscreenOrMouseLockRequest(); 226 ASSERT_FALSE(IsFullscreenBubbleDisplayingButtons()); 227 } 228 229 // Tests fullscreen and Mouse Lock with varying content settings ALLOW & BLOCK. 230 // http://crbug.com/146006 231 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 232 DISABLED_FullscreenMouseLockContentSettings) { 233 TestFullscreenMouseLockContentSettings(); 234 } 235 236 // Tests fullscreen and Mouse Lock with varying content settings ALLOW & BLOCK, 237 // but with the browser initiated in fullscreen mode first. 238 // Test is flaky: http://crbug.com/103912, http://crbug.com/146006 239 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 240 DISABLED_BrowserFullscreenMouseLockContentSettings) { 241 // Enter browser fullscreen first. 242 ASSERT_NO_FATAL_FAILURE(ToggleBrowserFullscreen(true)); 243 TestFullscreenMouseLockContentSettings(); 244 ASSERT_NO_FATAL_FAILURE(ToggleBrowserFullscreen(false)); 245 } 246 247 // Tests Fullscreen entered in Browser, then Tab mode, then exited via Browser. 248 // Test is flaky: http://crbug.com/146006 249 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 250 DISABLED_BrowserFullscreenExit) { 251 // Enter browser fullscreen. 252 ASSERT_NO_FATAL_FAILURE(ToggleBrowserFullscreen(true)); 253 254 // Enter tab fullscreen. 255 AddTabAtIndex(0, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 256 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 257 258 // Exit browser fullscreen. 259 ASSERT_NO_FATAL_FAILURE(ToggleBrowserFullscreen(false)); 260 ASSERT_FALSE(browser()->window()->IsFullscreen()); 261 } 262 263 // Tests Browser Fullscreen remains active after Tab mode entered and exited. 264 // Test is flaky: http://crbug.com/146006 265 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 266 DISABLED_BrowserFullscreenAfterTabFSExit) { 267 // Enter browser fullscreen. 268 ASSERT_NO_FATAL_FAILURE(ToggleBrowserFullscreen(true)); 269 270 // Enter and then exit tab fullscreen. 271 AddTabAtIndex(0, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 272 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 273 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(false)); 274 275 // Verify browser fullscreen still active. 276 ASSERT_TRUE(IsFullscreenForBrowser()); 277 } 278 279 // Tests fullscreen entered without permision prompt for file:// urls. 280 // Test is flaky: http://crbug.com/146006 281 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 282 DISABLED_FullscreenFileURL) { 283 ui_test_utils::NavigateToURL( 284 browser(), ui_test_utils::GetTestUrl( 285 base::FilePath(base::FilePath::kCurrentDirectory), 286 base::FilePath(kSimpleFile))); 287 288 // Validate that going fullscreen for a file does not ask permision. 289 ASSERT_FALSE(IsFullscreenPermissionRequested()); 290 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 291 ASSERT_FALSE(IsFullscreenPermissionRequested()); 292 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(false)); 293 } 294 295 // Tests fullscreen is exited on page navigation. 296 // Test is flaky: http://crbug.com/146006 297 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 298 DISABLED_TestTabExitsFullscreenOnNavigation) { 299 ASSERT_TRUE(test_server()->Start()); 300 301 ui_test_utils::NavigateToURL(browser(), GURL("about:blank")); 302 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 303 ui_test_utils::NavigateToURL(browser(), GURL("chrome://newtab")); 304 305 ASSERT_FALSE(browser()->window()->IsFullscreen()); 306 } 307 308 // Tests fullscreen is exited when navigating back. 309 // Test is flaky: http://crbug.com/146006 310 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 311 DISABLED_TestTabExitsFullscreenOnGoBack) { 312 ASSERT_TRUE(test_server()->Start()); 313 314 ui_test_utils::NavigateToURL(browser(), GURL("about:blank")); 315 ui_test_utils::NavigateToURL(browser(), GURL("chrome://newtab")); 316 317 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 318 319 GoBack(); 320 321 ASSERT_FALSE(browser()->window()->IsFullscreen()); 322 } 323 324 // Tests fullscreen is not exited on sub frame navigation. 325 // Test is flaky: http://crbug.com/146006 326 IN_PROC_BROWSER_TEST_F( 327 FullscreenControllerInteractiveTest, 328 DISABLED_TestTabDoesntExitFullscreenOnSubFrameNavigation) { 329 ASSERT_TRUE(test_server()->Start()); 330 331 GURL url(ui_test_utils::GetTestUrl(base::FilePath( 332 base::FilePath::kCurrentDirectory), base::FilePath(kSimpleFile))); 333 GURL url_with_fragment(url.spec() + "#fragment"); 334 335 ui_test_utils::NavigateToURL(browser(), url); 336 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 337 ui_test_utils::NavigateToURL(browser(), url_with_fragment); 338 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 339 } 340 341 // Tests tab fullscreen exits, but browser fullscreen remains, on navigation. 342 // Test is flaky: http://crbug.com/146006 343 IN_PROC_BROWSER_TEST_F( 344 FullscreenControllerInteractiveTest, 345 DISABLED_TestFullscreenFromTabWhenAlreadyInBrowserFullscreenWorks) { 346 ASSERT_TRUE(test_server()->Start()); 347 348 ui_test_utils::NavigateToURL(browser(), GURL("about:blank")); 349 ui_test_utils::NavigateToURL(browser(), GURL("chrome://newtab")); 350 351 ASSERT_NO_FATAL_FAILURE(ToggleBrowserFullscreen(true)); 352 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 353 354 GoBack(); 355 356 ASSERT_TRUE(IsFullscreenForBrowser()); 357 ASSERT_FALSE(IsWindowFullscreenForTabOrPending()); 358 } 359 360 #if defined(OS_MACOSX) 361 // http://crbug.com/100467 362 IN_PROC_BROWSER_TEST_F( 363 FullscreenControllerTest, DISABLED_TabEntersPresentationModeFromWindowed) { 364 ASSERT_TRUE(test_server()->Start()); 365 366 AddTabAtIndex(0, GURL(url::kAboutBlankURL), PAGE_TRANSITION_TYPED); 367 368 WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); 369 370 { 371 FullscreenNotificationObserver fullscreen_observer; 372 EXPECT_FALSE(browser()->window()->IsFullscreen()); 373 EXPECT_FALSE(browser()->window()->IsFullscreenWithChrome()); 374 EXPECT_FALSE(browser()->window()->IsFullscreenWithoutChrome()); 375 browser()->ToggleFullscreenModeForTab(tab, true); 376 fullscreen_observer.Wait(); 377 EXPECT_TRUE(browser()->window()->IsFullscreen()); 378 EXPECT_FALSE(browser()->window()->IsFullscreenWithChrome()); 379 EXPECT_TRUE(browser()->window()->IsFullscreenWithoutChrome()); 380 } 381 382 { 383 FullscreenNotificationObserver fullscreen_observer; 384 chrome::ToggleFullscreenMode(browser()); 385 fullscreen_observer.Wait(); 386 EXPECT_FALSE(browser()->window()->IsFullscreen()); 387 EXPECT_FALSE(browser()->window()->IsFullscreenWithChrome()); 388 EXPECT_FALSE(browser()->window()->IsFullscreenWithoutChrome()); 389 } 390 391 if (chrome::mac::SupportsSystemFullscreen()) { 392 // Test that tab fullscreen mode doesn't make presentation mode the default 393 // on Lion. 394 FullscreenNotificationObserver fullscreen_observer; 395 chrome::ToggleFullscreenMode(browser()); 396 fullscreen_observer.Wait(); 397 EXPECT_TRUE(browser()->window()->IsFullscreen()); 398 EXPECT_TRUE(browser()->window()->IsFullscreenWithChrome()); 399 EXPECT_FALSE(browser()->window()->IsFullscreenWithoutChrome()); 400 } 401 } 402 #endif 403 404 // Tests mouse lock can be escaped with ESC key. 405 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, EscapingMouseLock) { 406 ASSERT_TRUE(test_server()->Start()); 407 ui_test_utils::NavigateToURL(browser(), 408 test_server()->GetURL(kFullscreenMouseLockHTML)); 409 410 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 411 412 // Request to lock the mouse. 413 { 414 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 415 browser(), ui::VKEY_1, false, false, false, false, 416 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 417 content::NotificationService::AllSources())); 418 } 419 ASSERT_FALSE(IsFullscreenPermissionRequested()); 420 ASSERT_TRUE(IsMouseLockPermissionRequested()); 421 422 // Escape, no prompts should remain. 423 SendEscapeToFullscreenController(); 424 ASSERT_FALSE(IsFullscreenPermissionRequested()); 425 ASSERT_FALSE(IsMouseLockPermissionRequested()); 426 427 // Request to lock the mouse. 428 { 429 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 430 browser(), ui::VKEY_1, false, false, false, false, 431 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 432 content::NotificationService::AllSources())); 433 } 434 ASSERT_FALSE(IsFullscreenPermissionRequested()); 435 ASSERT_TRUE(IsMouseLockPermissionRequested()); 436 437 // Accept mouse lock, confirm it and that there is no prompt. 438 AcceptCurrentFullscreenOrMouseLockRequest(); 439 ASSERT_TRUE(IsMouseLocked()); 440 ASSERT_FALSE(IsWindowFullscreenForTabOrPending()); 441 ASSERT_FALSE(IsFullscreenPermissionRequested()); 442 ASSERT_FALSE(IsMouseLockPermissionRequested()); 443 444 // Escape, confirm we are out of mouse lock with no prompts. 445 SendEscapeToFullscreenController(); 446 ASSERT_FALSE(IsMouseLocked()); 447 ASSERT_FALSE(IsWindowFullscreenForTabOrPending()); 448 ASSERT_FALSE(IsFullscreenPermissionRequested()); 449 ASSERT_FALSE(IsMouseLockPermissionRequested()); 450 } 451 452 // Tests mouse lock and fullscreen modes can be escaped with ESC key. 453 // Test is flaky: http://crbug.com/146006 454 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 455 DISABLED_EscapingMouseLockAndFullscreen) { 456 ASSERT_TRUE(test_server()->Start()); 457 ui_test_utils::NavigateToURL(browser(), 458 test_server()->GetURL(kFullscreenMouseLockHTML)); 459 460 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 461 462 // Request to lock the mouse and enter fullscreen. 463 { 464 FullscreenNotificationObserver fullscreen_observer; 465 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 466 browser(), ui::VKEY_B, false, true, false, false, 467 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 468 content::NotificationService::AllSources())); 469 fullscreen_observer.Wait(); 470 } 471 ASSERT_TRUE(IsFullscreenPermissionRequested()); 472 ASSERT_TRUE(IsMouseLockPermissionRequested()); 473 474 // Escape, no prompts should remain. 475 { 476 FullscreenNotificationObserver fullscreen_observer; 477 SendEscapeToFullscreenController(); 478 fullscreen_observer.Wait(); 479 } 480 ASSERT_FALSE(IsFullscreenPermissionRequested()); 481 ASSERT_FALSE(IsMouseLockPermissionRequested()); 482 483 // Request to lock the mouse and enter fullscreen. 484 { 485 FullscreenNotificationObserver fullscreen_observer; 486 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 487 browser(), ui::VKEY_B, false, true, false, false, 488 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 489 content::NotificationService::AllSources())); 490 fullscreen_observer.Wait(); 491 } 492 ASSERT_TRUE(IsFullscreenPermissionRequested()); 493 ASSERT_TRUE(IsMouseLockPermissionRequested()); 494 495 // Accept both, confirm mouse lock and fullscreen and no prompts. 496 AcceptCurrentFullscreenOrMouseLockRequest(); 497 ASSERT_TRUE(IsMouseLocked()); 498 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 499 ASSERT_FALSE(IsFullscreenPermissionRequested()); 500 ASSERT_FALSE(IsMouseLockPermissionRequested()); 501 502 // Escape, confirm we are out of mouse lock and fullscreen with no prompts. 503 { 504 FullscreenNotificationObserver fullscreen_observer; 505 SendEscapeToFullscreenController(); 506 fullscreen_observer.Wait(); 507 } 508 ASSERT_FALSE(IsMouseLocked()); 509 ASSERT_FALSE(IsWindowFullscreenForTabOrPending()); 510 ASSERT_FALSE(IsFullscreenPermissionRequested()); 511 ASSERT_FALSE(IsMouseLockPermissionRequested()); 512 } 513 514 // Tests mouse lock then fullscreen. 515 // Test is flaky: http://crbug.com/146006 516 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 517 DISABLED_MouseLockThenFullscreen) { 518 ASSERT_TRUE(test_server()->Start()); 519 ui_test_utils::NavigateToURL(browser(), 520 test_server()->GetURL(kFullscreenMouseLockHTML)); 521 522 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 523 524 // Lock the mouse without a user gesture, expect no response. 525 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 526 browser(), ui::VKEY_D, false, false, false, false, 527 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 528 content::NotificationService::AllSources())); 529 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 530 ASSERT_FALSE(IsMouseLocked()); 531 532 // Lock the mouse with a user gesture. 533 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 534 browser(), ui::VKEY_1, false, false, false, false, 535 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 536 content::NotificationService::AllSources())); 537 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 538 ASSERT_FALSE(IsFullscreenPermissionRequested()); 539 ASSERT_TRUE(IsMouseLockPermissionRequested()); 540 ASSERT_FALSE(IsMouseLocked()); 541 542 // Accept mouse lock. 543 AcceptCurrentFullscreenOrMouseLockRequest(); 544 ASSERT_TRUE(IsMouseLocked()); 545 ASSERT_FALSE(IsFullscreenBubbleDisplayingButtons()); 546 547 // Enter fullscreen mode, mouse lock should be dropped to present buttons. 548 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(true)); 549 ASSERT_TRUE(IsFullscreenPermissionRequested()); 550 ASSERT_FALSE(IsMouseLockPermissionRequested()); 551 ASSERT_FALSE(IsMouseLocked()); 552 553 // Request mouse lock also, expect fullscreen and mouse lock buttons. 554 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 555 browser(), ui::VKEY_1, false, false, false, false, 556 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 557 content::NotificationService::AllSources())); 558 ASSERT_TRUE(IsFullscreenPermissionRequested()); 559 ASSERT_TRUE(IsMouseLockPermissionRequested()); 560 ASSERT_FALSE(IsMouseLocked()); 561 562 // Accept fullscreen and mouse lock. 563 AcceptCurrentFullscreenOrMouseLockRequest(); 564 ASSERT_TRUE(IsMouseLocked()); 565 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 566 ASSERT_FALSE(IsFullscreenBubbleDisplayingButtons()); 567 } 568 569 // Times out sometimes on Linux. http://crbug.com/135115 570 // Mac: http://crbug.com/103912 571 // Windows: Failing flakily on try jobs also. 572 // Tests mouse lock then fullscreen in same request. 573 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 574 DISABLED_MouseLockAndFullscreen) { 575 ASSERT_TRUE(test_server()->Start()); 576 ui_test_utils::NavigateToURL(browser(), 577 test_server()->GetURL(kFullscreenMouseLockHTML)); 578 579 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 580 581 // Request to lock the mouse and enter fullscreen. 582 { 583 FullscreenNotificationObserver fullscreen_observer; 584 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 585 browser(), ui::VKEY_B, false, true, false, false, 586 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 587 content::NotificationService::AllSources())); 588 fullscreen_observer.Wait(); 589 } 590 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 591 ASSERT_TRUE(IsFullscreenPermissionRequested()); 592 ASSERT_TRUE(IsMouseLockPermissionRequested()); 593 ASSERT_FALSE(IsMouseLocked()); 594 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 595 596 // Deny both first, to make sure we can. 597 { 598 FullscreenNotificationObserver fullscreen_observer; 599 DenyCurrentFullscreenOrMouseLockRequest(); 600 fullscreen_observer.Wait(); 601 } 602 ASSERT_FALSE(IsMouseLocked()); 603 ASSERT_FALSE(IsWindowFullscreenForTabOrPending()); 604 ASSERT_FALSE(IsFullscreenPermissionRequested()); 605 606 // Request to lock the mouse and enter fullscreen. 607 { 608 FullscreenNotificationObserver fullscreen_observer; 609 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 610 browser(), ui::VKEY_B, false, true, false, false, 611 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 612 content::NotificationService::AllSources())); 613 fullscreen_observer.Wait(); 614 } 615 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 616 ASSERT_TRUE(IsFullscreenPermissionRequested()); 617 ASSERT_TRUE(IsMouseLockPermissionRequested()); 618 ASSERT_FALSE(IsMouseLocked()); 619 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 620 621 // Accept both, confirm they are enabled and there is no prompt. 622 AcceptCurrentFullscreenOrMouseLockRequest(); 623 ASSERT_TRUE(IsMouseLocked()); 624 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 625 ASSERT_FALSE(IsFullscreenPermissionRequested()); 626 } 627 628 // Tests mouse lock and fullscreen for the privileged fullscreen case (e.g., 629 // embedded flash fullscreen, since the Flash plugin handles user permissions 630 // requests itself). 631 // Test is flaky: http://crbug.com/146006 632 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 633 DISABLED_PrivilegedMouseLockAndFullscreen) { 634 ASSERT_TRUE(test_server()->Start()); 635 ui_test_utils::NavigateToURL(browser(), 636 test_server()->GetURL(kFullscreenMouseLockHTML)); 637 638 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 639 640 SetPrivilegedFullscreen(true); 641 642 // Request to lock the mouse and enter fullscreen. 643 FullscreenNotificationObserver fullscreen_observer; 644 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 645 browser(), ui::VKEY_B, false, true, false, false, 646 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 647 content::NotificationService::AllSources())); 648 fullscreen_observer.Wait(); 649 650 // Confirm they are enabled and there is no prompt. 651 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 652 ASSERT_FALSE(IsFullscreenPermissionRequested()); 653 ASSERT_FALSE(IsMouseLockPermissionRequested()); 654 ASSERT_TRUE(IsMouseLocked()); 655 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 656 } 657 658 // TODO(erg): linux_aura bringup: http://crbug.com/163931 659 // Flaky on Windows, Linux, CrOS: http://crbug.com/159000 660 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS) 661 #define MAYBE_MouseLockSilentAfterTargetUnlock \ 662 DISABLED_MouseLockSilentAfterTargetUnlock 663 #else 664 #define MAYBE_MouseLockSilentAfterTargetUnlock MouseLockSilentAfterTargetUnlock 665 #endif 666 667 // Tests mouse lock can be exited and re-entered by an application silently 668 // with no UI distraction for users. 669 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 670 MAYBE_MouseLockSilentAfterTargetUnlock) { 671 ASSERT_TRUE(test_server()->Start()); 672 ui_test_utils::NavigateToURL(browser(), 673 test_server()->GetURL(kFullscreenMouseLockHTML)); 674 675 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 676 677 // Lock the mouse with a user gesture. 678 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 679 browser(), ui::VKEY_1, false, false, false, false, 680 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 681 content::NotificationService::AllSources())); 682 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 683 ASSERT_TRUE(IsMouseLockPermissionRequested()); 684 ASSERT_FALSE(IsMouseLocked()); 685 686 // Accept mouse lock. 687 AcceptCurrentFullscreenOrMouseLockRequest(); 688 ASSERT_TRUE(IsMouseLocked()); 689 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 690 691 // Unlock the mouse from target, make sure it's unlocked. 692 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 693 browser(), ui::VKEY_U, false, false, false, false, 694 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 695 content::NotificationService::AllSources())); 696 ASSERT_FALSE(IsMouseLocked()); 697 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 698 699 // Lock mouse again, make sure it works with no bubble. 700 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 701 browser(), ui::VKEY_1, false, false, false, false, 702 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 703 content::NotificationService::AllSources())); 704 ASSERT_TRUE(IsMouseLocked()); 705 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 706 707 // Unlock the mouse again by target. 708 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 709 browser(), ui::VKEY_U, false, false, false, false, 710 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 711 content::NotificationService::AllSources())); 712 ASSERT_FALSE(IsMouseLocked()); 713 714 // Lock from target, not user gesture, make sure it works. 715 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 716 browser(), ui::VKEY_D, false, false, false, false, 717 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 718 content::NotificationService::AllSources())); 719 ASSERT_TRUE(IsMouseLocked()); 720 ASSERT_FALSE(IsFullscreenBubbleDisplayed()); 721 722 // Unlock by escape. 723 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 724 browser(), ui::VKEY_ESCAPE, false, false, false, false, 725 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 726 content::NotificationService::AllSources())); 727 ASSERT_FALSE(IsMouseLocked()); 728 729 // Lock the mouse with a user gesture, make sure we see bubble again. 730 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 731 browser(), ui::VKEY_1, false, false, false, false, 732 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 733 content::NotificationService::AllSources())); 734 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 735 ASSERT_TRUE(IsMouseLocked()); 736 } 737 738 #if defined(OS_WIN) || \ 739 (defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_AURA)) 740 // These tests are very flaky on Vista. 741 // http://crbug.com/158762 742 // These are flaky on linux_aura. 743 // http://crbug.com/163931 744 #define MAYBE_TestTabExitsMouseLockOnNavigation \ 745 DISABLED_TestTabExitsMouseLockOnNavigation 746 #define MAYBE_TestTabExitsMouseLockOnGoBack \ 747 DISABLED_TestTabExitsMouseLockOnGoBack 748 #else 749 #define MAYBE_TestTabExitsMouseLockOnNavigation \ 750 TestTabExitsMouseLockOnNavigation 751 #define MAYBE_TestTabExitsMouseLockOnGoBack \ 752 TestTabExitsMouseLockOnGoBack 753 #endif 754 755 // Tests mouse lock is exited on page navigation. 756 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 757 MAYBE_TestTabExitsMouseLockOnNavigation) { 758 ASSERT_TRUE(test_server()->Start()); 759 ui_test_utils::NavigateToURL(browser(), 760 test_server()->GetURL(kFullscreenMouseLockHTML)); 761 762 // Lock the mouse with a user gesture. 763 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 764 browser(), ui::VKEY_1, false, false, false, false, 765 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 766 content::NotificationService::AllSources())); 767 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 768 ASSERT_TRUE(IsMouseLockPermissionRequested()); 769 ASSERT_FALSE(IsMouseLocked()); 770 771 // Accept mouse lock. 772 AcceptCurrentFullscreenOrMouseLockRequest(); 773 ASSERT_TRUE(IsMouseLocked()); 774 775 ui_test_utils::NavigateToURL(browser(), GURL("chrome://newtab")); 776 777 ASSERT_FALSE(IsMouseLocked()); 778 } 779 780 // Tests mouse lock is exited when navigating back. 781 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 782 MAYBE_TestTabExitsMouseLockOnGoBack) { 783 ASSERT_TRUE(test_server()->Start()); 784 785 // Navigate twice to provide a place to go back to. 786 ui_test_utils::NavigateToURL(browser(), GURL("about:blank")); 787 ui_test_utils::NavigateToURL(browser(), 788 test_server()->GetURL(kFullscreenMouseLockHTML)); 789 790 // Lock the mouse with a user gesture. 791 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 792 browser(), ui::VKEY_1, false, false, false, false, 793 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 794 content::NotificationService::AllSources())); 795 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 796 ASSERT_TRUE(IsMouseLockPermissionRequested()); 797 ASSERT_FALSE(IsMouseLocked()); 798 799 // Accept mouse lock. 800 AcceptCurrentFullscreenOrMouseLockRequest(); 801 ASSERT_TRUE(IsMouseLocked()); 802 803 GoBack(); 804 805 ASSERT_FALSE(IsMouseLocked()); 806 } 807 808 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_AURA) 809 // TODO(erg): linux_aura bringup: http://crbug.com/163931 810 #define MAYBE_TestTabDoesntExitMouseLockOnSubFrameNavigation DISABLED_TestTabDoesntExitMouseLockOnSubFrameNavigation 811 #else 812 #define MAYBE_TestTabDoesntExitMouseLockOnSubFrameNavigation TestTabDoesntExitMouseLockOnSubFrameNavigation 813 #endif 814 815 // Tests mouse lock is not exited on sub frame navigation. 816 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 817 MAYBE_TestTabDoesntExitMouseLockOnSubFrameNavigation) { 818 ASSERT_TRUE(test_server()->Start()); 819 820 // Create URLs for test page and test page with #fragment. 821 GURL url(test_server()->GetURL(kFullscreenMouseLockHTML)); 822 GURL url_with_fragment(url.spec() + "#fragment"); 823 824 // Navigate to test page. 825 ui_test_utils::NavigateToURL(browser(), url); 826 827 // Lock the mouse with a user gesture. 828 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 829 browser(), ui::VKEY_1, false, false, false, false, 830 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 831 content::NotificationService::AllSources())); 832 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 833 ASSERT_TRUE(IsMouseLockPermissionRequested()); 834 ASSERT_FALSE(IsMouseLocked()); 835 836 // Accept mouse lock. 837 AcceptCurrentFullscreenOrMouseLockRequest(); 838 ASSERT_TRUE(IsMouseLocked()); 839 840 // Navigate to url with fragment. Mouse lock should persist. 841 ui_test_utils::NavigateToURL(browser(), url_with_fragment); 842 ASSERT_TRUE(IsMouseLocked()); 843 } 844 845 // Tests Mouse Lock and Fullscreen are exited upon reload. 846 // http://crbug.com/137486 847 // mac: http://crbug.com/103912 848 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 849 DISABLED_ReloadExitsMouseLockAndFullscreen) { 850 ASSERT_TRUE(test_server()->Start()); 851 ui_test_utils::NavigateToURL(browser(), 852 test_server()->GetURL(kFullscreenMouseLockHTML)); 853 854 ASSERT_FALSE(IsMouseLockPermissionRequested()); 855 856 // Request mouse lock. 857 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 858 browser(), ui::VKEY_1, false, false, false, false, 859 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 860 content::NotificationService::AllSources())); 861 ASSERT_TRUE(IsMouseLockPermissionRequested()); 862 863 // Reload. Mouse lock request should be cleared. 864 { 865 MouseLockNotificationObserver mouselock_observer; 866 Reload(); 867 mouselock_observer.Wait(); 868 ASSERT_FALSE(IsMouseLockPermissionRequested()); 869 } 870 871 // Request mouse lock. 872 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 873 browser(), ui::VKEY_1, false, false, false, false, 874 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 875 content::NotificationService::AllSources())); 876 ASSERT_TRUE(IsMouseLockPermissionRequested()); 877 878 // Accept mouse lock. 879 AcceptCurrentFullscreenOrMouseLockRequest(); 880 ASSERT_TRUE(IsMouseLocked()); 881 ASSERT_TRUE(IsFullscreenBubbleDisplayed()); 882 883 // Reload. Mouse should be unlocked. 884 { 885 MouseLockNotificationObserver mouselock_observer; 886 Reload(); 887 mouselock_observer.Wait(); 888 ASSERT_FALSE(IsMouseLocked()); 889 } 890 891 // Request to lock the mouse and enter fullscreen. 892 { 893 FullscreenNotificationObserver fullscreen_observer; 894 ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait( 895 browser(), ui::VKEY_B, false, true, false, false, 896 chrome::NOTIFICATION_MOUSE_LOCK_CHANGED, 897 content::NotificationService::AllSources())); 898 fullscreen_observer.Wait(); 899 } 900 901 // We are fullscreen. 902 ASSERT_TRUE(IsWindowFullscreenForTabOrPending()); 903 904 // Reload. Mouse should be unlocked and fullscreen exited. 905 { 906 FullscreenNotificationObserver fullscreen_observer; 907 Reload(); 908 fullscreen_observer.Wait(); 909 ASSERT_FALSE(IsMouseLocked()); 910 ASSERT_FALSE(IsWindowFullscreenForTabOrPending()); 911 } 912 } 913 914 // Tests ToggleFullscreenModeForTab always causes window to change. 915 // Test is flaky: http://crbug.com/146006 916 IN_PROC_BROWSER_TEST_F(FullscreenControllerInteractiveTest, 917 DISABLED_ToggleFullscreenModeForTab) { 918 // Most fullscreen tests run sharded in fullscreen_controller_browsertest.cc 919 // but flakiness required a while loop in 920 // FullscreenControllerTest::ToggleTabFullscreen. This test verifies that 921 // when running serially there is no flakiness. 922 // This test reproduces the same flow as 923 // TestFullscreenMouseLockContentSettings. 924 // http://crbug.com/133831 925 926 GURL url = test_server()->GetURL("simple.html"); 927 AddTabAtIndex(0, url, PAGE_TRANSITION_TYPED); 928 929 // Validate that going fullscreen for a URL defaults to asking permision. 930 ASSERT_FALSE(IsFullscreenPermissionRequested()); 931 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreenNoRetries(true)); 932 ASSERT_TRUE(IsFullscreenPermissionRequested()); 933 ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreenNoRetries(false)); 934 } 935