NOT FOR REVIEW: Fullscreen WIP

third_party/WebKit/Source/web/FullscreenController.cpp

 /*
  * Copyright (C) 2013 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 19 matching lines @@
 
 #include "web/FullscreenController.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Fullscreen.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/PageScaleConstraintsSet.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLVideoElement.h"
-#include "core/layout/LayoutFullScreen.h"
-#include "platform/RuntimeEnabledFeatures.h"
 #include "public/platform/WebLayerTreeView.h"
 #include "public/web/WebFrameClient.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 #include "web/WebViewImpl.h"
 
 namespace blink {
 
 FullscreenController* FullscreenController::create(WebViewImpl* webViewImpl) {
   return new FullscreenController(webViewImpl);
 }
 
 FullscreenController::FullscreenController(WebViewImpl* webViewImpl)
     : m_webViewImpl(webViewImpl),
       m_haveEnteredFullscreen(false),
       m_exitFullscreenPageScaleFactor(0),
       m_needsScrollAndScaleRestore(false),
       m_isCancelingFullscreen(false) {}
 
 void FullscreenController::didEnterFullscreen() {
-  if (!m_provisionalFullscreenElement)
-    return;
-
-  Element* element = m_provisionalFullscreenElement.release();
-  Document& document = element->document();
-  m_fullscreenFrame = document.frame();
-
-  if (!m_fullscreenFrame)
+  if (m_pendingFullscreenElements.isEmpty())
     return;
 
   if (!m_haveEnteredFullscreen) {
     updatePageScaleConstraints(false);
     m_webViewImpl->setPageScaleFactor(1.0f);
     if (m_webViewImpl->mainFrame()->isWebLocalFrame())
       m_webViewImpl->mainFrame()->setScrollOffset(WebSize());
     m_webViewImpl->setVisualViewportOffset(FloatPoint());
     m_haveEnteredFullscreen = true;
   }
 
-  Fullscreen::from(document).didEnterFullscreenForElement(element);
-  DCHECK_EQ(Fullscreen::currentFullScreenElementFrom(document), element);
+  // TODO(foolip): Unprefixed requests
+  HeapVector<Member<Element>> pendingFullscreenElements;
+  pendingFullscreenElements.swap(m_pendingFullscreenElements);
 
-  if (isHTMLVideoElement(element)) {
-    HTMLVideoElement* videoElement = toHTMLVideoElement(element);
-    if (videoElement->usesOverlayFullscreenVideo() &&
-        m_webViewImpl->layerTreeView())
-      m_webViewImpl->layerTreeView()->setHasTransparentBackground(true);
+  for (Element* element : pendingFullscreenElements) {
+    Fullscreen::didEnterFullscreenForElement(*element,
+                                             Fullscreen::PrefixedRequest);
+
+    // TODO(foolip): this and the exit stuff has to be synced with animation
+    // frames tasks too
+    if (isHTMLVideoElement(element)) {
+      HTMLVideoElement* videoElement = toHTMLVideoElement(element);
+      if (videoElement->usesOverlayFullscreenVideo() &&
+          m_webViewImpl->layerTreeView())
+        m_webViewImpl->layerTreeView()->setHasTransparentBackground(true);
+    }
   }
 }
 
 void FullscreenController::didExitFullscreen() {
   if (!m_fullscreenFrame)
     return;
 
   if (m_haveEnteredFullscreen)
     updatePageScaleConstraints(true);
 
   if (Document* document = m_fullscreenFrame->document()) {
-    if (Fullscreen* fullscreen = Fullscreen::fromIfExists(*document)) {
-      Element* element = fullscreen->currentFullScreenElement();
-      if (element) {
-        // When the client exits from full screen we have to call
-        // fullyExitFullscreen to notify the document. While doing that,
-        // suppress notifications back to the client.
-        m_isCancelingFullscreen = true;
-        Fullscreen::fullyExitFullscreen(*document);
-        m_isCancelingFullscreen = false;
+    if (Element* element = Fullscreen::fullscreenElement(*document)) {
+      // When the client exits from full screen we have to call
+      // fullyExitFullscreen to notify the document. While doing that, suppress
+      // notifications back to the client.
+      m_isCancelingFullscreen = true;
+      Fullscreen::fullyExitFullscreen(*document);
+      m_isCancelingFullscreen = false;
 
-        // If the video used overlay fullscreen mode, the background was made
-        // transparent. Restore the transparency.
-        if (isHTMLVideoElement(element) && m_webViewImpl->layerTreeView())
-          m_webViewImpl->layerTreeView()->setHasTransparentBackground(
-              m_webViewImpl->isTransparent());
+      // If the video used overlay fullscreen mode, the background was made
+      // transparent. Restore the transparency.
+      if (isHTMLVideoElement(element) && m_webViewImpl->layerTreeView()) {
+        m_webViewImpl->layerTreeView()->setHasTransparentBackground(
+            m_webViewImpl->isTransparent());
+      }
 
-        // We need to wait until style and layout are updated in order
-        // to propertly restore scroll offsets since content may not be
-        // overflowing in the same way until they do.
-        if (m_haveEnteredFullscreen)
-          m_needsScrollAndScaleRestore = true;
+      // We need to wait until style and layout are updated in order
+      // to propertly restore scroll offsets since content may not be
+      // overflowing in the same way until they do.
+      if (m_haveEnteredFullscreen)
+        m_needsScrollAndScaleRestore = true;
 
-        fullscreen->didExitFullscreen();
-      }
+      Fullscreen::didExitFullscreen(*document);
     }
   }
 
   m_haveEnteredFullscreen = false;
   m_fullscreenFrame.clear();
 }
 
 void FullscreenController::enterFullscreenForElement(Element* element) {
-  // We are already transitioning to fullscreen for a different element.
-  if (m_provisionalFullscreenElement) {
-    m_provisionalFullscreenElement = element;
-    return;
-  }
+  m_pendingFullscreenElements.append(element);
 
   // We are already in fullscreen mode.
   if (m_fullscreenFrame) {
-    m_provisionalFullscreenElement = element;
     didEnterFullscreen();
     return;
   }
 
   // We need to store these values here rather than didEnterFullscreen since
   // by the time the latter is called, a Resize has already occured, clamping
   // the scroll offset. Don't save values if we're still waiting to restore
   // a previous set. This can happen if we exit and quickly reenter fullscreen
   // without performing a layout.
   if (!m_haveEnteredFullscreen && !m_needsScrollAndScaleRestore) {
     m_exitFullscreenPageScaleFactor = m_webViewImpl->pageScaleFactor();
     m_exitFullscreenScrollOffset =
         m_webViewImpl->mainFrame()->isWebLocalFrame()
             ? m_webViewImpl->mainFrame()->scrollOffset()
             : WebSize();
     m_exitFullscreenVisualViewportOffset =
         m_webViewImpl->visualViewportOffset();
   }
 
   // We need to transition to fullscreen mode.
   WebLocalFrameImpl* frame =
       WebLocalFrameImpl::fromFrame(element->document().frame());
   if (frame && frame->client()) {
-    if (!Fullscreen::from(element->document()).forCrossProcessDescendant())
-      frame->client()->enterFullscreen();
-    m_provisionalFullscreenElement = element;
+    frame->client()->enterFullscreen();
+  } else {
+    // TODO(foolip): now what?
+    DCHECK(0);
   }
 }
 
 void FullscreenController::exitFullscreenForElement(Element* element) {
   DCHECK(element);
 
+  // TODO(dsinclair): This should not be needed because we addToTopLayer
+  // in Fullscreen::popFullscreenElementStack but, the WebView code doesn't
+  // call Fullscreen::requestFullscreen() and, instead, just enters and
+  // exists itself. This should be unified so there is one way to go
+  // fullscreen.  crbug.com/538158
+  element->document().removeFromTopLayer(element);
+
   // The client is exiting full screen, so don't send a notification.
   if (m_isCancelingFullscreen)
     return;
 
   WebLocalFrameImpl* frame =
       WebLocalFrameImpl::fromFrame(element->document().frame());
   if (frame && frame->client())
     frame->client()->exitFullscreen();
 }
 
 void FullscreenController::updateSize() {
   if (!isFullscreen())
     return;
 
   updatePageScaleConstraints(false);
 
-  LayoutFullScreen* layoutObject =
-      Fullscreen::from(*m_fullscreenFrame->document()).fullScreenLayoutObject();
-  if (layoutObject)
-    layoutObject->updateStyle();
+  Document* document = m_fullscreenFrame->document();
+  if (Element* fullscreenElement = Fullscreen::fullscreenElement(*document))
+    Fullscreen::didUpdateSize(*fullscreenElement);
 }
 
 void FullscreenController::didUpdateLayout() {
   if (!m_needsScrollAndScaleRestore)
     return;
 
   // If we re-entered fullscreen before we could restore the scroll and scale
   // don't try restoring them yet.
   if (isFullscreen())
     return;
@@ skipping 25 matching lines @@
   // contents size.
   m_webViewImpl->didChangeContentsSize();
   if (m_webViewImpl->mainFrameImpl() &&
       m_webViewImpl->mainFrameImpl()->frameView())
     m_webViewImpl->mainFrameImpl()->frameView()->setNeedsLayout();
 
   m_webViewImpl->updateMainFrameLayoutSize();
 }
 
 DEFINE_TRACE(FullscreenController) {
-  visitor->trace(m_provisionalFullscreenElement);
+  visitor->trace(m_pendingFullscreenElements);
   visitor->trace(m_fullscreenFrame);
 }
 
 }  // namespace blink