[WIP] Migrate Fullscreen to use top layer instead of RenderFullScreen

Source/core/dom/FullscreenController.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
@@ skipping 21 matching lines @@
 #include "bindings/v8/ScriptController.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Event.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Frame.h"
 #include "core/page/Page.h"
 #include "core/page/Settings.h"
-#include "core/rendering/RenderFullScreen.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 static bool isAttributeOnAllOwners(const WebCore::QualifiedName& attribute, const WebCore::QualifiedName& prefixedAttribute, const HTMLFrameOwnerElement* owner)
 {
     if (!owner)
         return true;
     do {
@@ skipping 41 matching lines @@
 bool FullscreenController::isFullScreen(Document* document)
 {
     if (FullscreenController* found = fromIfExists(document))
         return found->webkitIsFullScreen();
     return false;
 }
 
 FullscreenController::FullscreenController(Document* document)
     : DocumentLifecycleObserver(document)
     , m_areKeysEnabledInFullScreen(false)
-    , m_fullScreenRenderer(0)
     , m_fullScreenChangeDelayTimer(this, &FullscreenController::fullScreenChangeDelayTimerFired)
 {
     document->setHasFullscreenController();
 }
 
 FullscreenController::~FullscreenController()
 {
 }
 
 inline Document* FullscreenController::document()
 {
     return toDocument(scriptExecutionContext());
 }
 
 void FullscreenController::documentWasDetached()
 {
     m_fullScreenChangeEventTargetQueue.clear();
     m_fullScreenErrorEventTargetQueue.clear();
-
-    if (m_fullScreenRenderer)
-        setFullScreenRenderer(0);
 }
 
 void FullscreenController::documentWasDisposed()
 {
     m_fullScreenElement = 0;
     m_fullScreenElementStack.clear();
 }
 
 bool FullscreenController::fullScreenIsAllowedForElement(Element* element) const
 {
@@ skipping 218 matching lines @@
     if (!document()->attached())
         return;
 
     ASSERT(element);
 
     // Protect against being called after the document has been removed from the page.
     if (!document()->page())
         return;
 
     ASSERT(document()->page()->settings()->fullScreenEnabled());
-
-    if (m_fullScreenRenderer)
-        m_fullScreenRenderer->unwrapRenderer();
-
     m_fullScreenElement = element;
+    document()->addToTopLayer(element);
 
 #if USE(NATIVE_FULLSCREEN_VIDEO)
     if (element && element->isMediaElement())
         return;
 #endif
 
-    // Create a placeholder block for a the full-screen element, to keep the page from reflowing
-    // when the element is removed from the normal flow. Only do this for a RenderBox, as only
-    // a box will have a frameRect. The placeholder will be created in setFullScreenRenderer()
-    // during layout.
-    RenderObject* renderer = m_fullScreenElement->renderer();
-    bool shouldCreatePlaceholder = renderer && renderer->isBox();
-    if (shouldCreatePlaceholder) {
-        m_savedPlaceholderFrameRect = toRenderBox(renderer)->frameRect();
-        m_savedPlaceholderRenderStyle = RenderStyle::clone(renderer->style());
-    }

[trchen, 2013/07/18 22:26:29]

I'm not sure how Document::addToTopLayer() works, but wouldn't it cause the page
to be reflowed without using a placeholder box?

[falken, 2013/07/22 17:51:44]

Yes, I think so. I thought we should remove it since the spec doesn't mention a
placeholder, and it's adding more complexity by making the render tree differ
even more from the DOM tree.

-
-    if (m_fullScreenElement != document()->documentElement())
-        RenderFullScreen::wrapRenderer(renderer, renderer ? renderer->parent() : 0, document());
-
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
-
-    document()->recalcStyle(Node::Force);

[falken, 2013/07/09 12:50:22]

I think this recalcStyle was a quirk needed for RenderFullScreen. I'll hunt down
when it was added.

 }
 
 void FullscreenController::webkitDidEnterFullScreenForElement(Element*)
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->attached())
         return;
 
     m_fullScreenElement->didBecomeFullscreenElement();
 
     m_fullScreenChangeDelayTimer.startOneShot(0);
 }
 
 void FullscreenController::webkitWillExitFullScreenForElement(Element*)
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->attached())
         return;
 
