Revert of Sync requestFullscreen() and exitFullscreen() algorithms with the spec

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 7648 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);
+  EXPECT_EQ(nullptr, Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
   webViewImpl->didEnterFullscreen();
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*document));
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
+  EXPECT_EQ(divFullscreen, Fullscreen::currentFullScreenElementFrom(*document));
   EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
   webViewImpl->updateAllLifecyclePhases();
+  EXPECT_EQ(divFullscreen, Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
 
   // 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);
+  EXPECT_EQ(nullptr, Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
   webViewImpl->didEnterFullscreen();
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*document));
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
+  EXPECT_EQ(divFullscreen, Fullscreen::currentFullScreenElementFrom(*document));
   EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
   webViewImpl->updateAllLifecyclePhases();
+  EXPECT_EQ(divFullscreen, Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
 
   // Verify that the viewports are nonscrollable.
   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(divFullscreen, Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
   webViewImpl->didExitFullscreen();
-  EXPECT_EQ(divFullscreen, Fullscreen::fullscreenElementFrom(*document));
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
+  EXPECT_EQ(nullptr, Fullscreen::currentFullScreenElementFrom(*document));
   EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*document));
   webViewImpl->updateAllLifecyclePhases();
+  EXPECT_EQ(nullptr, Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*document));
   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());
-  webViewImpl->didEnterFullscreen();
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*document));
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
+  EXPECT_EQ(nullptr, Fullscreen::currentFullScreenElementFrom(*document));
   EXPECT_EQ(document->documentElement(),
             Fullscreen::fullscreenElementFrom(*document));
+  webViewImpl->didEnterFullscreen();
+  EXPECT_EQ(document->documentElement(),
+            Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(document->documentElement(),
+            Fullscreen::fullscreenElementFrom(*document));
+
   webViewImpl->updateAllLifecyclePhases();
+  EXPECT_EQ(document->documentElement(),
+            Fullscreen::currentFullScreenElementFrom(*document));
+  EXPECT_EQ(document->documentElement(),
+            Fullscreen::fullscreenElementFrom(*document));
 
   // Verify that the main frame is still scrollable.
   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));
@@ skipping 18 matching lines @@
   webViewImpl->updateAllLifecyclePhases();
 
   Document* document =
       toWebLocalFrameImpl(webViewHelper.webView()->mainFrame()->firstChild())
           ->frame()
           ->document();
   UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
   Element* divFullscreen = document->getElementById("div1");
   Fullscreen::requestFullscreen(*divFullscreen);
   webViewImpl->didEnterFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
 
   // 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;
@@ skipping 21 matching lines @@
   HTMLIFrameElement* iframe =
       toHTMLIFrameElement(topDoc->querySelector("iframe"));
   Document* iframeDoc = iframe->contentDocument();
   Element* iframeBody = iframeDoc->body();
 
   {
     UserGestureIndicator gesture(DocumentUserGestureToken::create(topDoc));
     Fullscreen::requestFullscreen(*topBody);
   }
   webViewImpl->didEnterFullscreen();
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*topDoc));
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*iframeDoc));
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
-  EXPECT_EQ(topBody, Fullscreen::fullscreenElementFrom(*topDoc));
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*iframeDoc));
   webViewImpl->updateAllLifecyclePhases();
 
   {
     UserGestureIndicator gesture(DocumentUserGestureToken::create(iframeDoc));
     Fullscreen::requestFullscreen(*iframeBody);
   }
   webViewImpl->didEnterFullscreen();
-  EXPECT_EQ(topBody, Fullscreen::fullscreenElementFrom(*topDoc));
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*iframeDoc));
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
-  EXPECT_EQ(iframe, Fullscreen::fullscreenElementFrom(*topDoc));
-  EXPECT_EQ(iframeBody, Fullscreen::fullscreenElementFrom(*iframeDoc));
   webViewImpl->updateAllLifecyclePhases();
 
   // We are now in nested fullscreen, with both documents having a non-empty
   // fullscreen element stack.
