Automated tests for full screen & mouse lock M16 features

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)
 #include "base/mac/mac_util.h"
 #endif
 #include "base/sys_info.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/command_updater.h"
+#include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_helper.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tabs/pinned_tab_codec.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
@@ skipping 142 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

[yzshen1, 2012/03/16 07:33:28]

Please move ": public" to the same line as
ui_test_utils::WindowedNotificationObserver.

[scheib, 2012/03/16 21:20:03]

Done.

+    ui_test_utils::WindowedNotificationObserver {
+ public:
+  FullscreenNotificationObserver() : WindowedNotificationObserver(
+      chrome::NOTIFICATION_FULLSCREEN_CHANGED,
+      content::NotificationService::AllSources()) { }

[yzshen1, 2012/03/16 07:33:28]

nit: no need to have a space between {}.

[scheib, 2012/03/16 21:20:03]

Done.

+};
+
 }  // namespace
 
 class BrowserTest : public ExtensionBrowserTest {
  protected:
   // In RTL locales wrap the page title with RTL embedding characters so that it
   // matches the value returned by GetWindowTitle().
   std::wstring LocaleWindowCaptionFromPageTitle(
       const std::wstring& expected_title) {
     std::wstring page_title = WindowCaptionFromPageTitle(expected_title);
 #if defined(OS_WIN)
@@ skipping 15 matching lines @@
     const ExtensionSet* extensions =
         browser()->profile()->GetExtensionService()->extensions();
     for (ExtensionSet::const_iterator it = extensions->begin();
          it != extensions->end(); ++it) {
       if ((*it)->name() == "App Test")
         return *it;
     }
     NOTREACHED();
     return NULL;
   }
+
+  void ToggleTabFullscreen(WebContents* tab, bool enter_fullscreen)  {
+    if (browser()->fullscreen_controller_->IsFullscreenForBrowser()) {
+      // Changing tab fullscreen state will not actually change the window
+      // when browser fullscreen is in effect.
+      browser()->ToggleFullscreenModeForTab(tab, enter_fullscreen);
+    } else {  // Not in browser fullscreen, expect window to actually change.

[yzshen1, 2012/03/16 07:33:28]

Please consider the following sequence:
browser fullscreen -> tab fullscreen -> ToggleTabFullscreen(tab, false) -> it
will reach this 'else' branch, but we won't observe a fullscreen change
notification, right?

[scheib, 2012/03/16 21:20:03]

Etner Browser FS  | Will check for notification
Enter Tab FS      | Will not check notification
Exit Tab FS       | Will not check notification because IsFullscreenForBrowser
will still return true - the fullscreen was still initiated by browser mode.

[yzshen1, 2012/03/16 21:42:55]

Ah, I see.

I mistakenly thought that IsFullscreenForBrowser() <==> "Currently it is browser
fullscreen mode."
It would be good to add a comment for IsFullscreenForBrowser(), saying that
fullscreen was initiated by browser mode, but is not necessarily in browser
fullscreen mode at the moment.

On 2012/03/16 21:20:03, scheib wrote:

[scheib, 2012/03/19 17:11:06]

Done.

+      FullscreenNotificationObserver fullscreen_observer;
+      browser()->ToggleFullscreenModeForTab(tab, enter_fullscreen);
+      fullscreen_observer.Wait();
+      ASSERT_EQ(browser()->window()->IsFullscreen(), enter_fullscreen);
+    }
+  }
+
+  void ToggleBrowserFullscreen(bool enter_fullscreen)  {

[yzshen1, 2012/03/16 07:33:28]

|enter_fullscreen| seems to be the expected result, instead of a request.
The is different from the |enter_fullscreen| parameter of the previous method,
right?

[scheib, 2012/03/16 21:20:03]

True, this is inherited from previous impl. I've added an assert before the
toggle to verify that the state is opposite of the desired transition. Adding
logic to detect the current state and make sure the transition results in the
desired state without fail is fairly complex and I don't think needed for any
tests. Either they're running as expected, or they're not and we should early
out as soon as they deviate.

+    FullscreenNotificationObserver fullscreen_observer;
+
+    browser()->ToggleFullscreenMode();
+
+    fullscreen_observer.Wait();
+    ASSERT_EQ(browser()->window()->IsFullscreen(), enter_fullscreen);
+    ASSERT_EQ(browser()->fullscreen_controller_->IsFullscreenForBrowser(),
+        enter_fullscreen);
+  }
+
+  void RequestToLockMouse(content::WebContents* tab) {
+    browser()->RequestToLockMouse(tab);
+  }
+
+  void LostMouseLock() {
+    browser()->LostMouseLock();
+  }
+
+  bool IsFullscreenForTabOrPending() {
+    return browser()->IsFullscreenForTabOrPending();
+  }
+
+  bool IsMouseLockedOrPending() {
+    return browser()->IsMouseLockedOrPending();
+  }
+
+  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;
+  }
+
+  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 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)));
   EXPECT_EQ(LocaleWindowCaptionFromPageTitle(L"title1.html"),
             UTF16ToWideHack(browser()->GetWindowTitleForCurrentTab()));
