Remove pyauto tests.

chrome/test/functional/fullscreen_mouselock.py

Index: chrome/test/functional/fullscreen_mouselock.py
===================================================================
--- chrome/test/functional/fullscreen_mouselock.py	(revision 261231)
+++ chrome/test/functional/fullscreen_mouselock.py	(working copy)
@@ -1,618 +0,0 @@
-#!/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()