OOPIF: Process all local ancestors when requesting and exiting fullscreen.

chrome/browser/site_per_process_interactive_browsertest.cc

 // Copyright 2016 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 "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller_test.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 33 matching lines @@
 
   gfx::Size GetScreenSize() {
     content::WebContents* web_contents =
         browser()->tab_strip_model()->GetActiveWebContents();
     const display::Display display =
         display::Screen::GetScreen()->GetDisplayNearestWindow(
             web_contents->GetRenderWidgetHostView()->GetNativeView());
     return display.bounds().size();
   }
 
+  enum class FullscreenExitMethod {
+    JS_CALL,
+    ESC_PRESS,
+  };
+
+  void FullscreenElementInABA(FullscreenExitMethod exit_method);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(SitePerProcessInteractiveBrowserTest);
 };
 
 // Check that document.hasFocus() works properly with out-of-process iframes.
 // The test builds a page with four cross-site frames and then focuses them one
 // by one, checking the value of document.hasFocus() in all frames.  For any
 // given focused frame, document.hasFocus() should return true for that frame
 // and all its ancestor frames.
 IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest, DocumentHasFocus) {
@@ skipping 394 matching lines @@
   EXPECT_FALSE(ElementHasFullscreenStyle(child, "fullscreen-div"));
   EXPECT_FALSE(ElementHasFullscreenStyle(main_frame, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenAncestorStyle(main_frame, "child-0"));
 
   // Check that both frames cleared their document.webkitFullscreenElement.
   EXPECT_EQ("none", GetFullscreenElementId(main_frame));
   EXPECT_EQ("none", GetFullscreenElementId(child));
 }
 
 // Check that on a page with A-embed-B-embed-A frame hierarchy, an element in
-// the bottom frame can enter and exit fullscreen.
-//
-// TODO(alexmos): For now, the test will verify sizing and fullscreen CSS
-// styles, but additional refactoring of Blink's Fullscreen class is required
-// to fully handle fullscreenchange events and webkitFullscreenElement in the
-// main frame.
-IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest,
-                       FullscreenElementInABA) {
+// the bottom frame can enter and exit fullscreen.  |exit_method| specifies
+// whether to use browser-initiated vs. renderer-initiated fullscreen exit
+// (i.e., pressing escape vs. a JS call), since they trigger different code
+// paths on the Blink side.
+void SitePerProcessInteractiveBrowserTest::FullscreenElementInABA(
+    FullscreenExitMethod exit_method) {
   GURL main_url(embedded_test_server()->GetURL(
       "a.com", "/cross_site_iframe_factory.html?a(b(a))"));
   ui_test_utils::NavigateToURL(browser(), main_url);
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   content::RenderFrameHost* main_frame = web_contents->GetMainFrame();
   content::RenderFrameHost* child = ChildFrameAt(main_frame, 0);
   content::RenderFrameHost* grandchild = ChildFrameAt(child, 0);
 
@@ skipping 16 matching lines @@
 
   // Add a resize event handler that will send a message when the grandchild
   // frame is resized to the screen size.  Also save its original size.
   AddResizeListener(grandchild, GetScreenSize());
   gfx::Size original_grandchild_size = GetFrameSize(grandchild);
 
   // Fullscreen a <div> inside the bottom subframe.  This will block until
   // (1) the fullscreenchange events in all frames send a response, and
   // (2) the frame is resized to fill the whole screen.
   // (3) the browser has finished the fullscreen transition.
-  //
-  // TODO(alexmos): Also wait for "main_frame" once
-  // blink::Fullscreen::requestFullscreen() and exitFullscreen() are fixed to
-  // process all local ancestors.
-  std::set<std::string> expected_events = {"child", "grandchild"};
+  std::set<std::string> expected_events = {"main_frame", "child", "grandchild"};
   {
     content::DOMMessageQueue queue;
     std::unique_ptr<FullscreenNotificationObserver> observer(
         new FullscreenNotificationObserver());
     EXPECT_TRUE(ExecuteScript(grandchild, "activateFullscreen()"));
     WaitForMultipleFullscreenEvents(expected_events, queue);
     observer->Wait();
   }
 
   // Verify that the browser has entered fullscreen for the current tab.
   EXPECT_TRUE(browser()->window()->IsFullscreen());
   EXPECT_TRUE(browser()->exclusive_access_manager()
                        ->fullscreen_controller()
                        ->IsFullscreenForTabOrPending(web_contents));
 
   // Verify that the <div> has fullscreen style in the bottom frame, and that
   // the proper <iframe> elements have fullscreen style in its ancestor frames.
   EXPECT_TRUE(ElementHasFullscreenStyle(grandchild, "fullscreen-div"));
   EXPECT_TRUE(ElementHasFullscreenStyle(child, "child-0"));
   EXPECT_TRUE(ElementHasFullscreenAncestorStyle(child, "child-0"));
   EXPECT_TRUE(ElementHasFullscreenStyle(main_frame, "child-0"));
   EXPECT_TRUE(ElementHasFullscreenAncestorStyle(main_frame, "child-0"));
 
   // Check document.webkitFullscreenElement in all frames.
+  EXPECT_EQ("child-0", GetFullscreenElementId(main_frame));
   EXPECT_EQ("child-0", GetFullscreenElementId(child));
   EXPECT_EQ("fullscreen-div", GetFullscreenElementId(grandchild));
-  // TODO(alexmos): Also check that |main_frame|'s webkitFullscreenElement is
-  // "child-0" once blink::Fullscreen::requestFullscreen() is fixed to handle
-  // all local ancestors.
 
   // Now exit fullscreen from the subframe.
   AddResizeListener(grandchild, original_grandchild_size);
   {
     content::DOMMessageQueue queue;
     std::unique_ptr<FullscreenNotificationObserver> observer(
         new FullscreenNotificationObserver());
-    EXPECT_TRUE(ExecuteScript(grandchild, "exitFullscreen()"));
+    switch (exit_method) {
+      case FullscreenExitMethod::JS_CALL:
+        EXPECT_TRUE(ExecuteScript(grandchild, "exitFullscreen()"));
+        break;
+      case FullscreenExitMethod::ESC_PRESS:
+        ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
+            browser(), ui::VKEY_ESCAPE, false, false, false, false));
+        break;
+      default:
+        NOTREACHED();
+    }
     WaitForMultipleFullscreenEvents(expected_events, queue);
     observer->Wait();
   }
 
   EXPECT_FALSE(browser()->window()->IsFullscreen());
 
   // Verify that the fullscreen styles were removed from the <div> and its
   // container <iframe>'s.
   EXPECT_FALSE(ElementHasFullscreenStyle(grandchild, "fullscreen-div"));
   EXPECT_FALSE(ElementHasFullscreenStyle(child, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenAncestorStyle(child, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenStyle(main_frame, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenAncestorStyle(main_frame, "child-0"));
 
   // Check that document.webkitFullscreenElement was cleared in all three
   // frames.
   EXPECT_EQ("none", GetFullscreenElementId(main_frame));
   EXPECT_EQ("none", GetFullscreenElementId(child));
   EXPECT_EQ("none", GetFullscreenElementId(grandchild));
 }
 
+IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest,
+                       FullscreenElementInABAAndExitViaEscapeKey) {
+  FullscreenElementInABA(FullscreenExitMethod::ESC_PRESS);
+}
+
+IN_PROC_BROWSER_TEST_F(SitePerProcessInteractiveBrowserTest,
+                       FullscreenElementInABAAndExitViaJS) {
+  FullscreenElementInABA(FullscreenExitMethod::JS_CALL);
+}
+
 // Check that fullscreen works on a more complex page hierarchy with multiple
 // local and remote ancestors.  The test uses this frame tree:
 //
 //             A (a_top)
 //             |
 //             A (a_bottom)
 //            / \   .
 // (b_first) B   B (b_second)
 //               |
 //               C (c_top)
@@ skipping 130 matching lines @@
   // Verify that all fullscreen styles have been cleared.
   EXPECT_FALSE(ElementHasFullscreenStyle(a_top, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenStyle(a_bottom, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenStyle(a_bottom, "child-1"));
   EXPECT_FALSE(ElementHasFullscreenStyle(b_second, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenStyle(c_top, "child-0"));
   EXPECT_FALSE(ElementHasFullscreenStyle(c_middle, "fullscreen-div"));
   EXPECT_FALSE(ElementHasFullscreenStyle(c_middle, "child-0"));
 }