@@ skipping 644 matching lines @@
   EXPECT_EQ("fr", helper->language_state().original_language());
 }
 
 #if defined(OS_MACOSX)
 // http://crbug.com/104265
 #define MAYBE_TestNewTabExitsFullscreen DISABLED_TestNewTabExitsFullscreen
 #else
 #define MAYBE_TestNewTabExitsFullscreen TestNewTabExitsFullscreen
 #endif
 
+// Tests that while in full screen creating a new tab will exit full screen.

[yzshen1, 2012/03/16 07:33:28]

nit: we usually use 'fullscreen' as a word in the code. (There are several
places in this file that use 'full screen'.

[scheib, 2012/03/16 21:20:03]

Done.

 IN_PROC_BROWSER_TEST_F(BrowserTest, MAYBE_TestNewTabExitsFullscreen) {
   ASSERT_TRUE(test_server()->Start());
 
   AddTabAtIndex(
       0, GURL(chrome::kAboutBlankURL), content::PAGE_TRANSITION_TYPED);
 
   WebContents* fullscreen_tab = browser()->GetSelectedWebContents();
 
-  {
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
-    browser()->ToggleFullscreenModeForTab(fullscreen_tab, true);
-    fullscreen_observer.Wait();
-    ASSERT_TRUE(browser()->window()->IsFullscreen());
-  }
+  ToggleTabFullscreen(fullscreen_tab, true);
 
   {
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
+    FullscreenNotificationObserver fullscreen_observer;
     AddTabAtIndex(
         1, GURL(chrome::kAboutBlankURL), content::PAGE_TRANSITION_TYPED);
     fullscreen_observer.Wait();
     ASSERT_FALSE(browser()->window()->IsFullscreen());
   }
 }
 
 #if defined(OS_MACOSX)
 // http://crbug.com/100467
 #define MAYBE_TestTabExitsItselfFromFullscreen \
         FAILS_TestTabExitsItselfFromFullscreen
 #else
 #define MAYBE_TestTabExitsItselfFromFullscreen TestTabExitsItselfFromFullscreen
 #endif
 
+// Tests a tab exiting full screen will bring the browser out of full screen.
 IN_PROC_BROWSER_TEST_F(BrowserTest, MAYBE_TestTabExitsItselfFromFullscreen) {
   ASSERT_TRUE(test_server()->Start());
 
   AddTabAtIndex(
       0, GURL(chrome::kAboutBlankURL), content::PAGE_TRANSITION_TYPED);
 
   WebContents* fullscreen_tab = browser()->GetSelectedWebContents();
-
-  {
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
-    browser()->ToggleFullscreenModeForTab(fullscreen_tab, true);
-    fullscreen_observer.Wait();
-    ASSERT_TRUE(browser()->window()->IsFullscreen());
-  }
-
-  {
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
-    browser()->ToggleFullscreenModeForTab(fullscreen_tab, false);
-    fullscreen_observer.Wait();
-    ASSERT_FALSE(browser()->window()->IsFullscreen());
-  }
+  ToggleTabFullscreen(fullscreen_tab, true);
+  ToggleTabFullscreen(fullscreen_tab, false);
 }
 
+// Tests entering full screen and then requesting mouse lock results in
+// buttons for the user, and that after confirming the buttons are dismissed.
 IN_PROC_BROWSER_TEST_F(BrowserTest, TestFullscreenBubbleMouseLockState) {
   ASSERT_TRUE(test_server()->Start());
 
   AddTabAtIndex(0, GURL(chrome::kAboutBlankURL),
                 content::PAGE_TRANSITION_TYPED);
   AddTabAtIndex(1, GURL(chrome::kAboutBlankURL),
                 content::PAGE_TRANSITION_TYPED);
 
   WebContents* fullscreen_tab = browser()->GetSelectedWebContents();
 
-  {
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
-    browser()->ToggleFullscreenModeForTab(fullscreen_tab, true);
-    fullscreen_observer.Wait();
-    ASSERT_TRUE(browser()->window()->IsFullscreen());
-  }
+  ToggleTabFullscreen(fullscreen_tab, true);
 
-  browser()->RequestToLockMouse(fullscreen_tab);
-  FullscreenExitBubbleType type =
-      browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
-  bool mouse_lock = false;
-  fullscreen_bubble::PermissionRequestedByType(type, NULL, &mouse_lock);
-  ASSERT_TRUE(mouse_lock);
+  // Request mouse lock and verify the bubble is waiting for user confirmation.
+  RequestToLockMouse(fullscreen_tab);
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
 
-  browser()->OnAcceptFullscreenPermission(fullscreen_tab->GetURL(), type);
-  type = browser()->fullscreen_controller_->GetFullscreenExitBubbleType();
-  ASSERT_FALSE(fullscreen_bubble::ShowButtonsForType(type));
+  // Accept mouse lock and verify bubble no longer shows confirmation buttons.
+  AcceptCurrentFullscreenOrMouseLockRequest();
+  ASSERT_FALSE(IsFullscreenBubbleDisplayingButtons());
+}
+
+// Tests mouse lock fails before fullscreen is entered.
+IN_PROC_BROWSER_TEST_F(BrowserTest, MouseLockThenFullscreen) {
+  WebContents* tab = browser()->GetSelectedWebContents();
+  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
+
+  RequestToLockMouse(tab);
+  ASSERT_FALSE(IsFullscreenBubbleDisplayed());
+
+  ToggleTabFullscreen(tab, true);
+  ASSERT_TRUE(IsFullscreenPermissionRequested());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+}
+
+

[yzshen1, 2012/03/16 07:33:28]

Please remove one blank line.

[scheib, 2012/03/16 21:20:03]

Done.

+// 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.
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ToggleTabFullscreen(tab, true);
+  ASSERT_TRUE(IsFullscreenPermissionRequested());
+  ToggleTabFullscreen(tab, false);
+
+  // Add content setting to ALLOW fullscreen.
+  HostContentSettingsMap* settings_map =
+      browser()->profile()->GetHostContentSettingsMap();
+  ContentSettingsPattern pattern =
+      ContentSettingsPattern::FromURL(url);
+  settings_map->SetContentSetting(
+      pattern, ContentSettingsPattern::Wildcard(),
+      CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string(),
+      CONTENT_SETTING_ALLOW);
+
+  // Now, fullscreen should not prompt for permission.
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ToggleTabFullscreen(tab, true);
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+
+  // Leaving tab in fullscreen, now test mouse lock ALLOW:
+
+  // Validate that mouse lock defaults to asking permision.
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+  ASSERT_FALSE(IsMouseLockedOrPending());
+  RequestToLockMouse(tab);
+  ASSERT_TRUE(IsMouseLockPermissionRequested());
+  ASSERT_TRUE(IsMouseLockedOrPending());
+  LostMouseLock();
+
+  // Add content setting to ALLOW mouse lock.
+  settings_map->SetContentSetting(
+      pattern, ContentSettingsPattern::Wildcard(),
+      CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string(),
+      CONTENT_SETTING_ALLOW);
+
+  // Now, mouse lock should not prompt for permission.
+  ASSERT_FALSE(IsMouseLockedOrPending());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+  RequestToLockMouse(tab);
+  ASSERT_TRUE(IsMouseLockedOrPending());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+  LostMouseLock();
+
+  // Leaving tab in fullscreen, now test mouse lock BLOCK:
+
+  // Add content setting to BLOCK mouse lock.
+  settings_map->SetContentSetting(
+      pattern, ContentSettingsPattern::Wildcard(),
+      CONTENT_SETTINGS_TYPE_MOUSELOCK, std::string(),
+      CONTENT_SETTING_BLOCK);
+
+  // Now, mouse lock should not be pending.
+  ASSERT_FALSE(IsMouseLockedOrPending());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+  RequestToLockMouse(tab);
+  ASSERT_FALSE(IsMouseLockedOrPending());
+  ASSERT_FALSE(IsMouseLockPermissionRequested());
+}
+
+// Tests fullscreen and Mouse Lock with varying content settings ALLOW & BLOCK.
+IN_PROC_BROWSER_TEST_F(BrowserTest, FullscreenMouseLockContentSettings) {
+  TestFullscreenMouseLockContentSettings();
+}
+
+// Tests fullscreen and Mouse Lock with varying content settings ALLOW & BLOCK,
+// but with the browser initiated in fullscreen mode first.
+IN_PROC_BROWSER_TEST_F(BrowserTest, BrowserFullscreenMouseLockContentSettings) {
+  // Enter browser fullscreen first.
+  ToggleBrowserFullscreen(true);
+  TestFullscreenMouseLockContentSettings();
+  ToggleBrowserFullscreen(false);
+}
+
+// Tests Fullscreen entered in Browser, then Tab mode, then exited via Browser.