+  EXPECT_EQ(topBody, Fullscreen::currentFullScreenElementFrom(*topDoc));
+  EXPECT_EQ(iframe, Fullscreen::fullscreenElementFrom(*topDoc));
+  EXPECT_EQ(iframeBody, Fullscreen::currentFullScreenElementFrom(*iframeDoc));
+  EXPECT_EQ(iframeBody, Fullscreen::fullscreenElementFrom(*iframeDoc));
 
   webViewImpl->didExitFullscreen();
-  EXPECT_EQ(iframe, Fullscreen::fullscreenElementFrom(*topDoc));
-  EXPECT_EQ(iframeBody, Fullscreen::fullscreenElementFrom(*iframeDoc));
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*topDoc));
-  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*iframeDoc));
   webViewImpl->updateAllLifecyclePhases();
 
-  // We have now fully exited fullscreen.
+  // We should now have fully exited fullscreen.
+  EXPECT_EQ(nullptr, Fullscreen::currentFullScreenElementFrom(*topDoc));
+  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*topDoc));
+  EXPECT_EQ(nullptr, Fullscreen::currentFullScreenElementFrom(*iframeDoc));
+  EXPECT_EQ(nullptr, Fullscreen::fullscreenElementFrom(*iframeDoc));
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenWithTinyViewport) {
   FakeCompositingWebViewClient client;
   registerMockedHttpURLLoad("viewport-tiny.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-tiny.html", true, nullptr, &client, nullptr,
       configureAndroid);
   int viewportWidth = 384;
   int viewportHeight = 640;
   client.m_screenInfo.rect.width = viewportWidth;
   client.m_screenInfo.rect.height = viewportHeight;
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   webViewImpl->updateAllLifecyclePhases();
 
   LayoutViewItem layoutViewItem =
       webViewHelper.webView()->mainFrameImpl()->frameView()->layoutViewItem();
   EXPECT_EQ(320, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(533, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(1.2, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(1.2, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
   Fullscreen::requestFullscreen(*document->documentElement());
   webViewImpl->didEnterFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(384, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(640, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->maximumPageScaleFactor());
 
   webViewImpl->didExitFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(320, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(533, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(1.2, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(1.2, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenResizeWithTinyViewport) {
   FakeCompositingWebViewClient client;
   registerMockedHttpURLLoad("viewport-tiny.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   WebViewImpl* webViewImpl = webViewHelper.initializeAndLoad(
       m_baseURL + "viewport-tiny.html", true, nullptr, &client, nullptr,
       configureAndroid);
   int viewportWidth = 384;
   int viewportHeight = 640;
   client.m_screenInfo.rect.width = viewportWidth;
   client.m_screenInfo.rect.height = viewportHeight;
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   webViewImpl->updateAllLifecyclePhases();
 
   LayoutViewItem layoutViewItem =
       webViewHelper.webView()->mainFrameImpl()->frameView()->layoutViewItem();
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
   Fullscreen::requestFullscreen(*document->documentElement());
   webViewImpl->didEnterFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(384, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(640, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->maximumPageScaleFactor());
 
   viewportWidth = 640;
   viewportHeight = 384;
   client.m_screenInfo.rect.width = viewportWidth;
   client.m_screenInfo.rect.height = viewportHeight;
   webViewHelper.resize(WebSize(viewportWidth, viewportHeight));
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(640, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(384, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->maximumPageScaleFactor());
 
   webViewImpl->didExitFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
   EXPECT_EQ(320, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(192, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(2, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(2, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenRestoreScaleFactorUponExiting) {
   // The purpose of this test is to more precisely simulate the sequence of
@@ skipping 23 matching lines @@
   EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 
   {
     Document* document = webViewImpl->mainFrameImpl()->frame()->document();
     UserGestureIndicator gesture(DocumentUserGestureToken::create(document));
     Fullscreen::requestFullscreen(*document->body());
   }
 
   webViewImpl->didEnterFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
   client.m_screenInfo.rect.width = screenSizeMinusStatusBars.width;
   client.m_screenInfo.rect.height = screenSizeMinusStatusBars.height;
   webViewHelper.resize(screenSizeMinusStatusBars);
   client.m_screenInfo.rect.width = screenSize.width;
   client.m_screenInfo.rect.height = screenSize.height;
   webViewHelper.resize(screenSize);
   EXPECT_EQ(screenSize.width, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(screenSize.height, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->maximumPageScaleFactor());
 
   webViewImpl->didExitFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
   client.m_screenInfo.rect.width = screenSizeMinusStatusBars.width;
   client.m_screenInfo.rect.height = screenSizeMinusStatusBars.height;
   webViewHelper.resize(screenSizeMinusStatusBars);
   client.m_screenInfo.rect.width = screenSizeMinusStatusBarsMinusUrlBar.width;
   client.m_screenInfo.rect.height = screenSizeMinusStatusBarsMinusUrlBar.height;
   webViewHelper.resize(screenSizeMinusStatusBarsMinusUrlBar);
   EXPECT_EQ(screenSizeMinusStatusBarsMinusUrlBar.width,
             layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(screenSizeMinusStatusBarsMinusUrlBar.height,
@@ skipping 25 matching lines @@
   EXPECT_EQ(640, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(0.3125, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(0.3125, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, webViewImpl->maximumPageScaleFactor());
 
   Document* document = webViewImpl->mainFrameImpl()->frame()->document();
   UserGestureIndicator gesture(
       DocumentUserGestureToken::create(document, UserGestureToken::NewGesture));
   Fullscreen::requestFullscreen(*document->documentElement());
   webViewImpl->didEnterFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
 
   // Entering fullscreen causes layout size and page scale limits to be
   // overridden.
   EXPECT_EQ(100, layoutViewItem.logicalWidth().floor());
   EXPECT_EQ(200, layoutViewItem.logicalHeight().floor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->pageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->minimumPageScaleFactor());
   EXPECT_FLOAT_EQ(1.0, webViewImpl->maximumPageScaleFactor());
 
   const char source[] = "<meta name=\"viewport\" content=\"width=200\">";
 
   // Load a new page before exiting fullscreen.
   KURL testURL = toKURL("about:blank");
   WebFrame* frame = webViewHelper.webView()->mainFrame();
   FrameTestHelpers::loadHTMLString(frame, source, testURL);
   webViewImpl->didExitFullscreen();
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
   webViewImpl->updateAllLifecyclePhases();
 
   // 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());
 }
@@ skipping 27 matching lines @@
       m_baseURL + "fullscreen_video.html", true, nullptr, &webViewClient);
 
   const TestFullscreenWebLayerTreeView& layerTreeView =
       webViewClient.testFullscreenLayerTreeView;
 
   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->webkitEnterFullscreen();
   webViewImpl->didEnterFullscreen();
+  webViewImpl->updateAllLifecyclePhases();
+  EXPECT_TRUE(video->isFullscreen());
+  EXPECT_TRUE(layerTreeView.hasTransparentBackground);
+
+  webViewImpl->didExitFullscreen();
+  webViewImpl->updateAllLifecyclePhases();
   EXPECT_FALSE(video->isFullscreen());
   EXPECT_FALSE(layerTreeView.hasTransparentBackground);
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
-  EXPECT_TRUE(video->isFullscreen());
-  EXPECT_TRUE(layerTreeView.hasTransparentBackground);
-  webViewImpl->updateAllLifecyclePhases();
-
-  webViewImpl->didExitFullscreen();
-  EXPECT_TRUE(video->isFullscreen());
-  EXPECT_TRUE(layerTreeView.hasTransparentBackground);
-  webViewImpl->beginFrame(WTF::monotonicallyIncreasingTime());
-  EXPECT_FALSE(video->isFullscreen());
-  EXPECT_FALSE(layerTreeView.hasTransparentBackground);
-  webViewImpl->updateAllLifecyclePhases();
 }
 
 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));
@@ skipping 3082 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