Improve Fullscreen unit tests

third_party/WebKit/Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 43 matching lines @@
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/RemoteFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLBodyElement.h"
 #include "core/html/HTMLFormElement.h"
-#include "core/html/HTMLMediaElement.h"
+#include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageDocument.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutFullScreen.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/DocumentThreadableLoaderClient.h"
 #include "core/loader/FrameLoadRequest.h"
@@ skipping 13 matching lines @@
 #include "platform/geometry/FloatRect.h"
 #include "platform/network/ResourceError.h"
 #include "platform/scroll/Scrollbar.h"
 #include "platform/scroll/ScrollbarTestSuite.h"
 #include "platform/scroll/ScrollbarTheme.h"
 #include "platform/scroll/ScrollbarThemeMock.h"
 #include "platform/scroll/ScrollbarThemeOverlayMock.h"
 #include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
+#include "platform/testing/WebLayerTreeViewImplForTesting.h"
 #include "platform/weborigin/KURLHash.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebClipboard.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebMockClipboard.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebThread.h"
@@ skipping 7485 matching lines @@
   WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
       m_baseURL + "fullscreen_div.html", true, nullptr, &client, nullptr,
       configureAndroid);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   webViewImpl->updateAllLifecyclePhases();
 
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
   Element* divFullscreen = document->getElementById("div1");
   Fullscreen::requestFullscreen(*divFullscreen, Fullscreen::PrefixedRequest);
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), nullptr);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), divFullscreen);
   webViewImpl->didEnterFullscreen();
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), divFullscreen);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), divFullscreen);
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), divFullscreen);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), divFullscreen);
 
   // Verify that the element is sized to the viewport.
   LayoutFullScreen* fullscreenLayoutObject =
       Fullscreen::from(*document).fullScreenLayoutObject();
   EXPECT_EQ(viewportWidth, fullscreenLayoutObject->logicalWidth().toInt());
   EXPECT_EQ(viewportHeight, fullscreenLayoutObject->logicalHeight().toInt());
 
   // Verify it's updated after a device rotation.
   client.m_screenInfo.rect.width = viewportHeight;
   client.m_screenInfo.rect.height = viewportWidth;
@@ skipping 12 matching lines @@
   WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
       m_baseURL + "fullscreen_div.html", true, nullptr, &client, nullptr,
       configureAndroid);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   webViewImpl->updateAllLifecyclePhases();
 
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
   Element* divFullscreen = document->getElementById("div1");
   Fullscreen::requestFullscreen(*divFullscreen, Fullscreen::PrefixedRequest);
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), nullptr);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), divFullscreen);
   webViewImpl->didEnterFullscreen();
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), divFullscreen);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), divFullscreen);
   webViewImpl->updateAllLifecyclePhases();
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), divFullscreen);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), divFullscreen);
 
   // Verify that the viewports are nonscrollable.
-  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), divFullscreen);
   FrameView* frameView = webViewHelper.webView()->mainFrameImpl()->frameView();
   WebLayer* layoutViewportScrollLayer =
       webViewImpl->compositor()->scrollLayer()->platformLayer();
   WebLayer* visualViewportScrollLayer = frameView->page()
                                             ->frameHost()
                                             .visualViewport()
                                             .scrollLayer()
                                             ->platformLayer();
   ASSERT_FALSE(layoutViewportScrollLayer->userScrollableHorizontal());
   ASSERT_FALSE(layoutViewportScrollLayer->userScrollableVertical());
   ASSERT_FALSE(visualViewportScrollLayer->userScrollableHorizontal());
   ASSERT_FALSE(visualViewportScrollLayer->userScrollableVertical());
 
   // Verify that the viewports are scrollable upon exiting fullscreen.
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), divFullscreen);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), divFullscreen);
   webViewImpl->didExitFullscreen();
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), nullptr);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), nullptr);
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), nullptr);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document), nullptr);
   ASSERT_TRUE(layoutViewportScrollLayer->userScrollableHorizontal());
   ASSERT_TRUE(layoutViewportScrollLayer->userScrollableVertical());
   ASSERT_TRUE(visualViewportScrollLayer->userScrollableHorizontal());
   ASSERT_TRUE(visualViewportScrollLayer->userScrollableVertical());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenMainFrame) {
   FakeCompositingWebViewClient client;
   registerMockedHttpURLLoad("fullscreen_div.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   int viewportWidth = 640;
   int viewportHeight = 480;
   WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
       m_baseURL + "fullscreen_div.html", true, nullptr, &client, nullptr,
       configureAndroid);
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   webViewImpl->updateAllLifecyclePhases();
 
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
   Fullscreen::requestFullscreen(*document->documentElement(),
                                 Fullscreen::PrefixedRequest);
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document), nullptr);
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document),
+            document->documentElement());
   webViewImpl->didEnterFullscreen();
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document),
+            document->documentElement());
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document),
+            document->documentElement());
   webViewImpl->updateAllLifecyclePhases();
