| #!/usr/bin/env python |
| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import logging |
| import os |
| import re |
| import shutil |
| import time |
| |
| import pyauto_functional # Must be imported before pyauto |
| import pyauto |
| import test_utils |
| from selenium.webdriver.common.action_chains import ActionChains |
| from selenium.common.exceptions import WebDriverException |
| from selenium.webdriver.common.keys import Keys |
| from webdriver_pages import settings |
| |
| |
| class FullscreenMouselockTest(pyauto.PyUITest): |
| """TestCase for Fullscreen and Mouse Lock.""" |
| |
| def setUp(self): |
| pyauto.PyUITest.setUp(self) |
| self._driver = self.NewWebDriver() |
| # Get the hostname pattern (e.g. http://127.0.0.1:57622). |
| self._hostname_pattern = ( |
| re.sub('/files/$', '', self.GetHttpURLForDataPath(''))) |
| |
| def Debug(self): |
| """Test method for experimentation. |
| |
| This method will not run automatically. |
| """ |
| page = settings.ContentSettingsPage.FromNavigation(self._driver) |
| import pdb |
| pdb.set_trace() |
| |
| def ExtraChromeFlags(self): |
| """Ensures Chrome is launched with custom flags. |
| |
| Returns: |
| A list of extra flags to pass to Chrome when it is launched. |
| """ |
| # Extra flag needed by scroll performance tests. |
| return super(FullscreenMouselockTest, |
| self).ExtraChromeFlags() + ['--enable-pointer-lock'] |
| |
| def testFullScreenMouseLockHooks(self): |
| """Verify fullscreen and mouse lock automation hooks work.""" |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| |
| # Starting off we shouldn't be fullscreen |
| self.assertFalse(self.IsFullscreenForBrowser()) |
| self.assertFalse(self.IsFullscreenForTab()) |
| |
| # Go fullscreen |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(self.IsFullscreenForTab)) |
| |
| # Bubble should be up prompting to allow fullscreen |
| self.assertTrue(self.IsFullscreenBubbleDisplayed()) |
| self.assertTrue(self.IsFullscreenBubbleDisplayingButtons()) |
| self.assertTrue(self.IsFullscreenPermissionRequested()) |
| |
| # Accept bubble, it should go away. |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| self.assertTrue(self.WaitUntil( |
| lambda: not self.IsFullscreenBubbleDisplayingButtons())) |
| |
| # Try to lock mouse, it won't lock yet but permision will be requested. |
| self.assertFalse(self.IsMouseLocked()) |
| self._driver.find_element_by_id('lockMouse1').click() |
| self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested)) |
| self.assertFalse(self.IsMouseLocked()) |
| |
| # Deny mouse lock. |
| self.DenyCurrentFullscreenOrMouseLockRequest() |
| self.assertTrue(self.WaitUntil( |
| lambda: not self.IsFullscreenBubbleDisplayingButtons())) |
| self.assertFalse(self.IsMouseLocked()) |
| |
| # Try mouse lock again, and accept it. |
| self._driver.find_element_by_id('lockMouse1').click() |
| self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested)) |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| self.assertTrue(self.WaitUntil(self.IsMouseLocked)) |
| |
| # The following doesn't work - as sending the key to the input field isn't |
| # picked up by the browser. :( Need an alternative way. |
| # |
| # # Ideally we wouldn't target a specific element, we'd just send keys to |
| # # whatever the current keyboard focus was. |
| # keys_target = driver.find_element_by_id('sendKeysTarget') |
| # |
| # # ESC key should exit fullscreen and mouse lock. |
| # |
| # print "# ESC key should exit fullscreen and mouse lock." |
| # keys_target.send_keys(Keys.ESCAPE) |
| # self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForBrowser())) |
| # self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab())) |
| # self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked())) |
| # |
| # # Check we can go browser fullscreen |
| # print "# Check we can go browser fullscreen" |
| # keys_target.send_keys(Keys.F11) |
| # self.assertTrue(self.WaitUntil(self.IsFullscreenForBrowser)) |
| |
| def _LaunchFSAndExpectPrompt(self, button_action='enterFullscreen'): |
| """Helper function to launch fullscreen and expect a prompt. |
| |
| Fullscreen is initiated and a bubble prompt appears asking to allow or |
| cancel from fullscreen mode. The actual fullscreen mode doesn't take place |
| until after approving the prompt. |
| |
| If the helper is not successful then the test will fail. |
| |
| Args: |
| button_action: The button id to click to initiate an action. Default is to |
| click enterFullscreen. |
| """ |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| # Should not be in fullscreen mode during initial launch. |
| self.assertFalse(self.IsFullscreenForBrowser()) |
| self.assertFalse(self.IsFullscreenForTab()) |
| # Go into fullscreen mode. |
| self._driver.find_element_by_id(button_action).click() |
| self.assertTrue(self.WaitUntil(self.IsFullscreenForTab)) |
| # Bubble should display prompting to allow fullscreen. |
| self.assertTrue(self.IsFullscreenPermissionRequested()) |
| |
| def _InitiateBrowserFullscreen(self): |
| """Helper function that initiates browser fullscreen.""" |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| # Should not be in fullscreen mode during initial launch. |
| self.assertFalse(self.IsFullscreenForBrowser()) |
| self.assertFalse(self.IsFullscreenForTab()) |
| # Initiate browser fullscreen. |
| self.ApplyAccelerator(pyauto.IDC_FULLSCREEN) |
| self.assertTrue(self.WaitUntil(self.IsFullscreenForBrowser)) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab())) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked())) |
| |
| def _InitiateTabFullscreen(self): |
| """Helper function that initiates tab fullscreen.""" |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| # Initiate tab fullscreen. |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(self.IsFullscreenForTab)) |
| |
| def _AcceptFullscreenOrMouseLockRequest(self): |
| """Helper function to accept fullscreen or mouse lock request.""" |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| self.assertTrue(self.WaitUntil( |
| lambda: not self.IsFullscreenBubbleDisplayingButtons())) |
| |
| def _EnableFullscreenAndMouseLockMode(self): |
| """Helper function to enable fullscreen and mouse lock mode.""" |
| self._LaunchFSAndExpectPrompt(button_action='enterFullscreenAndLockMouse1') |
| # Allow fullscreen. |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| # The wait is needed due to crbug.com/123396. Should be able to click the |
| # fullscreen and mouselock button and be both accepted in a single action. |
| self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested)) |
| # Allow mouse lock. |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| self.assertTrue(self.WaitUntil(self.IsMouseLocked)) |
| |
| def _EnableMouseLockMode(self, button_action='lockMouse1'): |
| """Helper function to enable mouse lock mode. |
| |
| Args: |
| button_action: The button id to click to initiate an action. Default is to |
| click lockMouse1. |
| """ |
| self._driver.find_element_by_id(button_action).click() |
| self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested)) |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| self.assertTrue(self.IsMouseLocked()) |
| |
| def _EnableAndReturnLockMouseResult(self): |
| """Helper function to enable and return mouse lock result.""" |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| self._driver.find_element_by_id('lockMouse2').click() |
| self.assertTrue( |
| self.WaitUntil(self.IsMouseLockPermissionRequested)) |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| # Waits until lock_result gets 'success' or 'failure'. |
| return self._driver.execute_script('return lock_result') |
| |
| def _ClickAnchorLink(self): |
| """Clicks the anchor link until it's successfully clicked. |
| |
| Clicks on the anchor link and compares the js |clicked_elem_ID| variabled |
| with the anchor id. Returns True if the link is clicked. |
| """ |
| element_id = 'anchor' |
| # Catch WebDriverException: u'Element is not clickable at point (185.5, |
| # 669.5). Instead another element would receive the click. |
| try: |
| self._driver.find_element_by_id(element_id).click() |
| except WebDriverException: |
| return False |
| return self._driver.execute_script('return clicked_elem_ID') == element_id |
| |
| def testPrefsForFullscreenAllowed(self): |
| """Verify prefs when fullscreen is allowed.""" |
| self._LaunchFSAndExpectPrompt() |
| self._AcceptFullscreenOrMouseLockRequest() |
| content_settings = ( |
| self.GetPrefsInfo().Prefs()['profile']['content_settings']) |
| self.assertEqual( |
| {self._hostname_pattern + ',*': {'fullscreen': 1}}, # Allow hostname. |
| content_settings['pattern_pairs'], |
| msg='Saved hostname pattern does not match expected pattern.') |
| |
| def testPrefsForFullscreenExit(self): |
| """Verify prefs is empty when exit fullscreen mode before allowing.""" |
| self._LaunchFSAndExpectPrompt() |
| self._driver.find_element_by_id('exitFullscreen').click() |
| # Verify exit from fullscreen mode. |
| self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab())) |
| content_settings = ( |
| self.GetPrefsInfo().Prefs()['profile']['content_settings']) |
| self.assertEqual( |
| {}, content_settings['pattern_pairs'], |
| msg='Patterns saved when there should be none.') |
| |
| def testPatternsForFSAndML(self): |
| """Verify hostname pattern and behavior for allowed mouse cursor lock. |
| |
| To lock the mouse, the browser needs to be in fullscreen mode. |
| """ |
| self._EnableFullscreenAndMouseLockMode() |
| self._EnableMouseLockMode() |
| expected_pattern = ( |
| {self._hostname_pattern + ',*': {'fullscreen': 1, 'mouselock': 1}}) |
| content_settings = ( |
| self.GetPrefsInfo().Prefs()['profile']['content_settings']) |
| self.assertEqual( |
| expected_pattern, content_settings['pattern_pairs'], |
| msg='Saved hostname and behavior patterns do not match expected.') |
| |
| def testPatternsForAllowMouseLock(self): |
| """Verify hostname pattern and behavior for allowed mouse cursor lock. |
| |
| Enable fullscreen mode and enable mouse lock separately. |
| """ |
| self._LaunchFSAndExpectPrompt() |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| self._EnableMouseLockMode() |
| expected_pattern = ( |
| {self._hostname_pattern + ',*': {'fullscreen': 1, 'mouselock': 1}}) |
| content_settings = ( |
| self.GetPrefsInfo().Prefs()['profile']['content_settings']) |
| self.assertEqual( |
| expected_pattern, content_settings['pattern_pairs'], |
| msg='Saved hostname and behavior patterns do not match expected.') |
| |
| def testNoMouseLockRequest(self): |
| """Verify mouse lock request does not appear. |
| |
| When allowing all sites to disable the mouse cursor, the mouse lock request |
| bubble should not show. The mouse cursor should be automatically disabled |
| when clicking on a disable mouse button. |
| """ |
| # Allow all sites to disable mouse cursor. |
| self.SetPrefs(pyauto.kDefaultContentSettings, {u'mouselock': 1}) |
| self._LaunchFSAndExpectPrompt() |
| # Allow for fullscreen mode. |
| self._AcceptFullscreenOrMouseLockRequest() |
| self._driver.set_script_timeout(2) |
| # Receive callback status (success or failure) from javascript that the |
| # click has registered and the mouse lock status has changed. |
| lock_result = self._driver.execute_async_script( |
| 'lockMouse1(arguments[arguments.length - 1])') |
| self.assertEqual(lock_result, 'success', msg='Mouse lock unsuccessful.') |
| self.assertTrue(self.WaitUntil( |
| lambda: not self.IsMouseLockPermissionRequested())) |
| self.assertTrue(self.IsMouseLocked()) |
| |
| def testUnableToLockMouse(self): |
| """Verify mouse lock is disabled. |
| |
| When not allowing any site to disable the mouse cursor, the mouse lock |
| request bubble should not show and the mouse cursor should not be disabled. |
| """ |
| # Do not allow any site to disable mouse cursor. |
| self.SetPrefs(pyauto.kDefaultContentSettings, {u'mouselock': 2}) |
| self._LaunchFSAndExpectPrompt() |
| # Allow for fullscreen mode. |
| self._AcceptFullscreenOrMouseLockRequest() |
| self._driver.set_script_timeout(2) |
| # Receive callback status (success or failure) from javascript that the |
| # click has registered and the mouse lock status has changed. |
| lock_result = self._driver.execute_async_script( |
| 'lockMouse1(arguments[arguments.length - 1])') |
| self.assertEqual(lock_result, 'failure', msg='Mouse locked unexpectedly.') |
| self.assertTrue(self.WaitUntil( |
| lambda: not self.IsMouseLockPermissionRequested())) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked())) |
| |
| def testEnterTabFSWhileInBrowserFS(self): |
| """Verify able to enter into tab fullscreen while in browser fullscreen.""" |
| self._InitiateBrowserFullscreen() |
| # Initiate tab fullscreen. |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForTab())) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked())) |
| |
| def testMouseLockInBrowserFS(self): |
| """Verify mouse lock in browser fullscreen requires allow prompt.""" |
| self._InitiateBrowserFullscreen() |
| self._driver.set_script_timeout(2) |
| self._driver.execute_script('lockMouse1AndSetLockResult()') |
| # Bubble should display prompting to allow mouselock. |
| self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested)) |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| # Waits until lock_result gets 'success' or 'failure'. |
| lock_result = self._driver.execute_script('return lock_result') |
| self.assertEqual(lock_result, 'success', |
| msg='Mouse was not locked in browser fullscreen.') |
| |
| def testNoMouseLockWhenCancelFS(self): |
| """Verify mouse lock breaks when canceling tab fullscreen. |
| |
| This test uses javascript to initiate exit of tab fullscreen after mouse |
| lock success callback. |
| """ |
| self._LaunchFSAndExpectPrompt() |
| self._driver.set_script_timeout(2) |
| lock_result = self._driver.execute_script('lockMouse1AndSetLockResult()') |
| self.assertTrue( |
| self.WaitUntil(lambda: self.IsMouseLockPermissionRequested())) |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| self.assertTrue(self.WaitUntil(self.IsMouseLocked)) |
| # Waits until lock_result gets 'success' or 'failure'. |
| lock_result = self._driver.execute_script('return lock_result') |
| self.assertEqual( |
| lock_result, 'success', msg='Mouse is not locked.') |
| self._driver.execute_script('document.webkitCancelFullScreen()') |
| self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab()), |
| msg='Tab is still in fullscreen.') |
| self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked()), |
| msg='Mouse is still locked after exiting fullscreen.') |
| |
| def testNoTabFSExitWhenJSExitMouseLock(self): |
| """Verify tab fullscreen does not exit when javascript init mouse lock exit. |
| |
| This test uses javascript to initiate exit of mouse lock after mouse |
| lock success callback. |
| """ |
| self._LaunchFSAndExpectPrompt() |
| self._EnableMouseLockMode() |
| self._driver.execute_script('navigator.webkitPointer.unlock()') |
| self.WaitUntil(lambda: not self.IsMouseLocked()) |
| self.assertTrue(self.IsFullscreenForTab(), msg='Tab fullscreen was lost.') |
| |
| def testMouseLockExitWhenAlertDialogShow(self): |
| """Verify mouse lock breaks when alert dialog appears.""" |
| self._LaunchFSAndExpectPrompt() |
| self._EnableMouseLockMode() |
| # Need to catch the exception here since the alert dialog raises |
| # a WebDriverException due to a modal dialog. |
| from selenium.common.exceptions import WebDriverException |
| try: |
| self._driver.execute_script('alert("A modal dialog")') |
| except WebDriverException: |
| pass |
| |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForTab()), |
| msg='Tab fullscreen was lost.') |
| self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked()), |
| msg='Mouse is still locked') |
| |
| def testMouseLockExitWhenBrowserLoseFocus(self): |
| """Verify mouse lock breaks when browser loses focus. |
| |
| Mouse lock breaks when the focus is placed on another new window. |
| """ |
| self._LaunchFSAndExpectPrompt() |
| self.AcceptCurrentFullscreenOrMouseLockRequest() |
| # Open a new window to shift focus away. |
| self.OpenNewBrowserWindow(True) |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForTab())) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked()), |
| msg='Mouse lock did not break when browser lost focus.') |
| |
| def testMouseLockLostOnReload(self): |
| """Verify mouse lock is lost on page reload.""" |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| self._EnableMouseLockMode() |
| self.ReloadActiveTab() |
| self.assertTrue(self.WaitUntil(lambda: not self.IsMouseLocked()), |
| msg='Mouse lock did not break when page is reloaded.') |
| |
| def testNoMLBubbleWhenTabLoseFocus(self): |
| """Verify mouse lock bubble goes away when tab loses focus.""" |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| self._driver.find_element_by_id('lockMouse1').click() |
| self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested)) |
| self.AppendTab(pyauto.GURL('chrome://newtab')) |
| self.assertTrue(self.WaitUntil( |
| lambda: not self.IsFullscreenBubbleDisplayingButtons()), |
| msg='Mouse lock bubble did not clear when tab lost focus.') |
| |
| def testTabFSExitWhenNavBackToPrevPage(self): |
| """Verify tab fullscreen exit when navigating back to previous page. |
| |
| This test navigates to a new page while in tab fullscreen mode by using |
| GoBack() to navigate to the previous google.html page. |
| """ |
| self.NavigateToURL(self.GetHttpURLForDataPath('google', 'google.html')) |
| self._InitiateTabFullscreen() |
| self.TabGoBack() |
| self.assertFalse( |
| self.IsFullscreenForTab(), |
| msg='Tab fullscreen did not exit when navigating to a new page.') |
| |
| def testTabFSExitWhenNavToNewPage(self): |
| """Verify tab fullscreen exit when navigating to a new website. |
| |
| This test navigates to a new website while in tab fullscreen. |
| """ |
| self._InitiateTabFullscreen() |
| self.NavigateToURL(self.GetHttpURLForDataPath('google', 'google.html')) |
| self.assertFalse( |
| self.IsFullscreenForTab(), |
| msg='Tab fullscreen did not exit when navigating to a new website.') |
| |
| def testTabFSDoesNotExitForAnchorLinks(self): |
| """Verify tab fullscreen does not exit for anchor links. |
| |
| Tab fullscreen should not exit when following a link to the same page such |
| as example.html#anchor. |
| """ |
| self._InitiateTabFullscreen() |
| self.assertTrue(self.WaitUntil(self._ClickAnchorLink)) |
| self.assertTrue( |
| self.WaitUntil(self.IsFullscreenForTab), |
| msg='Tab fullscreen should not exit when clicking on an anchor link.') |
| |
| def testMLExitWhenNavBackToPrevPage(self): |
| """Verify mouse lock exit when navigating back to previous page. |
| |
| This test navigates to a new page while mouse lock is activated by using |
| GoBack() to navigate to the previous google.html page. |
| """ |
| self.NavigateToURL(self.GetHttpURLForDataPath('google', 'google.html')) |
| lock_result = self._EnableAndReturnLockMouseResult() |
| self.assertEqual( |
| lock_result, 'success', msg='Mouse is not locked.') |
| self.TabGoBack() |
| self.assertFalse( |
| self.IsMouseLocked(), |
| msg='Mouse lock did not exit when navigating to the prev page.') |
| |
| def testMLExitWhenNavToNewPage(self): |
| """Verify mouse lock exit when navigating to a new website.""" |
| lock_result = self._EnableAndReturnLockMouseResult() |
| self.assertEqual( |
| lock_result, 'success', msg='Mouse is not locked.') |
| self.NavigateToURL(self.GetHttpURLForDataPath('google', 'google.html')) |
| self.assertFalse( |
| self.IsMouseLocked(), |
| msg='Mouse lock did not exit when navigating to a new website.') |
| |
| def testMLDoesNotExitForAnchorLinks(self): |
| """Verify mouse lock does not exit for anchor links. |
| |
| Mouse lock should not exist when following a link to the same page such as |
| example.html#anchor. |
| """ |
| lock_result = self._EnableAndReturnLockMouseResult() |
| self.assertEqual( |
| lock_result, 'success', msg='Mouse is not locked.') |
| ActionChains(self._driver).move_to_element( |
| self._driver.find_element_by_id('anchor')).click().perform() |
| self.assertTrue(self.WaitUntil(self.IsMouseLocked), |
| msg='Mouse lock broke when clicking on an anchor link.') |
| |
| def ExitTabFSToBrowserFS(self): |
| """Verify exiting tab fullscreen leaves browser in browser fullscreen. |
| |
| This test is semi-automated. |
| |
| The browser initiates browser fullscreen, then initiates tab fullscreen. The |
| test verifies that existing tab fullscreen by simulating ESC key press or |
| clicking the js function to exitFullscreen() will exit the tab fullscreen |
| leaving browser fullscreen intact. |
| """ |
| self._InitiateBrowserFullscreen() |
| # Initiate tab fullscreen. |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForTab())) |
| # Require manual intervention to send ESC key due to crbug.com/123930. |
| # TODO(dyu): Update to a full test once associated bug is fixed. |
| logging.info('Press ESC key to exit tab fullscreen.') |
| time.sleep(5) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab())) |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForBrowser()), |
| msg='Not in browser fullscreen mode.') |
| |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForTab())) |
| # Exit tab fullscreen by clicking button exitFullscreen(). |
| self._driver.find_element_by_id('exitFullscreen').click() |
| self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab())) |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForBrowser()), |
| msg='Not in browser fullscreen mode.') |
| |
| def F11KeyExitsTabAndBrowserFS(self): |
| """Verify existing tab fullscreen exits all fullscreen modes. |
| |
| This test is semi-automated. |
| |
| The browser initiates browser fullscreen, then initiates tab fullscreen. The |
| test verifies that existing tab fullscreen by simulating F11 key press or |
| CMD + SHIFT + F keys on the Mac will exit the tab fullscreen and the |
| browser fullscreen. |
| """ |
| self._InitiateBrowserFullscreen() |
| # Initiate tab fullscreen. |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(lambda: self.IsFullscreenForTab())) |
| # Require manual intervention to send F11 key due to crbug.com/123930. |
| # TODO(dyu): Update to a full test once associated bug is fixed. |
| logging.info('Press F11 key to exit tab fullscreen.') |
| time.sleep(5) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForTab())) |
| self.assertTrue(self.WaitUntil(lambda: not self.IsFullscreenForBrowser()), |
| msg='Browser is in fullscreen mode.') |
| |
| def SearchForTextOutsideOfContainer(self): |
| """Verify text outside of container is not visible when fullscreen. |
| |
| This test is semi-automated. |
| |
| Verify this test manually until there is a way to find text on screen |
| without using FindInPage(). |
| |
| The text that is outside of the fullscreen container should only be visible |
| when fullscreen is off. The text should not be visible while in fullscreen |
| mode. |
| """ |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| # Should not be in fullscreen mode during initial launch. |
| self.assertFalse(self.IsFullscreenForBrowser()) |
| self.assertFalse(self.IsFullscreenForTab()) |
| self.assertTrue( |
| self.WaitUntil(lambda: self.FindInPage( |
| 'This text is outside of the container')['match_count'], |
| expect_retval=1)) |
| # Go into fullscreen mode. |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(self.IsFullscreenForTab)) |
| time.sleep(5) |
| # TODO(dyu): find a way to verify on screen text instead of using |
| # FindInPage() which searches for text in the HTML. |
| |
| def SameMouseLockMovement(self): |
| """Verify the correct feel of mouse movement data when mouse is locked. |
| |
| This test is semi-automated. |
| |
| This test loads the same web page in two different tabs while in mouse lock |
| mode. Each tab loads the web page from a different URL (e.g. by loading it |
| from a localhost server and a file url). The test verifies |
| that the mouse lock movements work the same in both |
| tabs. |
| """ |
| url1 = self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html') |
| url2 = self.GetFileURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html') |
| tab2 = 'f1-4' |
| self.NavigateToURL(url1) |
| self.RunCommand(pyauto.IDC_NEW_TAB) # Open new tab. |
| self.NavigateToURL(url2, 0, 1) |
| self._driver.switch_to_window(tab2) |
| self._EnableMouseLockMode() # Lock mouse in tab 2. |
| raw_input('Manually move the mouse cursor on the page in tab 2. Shift+Tab \ |
| into tab 1, click on lockMouse1() button, and move the mouse \ |
| cursor on the page in tab 1. Verify mouse movement is smooth.') |
| |
| def MouseEventsIndependentOfExitBubble(self): |
| """Verify mouse events are independent of the exit FS exit bubble for ML. |
| |
| Mouse movement events should work immediately when mouse lock is activated. |
| The events should not be blocked waiting for the exit instruction bubble to |
| clear. |
| """ |
| self.NavigateToURL(self.GetHttpURLForDataPath( |
| 'fullscreen_mouselock', 'fullscreen_mouselock.html')) |
| # Should not be in fullscreen mode during initial launch. |
| self.assertFalse(self.IsFullscreenForBrowser()) |
| self.assertFalse(self.IsFullscreenForTab()) |
| # Go into fullscreen mode. |
| self._driver.find_element_by_id('enterFullscreen').click() |
| self.assertTrue(self.WaitUntil(self.IsFullscreenForTab)) |
| self._EnableMouseLockMode() |
| raw_input( |
| '1. Move the mouse, see movement data being received by the page.\ |
| 2. Press ESC key.\ |
| 3. Lock the mouse without going fullscreen. Click lockMouse1() button.\ |
| Verify: The mouse movement events should work immediately.') |
| |
| if __name__ == '__main__': |
| pyauto_functional.Main() |
