Clarify fullscreenElement vs. currentFullScreenElement distinction

third_party/WebKit/Source/core/dom/Fullscreen.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 162 matching lines @@
 
 Fullscreen* Fullscreen::fromIfExistsSlow(Document& document)
 {
     return static_cast<Fullscreen*>(Supplement<Document>::from(document, supplementName()));
 }
 
 Element* Fullscreen::fullscreenElementFrom(Document& document)
 {
     if (Fullscreen* found = fromIfExists(document))
         return found->fullscreenElement();
-    return 0;
+    return nullptr;
 }
 
 Element* Fullscreen::currentFullScreenElementFrom(Document& document)
 {
     if (Fullscreen* found = fromIfExists(document))
-        return found->webkitCurrentFullScreenElement();
-    return 0;
-}
-
-bool Fullscreen::isFullScreen(Document& document)
-{
-    return currentFullScreenElementFrom(document);
+        return found->currentFullScreenElement();
+    return nullptr;
 }
 
 Fullscreen::Fullscreen(Document& document)
     : ContextLifecycleObserver(&document)
     , m_fullScreenLayoutObject(nullptr)
     , m_eventQueueTimer(this, &Fullscreen::eventQueueTimerFired)
     , m_forCrossProcessDescendant(false)
 {
     document.setHasFullscreenSupplement();
 }
 
 Fullscreen::~Fullscreen()
 {
 }
 
 inline Document* Fullscreen::document()
 {
     return toDocument(lifecycleContext());
 }
 
 void Fullscreen::contextDestroyed()
 {
     m_eventQueue.clear();
 
     if (m_fullScreenLayoutObject)
         m_fullScreenLayoutObject->destroy();
 
-    m_fullScreenElement = nullptr;
-    m_fullScreenElementStack.clear();
-
+    m_currentFullScreenElement = nullptr;
+    m_fullscreenElementStack.clear();
 }
 
 void Fullscreen::requestFullscreen(Element& element, RequestType requestType, bool forCrossProcessDescendant)
 {
     // Use counters only need to be incremented in the process of the actual
     // fullscreen element.
     if (!forCrossProcessDescendant) {
         if (document()->isSecureContext()) {
             UseCounter::count(document(), UseCounter::FullscreenSecureOrigin);
         } else {
@@ skipping 122 matching lines @@
     // will be the top frame's document.  With OOPIF, each renderer process for
     // the current page will separately call fullyExitFullscreen to cover all
     // local frames in each process.
     Document& doc = topmostLocalAncestor(document);
 
     // 2. If |doc|'s fullscreen element stack is empty, terminate these steps.
     if (!fullscreenElementFrom(doc))
         return;
 
     // 3. Remove elements from |doc|'s fullscreen element stack until only the top element is left.
-    size_t stackSize = from(doc).m_fullScreenElementStack.size();
-    from(doc).m_fullScreenElementStack.remove(0, stackSize - 1);
-    DCHECK_EQ(from(doc).m_fullScreenElementStack.size(), 1u);
+    size_t stackSize = from(doc).m_fullscreenElementStack.size();
+    from(doc).m_fullscreenElementStack.remove(0, stackSize - 1);
+    DCHECK_EQ(from(doc).m_fullscreenElementStack.size(), 1u);
 
     // 4. Act as if the exitFullscreen() method was invoked on |doc|.
     from(doc).exitFullscreen();
 }
 
 void Fullscreen::exitFullscreen()
 {
     // The exitFullscreen() method must run these steps:
 
     // 1. Let doc be the context object. (i.e. "this")
     Document* currentDoc = document();
     if (!currentDoc->isActive())
         return;
 
     // 2. If doc's fullscreen element stack is empty, terminate these steps.
-    if (m_fullScreenElementStack.isEmpty())
+    if (m_fullscreenElementStack.isEmpty())
         return;
 
     // 3. Let descendants be all the doc's descendant browsing context's documents with a non-empty fullscreen
     // element stack (if any), ordered so that the child of the doc is last and the document furthest
     // away from the doc is first.
     HeapDeque<Member<Document>> descendants;
     for (Frame* descendant = document()->frame() ? document()->frame()->tree().traverseNext() : 0; descendant; descendant = descendant->tree().traverseNext()) {
         if (!descendant->isLocalFrame())
             continue;
         DCHECK(toLocalFrame(descendant)->document());
         if (fullscreenElementFrom(*toLocalFrame(descendant)->document()))
             descendants.prepend(toLocalFrame(descendant)->document());
     }
 
     // 4. For each descendant in descendants, empty descendant's fullscreen element stack, and queue a
     // task to fire an event named fullscreenchange with its bubbles attribute set to true on descendant.
     for (auto& descendant : descendants) {
         DCHECK(descendant);
-        RequestType requestType = from(*descendant).m_fullScreenElementStack.last().second;
+        RequestType requestType = from(*descendant).m_fullscreenElementStack.last().second;
         from(*descendant).clearFullscreenElementStack();
         enqueueChangeEvent(*descendant, requestType);
     }
 
     // 5. While doc is not null, run these substeps:
     Element* newTop = 0;
     while (currentDoc) {
-        RequestType requestType = from(*currentDoc).m_fullScreenElementStack.last().second;
+        RequestType requestType = from(*currentDoc).m_fullscreenElementStack.last().second;
 
         // 1. Pop the top element of doc's fullscreen element stack.
         from(*currentDoc).popFullscreenElementStack();
 
         //    If doc's fullscreen element stack is non-empty and the element now at the top is either
         //    not in a document or its node document is not doc, repeat this substep.
         newTop = fullscreenElementFrom(*currentDoc);
         if (newTop && (!newTop->isConnected() || newTop->document() != currentDoc))
             continue;
 
@@ skipping 31 matching lines @@
     // Speculative fix for engaget.com/videos per crbug.com/336239.
     // FIXME: This check is wrong. We DCHECK(document->isActive()) above
     // so this should be redundant and should be removed!
     if (!host)
         return;
 
     // Only exit out of full screen window mode if there are no remaining elements in the
     // full screen stack.
     if (!newTop) {
         // FIXME: if the frame exiting fullscreen is not the frame that entered
-        // fullscreen (but a parent frame for example), m_fullScreenElement
-        // might be null. We want to pass an element that is part of the
-        // document so we will pass the documentElement in that case.
-        // This should be fix by exiting fullscreen for a frame instead of an
-        // element, see https://crbug.com/441259
+        // fullscreen (but a parent frame for example),
+        // m_currentFullScreenElement might be null. We want to pass an element
+        // that is part of the document so we will pass the documentElement in
+        // that case. This should be fix by exiting fullscreen for a frame
+        // instead of an element, see https://crbug.com/441259
         host->chromeClient().exitFullScreenForElement(
-            m_fullScreenElement ? m_fullScreenElement.get() : document()->documentElement());
+            m_currentFullScreenElement ? m_currentFullScreenElement.get() : document()->documentElement());
         return;
     }
 
     // Otherwise, notify the chrome of the new full screen element.
     host->chromeClient().enterFullScreenForElement(newTop);
 }
 
 bool Fullscreen::fullscreenEnabled(Document& document)
 {
     // 4. The fullscreenEnabled attribute must return true if the context object has its
     //    fullscreen enabled flag set and fullscreen is supported, and false otherwise.
 
     // Top-level browsing contexts are implied to have their allowFullScreen attribute set.
     return fullscreenIsAllowedForAllOwners(document) && fullscreenIsSupported(document);
 }
 
 void Fullscreen::didEnterFullscreenForElement(Element* element)
 {
     DCHECK(element);
     if (!document()->isActive())
         return;
 
     if (m_fullScreenLayoutObject)
         m_fullScreenLayoutObject->unwrapLayoutObject();
 
-    m_fullScreenElement = element;
+    m_currentFullScreenElement = element;
 
     // 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 LayoutBox, as only
     // a box will have a frameRect. The placeholder will be created in setFullScreenLayoutObject()
     // during layout.
-    LayoutObject* layoutObject = m_fullScreenElement->layoutObject();
+    LayoutObject* layoutObject = m_currentFullScreenElement->layoutObject();
     bool shouldCreatePlaceholder = layoutObject && layoutObject->isBox();
     if (shouldCreatePlaceholder) {
         m_savedPlaceholderFrameRect = toLayoutBox(layoutObject)->frameRect();
         m_savedPlaceholderComputedStyle = ComputedStyle::clone(layoutObject->styleRef());
     }
 
     // TODO(alexmos): When |m_forCrossProcessDescendant| is true, some of
     // this layout work has already been done in another process, so it should
     // not be necessary to repeat it here.
-    if (m_fullScreenElement != document()->documentElement())
+    if (m_currentFullScreenElement != document()->documentElement())
         LayoutFullScreen::wrapLayoutObject(layoutObject, layoutObject ? layoutObject->parent() : 0, document());
 
-    // When |m_forCrossProcessDescendant| is true, m_fullScreenElement
+    // When |m_forCrossProcessDescendant| is true, m_currentFullScreenElement
     // corresponds to the HTMLFrameOwnerElement for the out-of-process iframe
     // that contains the actual fullscreen element.   Hence, it must also set
     // the ContainsFullScreenElement flag (so that it gains the
     // -webkit-full-screen-ancestor style).
     if (m_forCrossProcessDescendant) {
-        DCHECK(m_fullScreenElement->isFrameOwnerElement());
-        DCHECK(toHTMLFrameOwnerElement(m_fullScreenElement)->contentFrame()->isRemoteFrame());
-        m_fullScreenElement->setContainsFullScreenElement(true);
+        DCHECK(m_currentFullScreenElement->isFrameOwnerElement());
+        DCHECK(toHTMLFrameOwnerElement(m_currentFullScreenElement)->contentFrame()->isRemoteFrame());
+        m_currentFullScreenElement->setContainsFullScreenElement(true);
     }
 
-    m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
+    m_currentFullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
 
     document()->styleEngine().ensureFullscreenUAStyle();
-    m_fullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
+    m_currentFullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
 
     // FIXME: This should not call updateStyleAndLayoutTree.
     document()->updateStyleAndLayoutTree();
 
-    m_fullScreenElement->didBecomeFullscreenElement();
+    m_currentFullScreenElement->didBecomeFullscreenElement();
 
     if (document()->frame())
         document()->frame()->eventHandler().scheduleHoverStateUpdate();
 
     m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void Fullscreen::didExitFullscreen()
 {
-    if (!m_fullScreenElement)
+    if (!m_currentFullScreenElement)
         return;
 
     if (!document()->isActive())
         return;
 
-    m_fullScreenElement->willStopBeingFullscreenElement();
+    m_currentFullScreenElement->willStopBeingFullscreenElement();
 
     if (m_forCrossProcessDescendant)
-        m_fullScreenElement->setContainsFullScreenElement(false);
+        m_currentFullScreenElement->setContainsFullScreenElement(false);
 
-    m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
+    m_currentFullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
 
     if (m_fullScreenLayoutObject)
         LayoutFullScreenItem(m_fullScreenLayoutObject).unwrapLayoutObject();
 
     document()->styleEngine().ensureFullscreenUAStyle();
-    m_fullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
-    m_fullScreenElement = nullptr;
+    m_currentFullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
+    m_currentFullScreenElement = nullptr;
 
     if (document()->frame())
         document()->frame()->eventHandler().scheduleHoverStateUpdate();
 
     // When fullyExitFullscreen is called, we call exitFullscreen 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_eventQueue.isEmpty())
         exitingDocument = &topmostLocalAncestor(*document());
@@ skipping 30 matching lines @@
 void Fullscreen::enqueueChangeEvent(Document& document, RequestType requestType)
 {
     Event* event;
     if (requestType == UnprefixedRequest) {
         event = createEvent(EventTypeNames::fullscreenchange, document);
     } else {
         DCHECK(document.hasFullscreenSupplement());
         Fullscreen& fullscreen = from(document);
         EventTarget* target = fullscreen.fullscreenElement();
         if (!target)
-            target = fullscreen.webkitCurrentFullScreenElement();
+            target = fullscreen.currentFullScreenElement();
         if (!target)
             target = &document;
         event = createEvent(EventTypeNames::webkitfullscreenchange, *target);
     }
     m_eventQueue.append(event);
     // NOTE: The timer is started in didEnterFullscreenForElement/didExitFullscreen.
 }
 
 void Fullscreen::enqueueErrorEvent(Element& element, RequestType requestType)
 {
@@ skipping 31 matching lines @@
     // fullscreen element stack, run these steps:
 
     // 1. If |oldNode| is at the top of its node document's fullscreen element stack, act as if the
     //    exitFullscreen() method was invoked on that document.
     if (fullscreenElement() == &oldNode) {
         exitFullscreen();
         return;
     }
 
     // 2. Otherwise, remove |oldNode| from its node document's fullscreen element stack.
-    for (size_t i = 0; i < m_fullScreenElementStack.size(); ++i) {
-        if (m_fullScreenElementStack[i].first.get() == &oldNode) {
-            m_fullScreenElementStack.remove(i);
+    for (size_t i = 0; i < m_fullscreenElementStack.size(); ++i) {
+        if (m_fullscreenElementStack[i].first.get() == &oldNode) {
+            m_fullscreenElementStack.remove(i);
             return;
         }
     }
 
     // NOTE: |oldNode| was not in the fullscreen element stack.
 }
 
 void Fullscreen::clearFullscreenElementStack()
 {
-    m_fullScreenElementStack.clear();
+    m_fullscreenElementStack.clear();
 }
 
 void Fullscreen::popFullscreenElementStack()
 {
-    if (m_fullScreenElementStack.isEmpty())
+    if (m_fullscreenElementStack.isEmpty())
         return;
 
-    m_fullScreenElementStack.removeLast();
+    m_fullscreenElementStack.removeLast();
 }
 
 void Fullscreen::pushFullscreenElementStack(Element& element, RequestType requestType)
 {
-    m_fullScreenElementStack.append(std::make_pair(&element, requestType));
+    m_fullscreenElementStack.append(std::make_pair(&element, requestType));
 }
 
 DEFINE_TRACE(Fullscreen)
 {
-    visitor->trace(m_fullScreenElement);
-    visitor->trace(m_fullScreenElementStack);
+    visitor->trace(m_currentFullScreenElement);
+    visitor->trace(m_fullscreenElementStack);
     visitor->trace(m_eventQueue);
     Supplement<Document>::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink