Windowed mode mouse lock addded to fullscreen controller.

chrome/browser/ui/browser_browsertest.cc

 // 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.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #if defined(OS_MACOSX)
@@ skipping 35 matching lines @@
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/test/test_server.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 23 matching lines @@
 
 const FilePath::CharType* kBeforeUnloadFile =
     FILE_PATH_LITERAL("beforeunload.html");
 
 const FilePath::CharType* kSimpleFile = FILE_PATH_LITERAL("simple.html");
 const FilePath::CharType* kTitle1File = FILE_PATH_LITERAL("title1.html");
 const FilePath::CharType* kTitle2File = FILE_PATH_LITERAL("title2.html");
 
 const FilePath::CharType kDocRoot[] = FILE_PATH_LITERAL("chrome/test/data");
 
+const char* kFullscreenMouseLockHTML =
+    "files/fullscreen_mouselock/fullscreen_mouselock.html";
+
 // Given a page title, returns the expected window caption string.
 string16 WindowCaptionFromPageTitle(const string16& page_title) {
 #if defined(OS_MACOSX) || defined(OS_CHROMEOS)
   // On Mac or ChromeOS, we don't want to suffix the page title with
   // the application name.
   if (page_title.empty())
     return l10n_util::GetStringUTF16(IDS_BROWSER_WINDOW_MAC_TAB_UNTITLED);
   return page_title;
 #else
   if (page_title.empty())
@@ skipping 62 matching lines @@
   }
 
   virtual std::string GetHTMLContents() OVERRIDE {
     return "<h1>INTERSTITIAL</h1>";
   }
 
  private:
   InterstitialPage* interstitial_page_;  // Owns us.
 };
 
-// Fullscreen transition notification observer simplifies test code.
 class FullscreenNotificationObserver
     : public ui_test_utils::WindowedNotificationObserver {
  public:
   FullscreenNotificationObserver() : WindowedNotificationObserver(
       chrome::NOTIFICATION_FULLSCREEN_CHANGED,
       content::NotificationService::AllSources()) {}
 };
 