[yzshen1, 2012/03/16 07:33:28]

It would be great if we also test
browser fullscreen -> tab fullscreen -> exit tab fullscreen -> it should stay in
browser fullscreen.

[scheib, 2012/03/16 21:20:03]

Done. Added BrowserFullscreenAfterTabFSExit.

+IN_PROC_BROWSER_TEST_F(BrowserTest, BrowserFullscreenExit) {
+  // Enter browser fullscreen.
+  ToggleBrowserFullscreen(true);
+
+  // Enter tab fullscreen.
+  AddTabAtIndex(0, GURL(chrome::kAboutBlankURL),
+                content::PAGE_TRANSITION_TYPED);
+  WebContents* fullscreen_tab = browser()->GetSelectedWebContents();
+  ToggleTabFullscreen(fullscreen_tab, true);
+
+  // Exit browser fullscreen.
+  ToggleBrowserFullscreen(false);
+  ASSERT_FALSE(browser()->window()->IsFullscreen());
+}
+
+// Tests fullscreen entered without permision prompt for file:// urls.
+IN_PROC_BROWSER_TEST_F(BrowserTest, FullscreenFileURL) {
+  GURL url = ui_test_utils::GetTestUrl(FilePath(""), FilePath("simple.html"));
+  AddTabAtIndex(0, url, content::PAGE_TRANSITION_TYPED);
+  WebContents* tab = browser()->GetSelectedWebContents();
+
+  // Validate that going fullscreen for a URL defaults to asking permision.

[koz (OOO until 15th September), 2012/03/16 04:31:25]

This comment seems to contradict the code and the comment for this test.

[scheib, 2012/03/16 21:20:03]

Done.

+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ToggleTabFullscreen(tab, true);
+  ASSERT_FALSE(IsFullscreenPermissionRequested());
+  ToggleTabFullscreen(tab, false);
 }
 
 #if defined(OS_MACOSX)
 // http://crbug.com/100467
 IN_PROC_BROWSER_TEST_F(
     BrowserTest, FAILS_TabEntersPresentationModeFromWindowed) {
   ASSERT_TRUE(test_server()->Start());
 
   AddTabAtIndex(
       0, GURL(chrome::kAboutBlankURL), content::PAGE_TRANSITION_TYPED);
 
   WebContents* fullscreen_tab = browser()->GetSelectedWebContents();
 
   {
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
+    FullscreenNotificationObserver fullscreen_observer;
     EXPECT_FALSE(browser()->window()->IsFullscreen());
     EXPECT_FALSE(browser()->window()->InPresentationMode());
     browser()->ToggleFullscreenModeForTab(fullscreen_tab, true);
     fullscreen_observer.Wait();
     ASSERT_TRUE(browser()->window()->IsFullscreen());
     ASSERT_TRUE(browser()->window()->InPresentationMode());
   }
 
   {
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
+    FullscreenNotificationObserver fullscreen_observer;
     browser()->TogglePresentationMode();
     fullscreen_observer.Wait();
     ASSERT_FALSE(browser()->window()->IsFullscreen());
     ASSERT_FALSE(browser()->window()->InPresentationMode());
   }
 
   if (base::mac::IsOSLionOrLater()) {
     // Test that tab fullscreen mode doesn't make presentation mode the default
     // on Lion.
-    ui_test_utils::WindowedNotificationObserver fullscreen_observer(
-        chrome::NOTIFICATION_FULLSCREEN_CHANGED,
-        content::NotificationService::AllSources());
+    FullscreenNotificationObserver fullscreen_observer;
     browser()->ToggleFullscreenMode();
     fullscreen_observer.Wait();
     ASSERT_TRUE(browser()->window()->IsFullscreen());
     ASSERT_FALSE(browser()->window()->InPresentationMode());
   }
 }
 #endif
 
 // Chromeos defaults to restoring the last session, so this test isn't
 // applicable.
@@ skipping 518 matching lines @@
 
   // The normal browser should now have four.
   EXPECT_EQ(4, browser()->tab_count());
 
   // Close the additional browsers.
   popup_browser->CloseAllTabs();
   app_browser->CloseAllTabs();
   app_popup_browser->CloseAllTabs();
 }
 #endif