Home | History | Annotate | Download | only in fullscreen 
      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