+class MouseLockNotificationObserver
+    : public ui_test_utils::WindowedNotificationObserver {
+ public:
+  MouseLockNotificationObserver() : WindowedNotificationObserver(
+      chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+      content::NotificationService::AllSources()) {}
+};
+
 }  // namespace
 
 class BrowserTest : public ExtensionBrowserTest {
  protected:
+  virtual void SetUpCommandLine(CommandLine* command_line) {
+    ExtensionBrowserTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitch(switches::kEnablePointerLock);
+  }
+
   // In RTL locales wrap the page title with RTL embedding characters so that it
   // matches the value returned by GetWindowTitle().
   string16 LocaleWindowCaptionFromPageTitle(const string16& expected_title) {
     string16 page_title = WindowCaptionFromPageTitle(expected_title);
 #if defined(OS_WIN)
     std::string locale = g_browser_process->GetApplicationLocale();
     if (base::i18n::GetTextDirectionForLocale(locale.c_str()) ==
         base::i18n::RIGHT_TO_LEFT) {
       base::i18n::WrapStringWithLTRFormatting(&page_title);
     }
@@ skipping 43 matching lines @@
   }
 
   void RequestToLockMouse(content::WebContents* tab, bool user_gesture) {
     browser()->RequestToLockMouse(tab, user_gesture);
   }
 
   void LostMouseLock() {
     browser()->LostMouseLock();
   }
 
+  bool SendEscapeToFullscreenController() {
+    return browser()->fullscreen_controller_->HandleUserPressedEscape();
+  }
+
   bool IsFullscreenForBrowser() {
     return browser()->fullscreen_controller_->IsFullscreenForBrowser();
   }
 
   bool IsFullscreenForTabOrPending() {
     return browser()->IsFullscreenForTabOrPending();
   }
 
   bool IsMouseLocked() {
+    // Verify that IsMouseLocked is consistent between the
+    // Fullscreen Controller and the Render View Host View.
+    EXPECT_TRUE(browser()->IsMouseLocked() ==
+                browser()->GetSelectedWebContents()->
+                    GetRenderViewHost()->GetView()->IsMouseLocked());
     return browser()->IsMouseLocked();
   }
 
   bool IsMouseLockPermissionRequested() {
     FullscreenExitBubbleType type =
         browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
     bool mouse_lock = false;
     fullscreen_bubble::PermissionRequestedByType(type, NULL, &mouse_lock);
     return mouse_lock;
   }
 
   bool IsFullscreenPermissionRequested() {
     FullscreenExitBubbleType type =
         browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
     bool fullscreen = false;
     fullscreen_bubble::PermissionRequestedByType(type, &fullscreen, NULL);
     return fullscreen;
   }
 
   FullscreenExitBubbleType GetFullscreenExitBubbleType() {
     return browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
   }
 
   bool IsFullscreenBubbleDisplayed() {
     FullscreenExitBubbleType type =
         browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
-    // TODO(scheib): Should be FEB_TYPE_NONE, crbug.com/107013 will include fix.
-    return type != FEB_TYPE_BROWSER_FULLSCREEN_EXIT_INSTRUCTION;
+    return type != FEB_TYPE_NONE;
   }
 
   bool IsFullscreenBubbleDisplayingButtons() {
     FullscreenExitBubbleType type =
         browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
     return fullscreen_bubble::ShowButtonsForType(type);
   }
 
   void AcceptCurrentFullscreenOrMouseLockRequest() {
     WebContents* fullscreen_tab = browser()->GetSelectedWebContents();
     FullscreenExitBubbleType type =
         browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
     browser()->OnAcceptFullscreenPermission(fullscreen_tab->GetURL(), type);
   }
 
+  void DenyCurrentFullscreenOrMouseLockRequest() {
+    FullscreenExitBubbleType type =
+        browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
+    browser()->OnDenyFullscreenPermission(type);
+  }
+
   // Helper method to be called by multiple tests.
   void TestFullscreenMouseLockContentSettings();
 };
 
 // Launch the app on a page with no title, check that the app title was set
 // correctly.
 IN_PROC_BROWSER_TEST_F(BrowserTest, NoTitle) {
   ui_test_utils::NavigateToURL(browser(),
       ui_test_utils::GetTestUrl(FilePath(FilePath::kCurrentDirectory),
                                 FilePath(kTitle1File)));
@@ skipping 710 matching lines @@
 
   // Request mouse lock and verify the bubble is waiting for user confirmation.
   RequestToLockMouse(fullscreen_tab, true);
   ASSERT_TRUE(IsMouseLockPermissionRequested());
 
   // Accept mouse lock and verify bubble no longer shows confirmation buttons.
   AcceptCurrentFullscreenOrMouseLockRequest();
   ASSERT_FALSE(IsFullscreenBubbleDisplayingButtons());
 }
 
-// Tests mouse lock fails before fullscreen is entered.
+// Tests mouse lock then fullscreen.
 IN_PROC_BROWSER_TEST_F(BrowserTest, MouseLockThenFullscreen) {
+  ASSERT_TRUE(test_server()->Start());
+  ui_test_utils::NavigateToURL(browser(),
+                               test_server()->GetURL(kFullscreenMouseLockHTML));
+
   WebContents* tab = browser()->GetSelectedWebContents();
-  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
-
-  RequestToLockMouse(tab, true);
-  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
-
+
+  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
+
+  // Lock the mouse without a user gesture, expect no response.
+  ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+      browser(), ui::VKEY_D, false, false, false, false,
+      chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+      content::NotificationService::AllSources()));
+  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
+  ASSERT_FALSE(IsMouseLocked());
+
+  // Lock the mouse with a user gesture.
+  ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+      browser(), ui::VKEY_1, false, false, false, false,
+      chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+      content::NotificationService::AllSources()));
+  ASSERT_TRUE(IsFullscreenBubbleDisplayed());
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+  ASSERT_FALSE(IsMouseLocked());
+
+  // Accept mouse lock.
+  AcceptCurrentFullscreenOrMouseLockRequest();
+  ASSERT_TRUE(IsMouseLocked());
+  ASSERT_FALSE(IsFullscreenBubbleDisplayingButtons());
+
+  // Enter fullscreen mode, mouse lock should be dropped to present buttons.
   ASSERT_NO_FATAL_FAILURE(ToggleTabFullscreen(tab, true));
   ASSERT_TRUE(IsFullscreenPermissionRequested());
   ASSERT_FALSE(IsMouseLockPermissionRequested());