+  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document),
+            document->documentElement());
+  EXPECT_EQ(Fullscreen::fullscreenElementFrom(*document),
+            document->documentElement());
 
   // Verify that the main frame is still scrollable.
-  EXPECT_EQ(Fullscreen::currentFullScreenElementFrom(*document),
-            document->documentElement());
   WebLayer* webScrollLayer =
       webViewImpl->compositor()->scrollLayer()->platformLayer();
   ASSERT_TRUE(webScrollLayer->scrollable());
   ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
   ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 
   // Verify the main frame still behaves correctly after a resize.
   webViewHelper.resize(WebSize(viewportHeight, viewportWidth));
   ASSERT_TRUE(webScrollLayer->scrollable());
   ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
@@ skipping 249 matching lines @@
 
   // Make sure the new page's layout size and scale factor limits aren't
   // overridden.
   layoutViewItem = webViewImpl->mainFrameImpl()->frameView()->layoutViewItem();
   EXPECT_EQ(200, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(400, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(0.5, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 }
 
+TEST_P(ParameterizedWebFrameTest, OverlayFullscreenVideo) {
+  RuntimeEnabledFeatures::setForceOverlayFullscreenVideoEnabled(true);
+  registerMockedHttpURLLoad("fullscreen_video.html");
+  FrameTestHelpers::TestWebViewClient webViewClient;
+  FrameTestHelpers::WebViewHelper webViewHelper;
+  WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
+      m_baseURL + "fullscreen_video.html", true, nullptr, &webViewClient);
+
+  WebLayerTreeViewImplForTesting* layerTreeView =
+      static_cast<WebLayerTreeViewImplForTesting*>(

[foolip, 2016/11/24 17:08:53]

I can only assume this isn't cool? Is it acceptable, or should this kind of
thing be done by subclassing WebLayerTreeViewImplForTesting? Or something else
entirely?

[eae, 2016/11/24 21:45:31]

It is a little gross but not without precedence. Elliot, what's your take on
this?

[foolip, 2016/11/28 14:23:37]

A new week and it wasn't nearly as messy as I thought to add a special
TestFullscreenWebViewClient for this, so PTAL :)

+          webViewClient.layerTreeView());
+
+  Document* document = webViewImpl->mainFrameImpl()->frame()->document();
+  UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
+  HTMLVideoElement* video =
+      toHTMLVideoElement(document->getElementById("video"));
+  EXPECT_TRUE(video->usesOverlayFullscreenVideo());
+  EXPECT_FALSE(video->isFullscreen());
+  EXPECT_FALSE(layerTreeView->hasTransparentBackground());
+
+  video->enterFullscreen();
+  webViewImpl->didEnterFullscreen();
+  webViewImpl->updateAllLifecyclePhases();
+  EXPECT_TRUE(video->isFullscreen());
+  EXPECT_TRUE(layerTreeView->hasTransparentBackground());
+
+  webViewImpl->didExitFullscreen();
+  webViewImpl->updateAllLifecyclePhases();
+  EXPECT_FALSE(video->isFullscreen());
+  EXPECT_FALSE(layerTreeView->hasTransparentBackground());
+}
+
 TEST_P(ParameterizedWebFrameTest, LayoutBlockPercentHeightDescendants) {
   registerMockedHttpURLLoad("percent-height-descendants.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL +
                                   "percent-height-descendants.html");
 
   WebViewImpl* webView = webViewHelper.webView();
   webViewHelper.resize(WebSize(800, 800));
   webView->updateAllLifecyclePhases();
 
@@ skipping 2899 matching lines @@
 
   EXPECT_TRUE(mainFrameClient.childClient().didCallFrameDetached());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidStopLoading());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidFinishDocumentLoad());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidHandleOnloadEvents());
 
   webViewHelper.reset();
 }
 
 }  // namespace blink