+    document()->removeFromTopLayer(m_fullScreenElement.get());
     m_fullScreenElement->willStopBeingFullscreenElement();
 }
 
 void FullscreenController::webkitDidExitFullScreenForElement(Element*)
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->attached())
         return;
 
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
-
     m_areKeysEnabledInFullScreen = false;
 
-    if (m_fullScreenRenderer)
-        m_fullScreenRenderer->unwrapRenderer();
-
     m_fullScreenElement = 0;
     document()->scheduleForcedStyleRecalc();
 
     // When webkitCancelFullScreen is called, we call webkitExitFullScreen on the topDocument(). That
     // means that the events will be queued there. So if we have no events here, start the timer on
     // the exiting document.
     Document* exitingDocument = document();
     if (m_fullScreenChangeEventTargetQueue.isEmpty() && m_fullScreenErrorEventTargetQueue.isEmpty())
         exitingDocument = document()->topDocument();
     from(exitingDocument)->m_fullScreenChangeDelayTimer.startOneShot(0);
 }
 
-void FullscreenController::setFullScreenRenderer(RenderFullScreen* renderer)
-{
-    if (renderer == m_fullScreenRenderer)
-        return;
-
-    if (renderer && m_savedPlaceholderRenderStyle) {
-        renderer->createPlaceholder(m_savedPlaceholderRenderStyle.release(), m_savedPlaceholderFrameRect);
-    } else if (renderer && m_fullScreenRenderer && m_fullScreenRenderer->placeholder()) {
-        RenderBlock* placeholder = m_fullScreenRenderer->placeholder();
-        renderer->createPlaceholder(RenderStyle::clone(placeholder->style()), placeholder->frameRect());
-    }
-
-    if (m_fullScreenRenderer)
-        m_fullScreenRenderer->destroy();
-    ASSERT(!m_fullScreenRenderer);
-
-    m_fullScreenRenderer = renderer;
-}
-
-void FullscreenController::fullScreenRendererDestroyed()
-{
-    m_fullScreenRenderer = 0;
-}
-
 void FullscreenController::fullScreenChangeDelayTimerFired(Timer<FullscreenController>*)
 {
     // Since we dispatch events in this function, it's possible that the
     // document will be detached and GC'd. We protect it here to make sure we
     // can finish the function successfully.
     RefPtr<Document> protectDocument(document());
     Deque<RefPtr<Node> > changeQueue;
     m_fullScreenChangeEventTargetQueue.swap(changeQueue);
     Deque<RefPtr<Node> > errorQueue;
     m_fullScreenErrorEventTargetQueue.swap(errorQueue);
@@ skipping 55 matching lines @@
 void FullscreenController::clearFullscreenElementStack()
 {
     m_fullScreenElementStack.clear();
 }
 
 void FullscreenController::popFullscreenElementStack()
 {
     if (m_fullScreenElementStack.isEmpty())
         return;
 
+    document()->removeFromTopLayer(m_fullScreenElementStack.last().get());
     m_fullScreenElementStack.removeLast();
 }
 
 void FullscreenController::pushFullscreenElementStack(Element* element)
 {
+    document()->addToTopLayer(element);
     m_fullScreenElementStack.append(element);
 }
 
 void FullscreenController::addDocumentToFullScreenChangeEventQueue(Document* doc)
 {
     ASSERT(doc);
 
     Node* target = 0;
     if (FullscreenController* controller = fromIfExists(doc)) {
         target = controller->webkitFullscreenElement();
         if (!target)
             target = controller->webkitCurrentFullScreenElement();
     }
 
     if (!target)
         target = doc;
     m_fullScreenChangeEventTargetQueue.append(target);
 }
 
 } // namespace WebCore