+  ASSERT_FALSE(IsMouseLocked());
+
+  // Request mouse lock also, expect fullscreen and mouse lock buttons.
+  ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+      browser(), ui::VKEY_1, false, false, false, false,
+      chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+      content::NotificationService::AllSources()));
+  ASSERT_TRUE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+  ASSERT_FALSE(IsMouseLocked());
+
+  // Accept fullscreen and mouse lock.
+  AcceptCurrentFullscreenOrMouseLockRequest();
+  ASSERT_TRUE(IsMouseLocked());
+  ASSERT_TRUE(IsFullscreenForTabOrPending());
+  ASSERT_FALSE(IsFullscreenBubbleDisplayingButtons());
+}
+
+// Tests mouse lock then fullscreen in same request.
+IN_PROC_BROWSER_TEST_F(BrowserTest, MouseLockAndFullscreen) {
+  ASSERT_TRUE(test_server()->Start());
+  ui_test_utils::NavigateToURL(browser(),
+                               test_server()->GetURL(kFullscreenMouseLockHTML));
+
+  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
+
+  // Request to lock the mouse and enter fullscreen.
+  {
+    FullscreenNotificationObserver fullscreen_observer;
+    ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+        browser(), ui::VKEY_B, false, true, false, false,
+        chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+        content::NotificationService::AllSources()));
+    fullscreen_observer.Wait();
+  }
+  ASSERT_TRUE(IsFullscreenBubbleDisplayed());
+  ASSERT_TRUE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+  ASSERT_FALSE(IsMouseLocked());
+  ASSERT_TRUE(IsFullscreenForTabOrPending());
+
+  // Deny both first, to make sure we can.
+  {
+    FullscreenNotificationObserver fullscreen_observer;
+    DenyCurrentFullscreenOrMouseLockRequest();
+    fullscreen_observer.Wait();
+  }
+  ASSERT_FALSE(IsMouseLocked());
+  ASSERT_FALSE(IsFullscreenForTabOrPending());
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+
+  // Request to lock the mouse and enter fullscreen.
+  {
+    FullscreenNotificationObserver fullscreen_observer;
+    ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+        browser(), ui::VKEY_B, false, true, false, false,
+        chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+        content::NotificationService::AllSources()));
+    fullscreen_observer.Wait();
+  }
+  ASSERT_TRUE(IsFullscreenBubbleDisplayed());
+  ASSERT_TRUE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+  ASSERT_FALSE(IsMouseLocked());
+  ASSERT_TRUE(IsFullscreenForTabOrPending());
+
+  // Accept both, confirm they are enabled and there is no prompt.
+  AcceptCurrentFullscreenOrMouseLockRequest();
+  ASSERT_TRUE(IsMouseLocked());
+  ASSERT_TRUE(IsFullscreenForTabOrPending());
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+}
+
+// Tests mouse lock can be escaped with ESC key.
+IN_PROC_BROWSER_TEST_F(BrowserTest, EscapingMouseLock) {
+  ASSERT_TRUE(test_server()->Start());
+  ui_test_utils::NavigateToURL(browser(),
+                               test_server()->GetURL(kFullscreenMouseLockHTML));
+
+  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
+
+  // Request to lock the mouse.
+  {
+    ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+        browser(), ui::VKEY_1, false, false, false, false,
+        chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+        content::NotificationService::AllSources()));
+  }
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+
+  // Escape, no prompts should remain.
+  SendEscapeToFullscreenController();
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+
+  // Request to lock the mouse.
+  {
+    ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+        browser(), ui::VKEY_1, false, false, false, false,
+        chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+        content::NotificationService::AllSources()));
+  }
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+
+  // Accept mouse lock, confirm it and that there is no prompt.
+  AcceptCurrentFullscreenOrMouseLockRequest();
+  ASSERT_TRUE(IsMouseLocked());
+  ASSERT_FALSE(IsFullscreenForTabOrPending());
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+
+  // Escape, confirm we are out of mouse lock with no prompts.
+  SendEscapeToFullscreenController();
+  ASSERT_FALSE(IsMouseLocked());
+  ASSERT_FALSE(IsFullscreenForTabOrPending());
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+}
+
+// Tests mouse lock and fullscreen modes can be escaped with ESC key.
+IN_PROC_BROWSER_TEST_F(BrowserTest, EscapingMouseLockAndFullscreen) {
+  ASSERT_TRUE(test_server()->Start());
+  ui_test_utils::NavigateToURL(browser(),
+                               test_server()->GetURL(kFullscreenMouseLockHTML));
+
+  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
+
+  // Request to lock the mouse and enter fullscreen.
+  {
+    FullscreenNotificationObserver fullscreen_observer;
+    ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+        browser(), ui::VKEY_B, false, true, false, false,
+        chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+        content::NotificationService::AllSources()));
+    fullscreen_observer.Wait();
+  }
+  ASSERT_TRUE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+
+  // Escape, no prompts should remain.
+  {
+    FullscreenNotificationObserver fullscreen_observer;
+    SendEscapeToFullscreenController();
+    fullscreen_observer.Wait();
+  }
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+
+  // Request to lock the mouse and enter fullscreen.
+  {
+    FullscreenNotificationObserver fullscreen_observer;
+    ASSERT_TRUE(ui_test_utils::SendKeyPressAndWait(
+        browser(), ui::VKEY_B, false, true, false, false,
+        chrome::NOTIFICATION_MOUSE_LOCK_CHANGED,
+        content::NotificationService::AllSources()));
+    fullscreen_observer.Wait();
+  }
+  ASSERT_TRUE(IsFullscreenPermissionRequested());
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+
+  // Accept both, confirm mouse lock and fullscreen and no prompts.
+  AcceptCurrentFullscreenOrMouseLockRequest();
+  ASSERT_TRUE(IsMouseLocked());
+  ASSERT_TRUE(IsFullscreenForTabOrPending());
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+
+  // Escape, confirm we are out of mouse lock and fullscreen with no prompts.
+  {
+    FullscreenNotificationObserver fullscreen_observer;
+    SendEscapeToFullscreenController();
+    fullscreen_observer.Wait();
+  }
+  ASSERT_FALSE(IsMouseLocked());
+  ASSERT_FALSE(IsFullscreenForTabOrPending());
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
 }
 
 // Helper method to be called by multiple tests.
 // Tests Fullscreen and Mouse Lock with varying content settings ALLOW & BLOCK.
 void BrowserTest::TestFullscreenMouseLockContentSettings() {
   GURL url = test_server()->GetURL("simple.html");
   AddTabAtIndex(0, url, content::PAGE_TRANSITION_TYPED);
   WebContents* tab = browser()->GetSelectedWebContents();
 
   // Validate that going fullscreen for a URL defaults to asking permision.
@@ skipping 842 matching lines @@
      command_line->AppendSwitchASCII(switches::kApp, url.spec());
    }
 };
 
 IN_PROC_BROWSER_TEST_F(AppModeTest, EnableAppModeTest) {
   // Test that an application browser window loads correctly.
 
   // Verify the browser is in application mode.
   EXPECT_TRUE(browser()->IsApplication());
 }