Add additional tests for mouse lock.

chrome/test/functional/fullscreen_mouselock.py

 #!/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
@@ skipping 146 matching lines @@
     # 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.
 
-    For now, to lock the mouse, the browser needs to be in fullscreen 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.IsMouseLockPermissionRequested())
+    self.assertTrue(self.WaitUntil(self.IsMouseLockPermissionRequested))
     self.AcceptCurrentFullscreenOrMouseLockRequest()
     self.assertTrue(self.IsMouseLocked())
 
   def testPrefsForFullscreenAllowed(self):
     """Verify prefs when fullscreen is allowed."""
     self._LaunchFSAndExpectPrompt()
     self._AcceptFullscreenOrMouseLockRequest()
     content_settings = (
         self.GetPrefsInfo().Prefs()['profile']['content_settings'])
     self.assertEqual(
@@ skipping 96 matching lines @@
     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.
@@ skipping 49 matching lines @@
     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 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.
-    print "Press ESC key to exit tab fullscreen."
+    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.
-    print "Press F11 key to exit tab fullscreen."
+    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.')
+
 
 if __name__ == '__main__':
   pyauto_functional.Main()