Rename FullscreenElementStack to just Fullscreen

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.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
-#include "core/dom/FullscreenElementStack.h"
+#include "core/dom/Fullscreen.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
 #include "core/events/Event.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLMediaElement.h"
@@ skipping 38 matching lines @@
 
 static PassRefPtrWillBeRawPtr<Event> createEvent(const AtomicString& type, EventTarget& target)
 {
     EventInit initializer;
     initializer.bubbles = isPrefixed(type);
     RefPtrWillBeRawPtr<Event> event = Event::create(type, initializer);
     event->setTarget(&target);
     return event;
 }
 
-const char* FullscreenElementStack::supplementName()
+const char* Fullscreen::supplementName()
 {
-    return "FullscreenElementStack";
+    return "Fullscreen";
 }
 
-FullscreenElementStack& FullscreenElementStack::from(Document& document)
+Fullscreen& Fullscreen::from(Document& document)
 {
-    FullscreenElementStack* fullscreen = fromIfExists(document);
+    Fullscreen* fullscreen = fromIfExists(document);
     if (!fullscreen) {
-        fullscreen = new FullscreenElementStack(document);
+        fullscreen = new Fullscreen(document);
         DocumentSupplement::provideTo(document, supplementName(), adoptPtrWillBeNoop(fullscreen));
     }
 
     return *fullscreen;
 }
 
-FullscreenElementStack* FullscreenElementStack::fromIfExistsSlow(Document& document)
+Fullscreen* Fullscreen::fromIfExistsSlow(Document& document)
 {
-    return static_cast<FullscreenElementStack*>(DocumentSupplement::from(document, supplementName()));
+    return static_cast<Fullscreen*>(DocumentSupplement::from(document, supplementName()));
 }
 
-Element* FullscreenElementStack::fullscreenElementFrom(Document& document)
+Element* Fullscreen::fullscreenElementFrom(Document& document)
 {
-    if (FullscreenElementStack* found = fromIfExists(document))
+    if (Fullscreen* found = fromIfExists(document))
         return found->fullscreenElement();
     return 0;
 }
 
-Element* FullscreenElementStack::currentFullScreenElementFrom(Document& document)
+Element* Fullscreen::currentFullScreenElementFrom(Document& document)
 {
-    if (FullscreenElementStack* found = fromIfExists(document))
+    if (Fullscreen* found = fromIfExists(document))
         return found->webkitCurrentFullScreenElement();
     return 0;
 }
 
-bool FullscreenElementStack::isFullScreen(Document& document)
+bool Fullscreen::isFullScreen(Document& document)
 {
-    if (FullscreenElementStack* found = fromIfExists(document))
+    if (Fullscreen* found = fromIfExists(document))
         return found->webkitIsFullScreen();
     return false;
 }
 
-FullscreenElementStack::FullscreenElementStack(Document& document)
+Fullscreen::Fullscreen(Document& document)
     : DocumentLifecycleObserver(&document)
     , m_areKeysEnabledInFullScreen(false)
     , m_fullScreenRenderer(nullptr)
-    , m_eventQueueTimer(this, &FullscreenElementStack::eventQueueTimerFired)
+    , m_eventQueueTimer(this, &Fullscreen::eventQueueTimerFired)
 {
-    document.setHasFullscreenElementStack();
+    document.setHasFullscreenSupplement();
 }
 
-FullscreenElementStack::~FullscreenElementStack()
+Fullscreen::~Fullscreen()
 {
 }
 
-inline Document* FullscreenElementStack::document()
+inline Document* Fullscreen::document()
 {
     return lifecycleContext();
 }
 
-void FullscreenElementStack::documentWasDetached()
+void Fullscreen::documentWasDetached()
 {
     m_eventQueue.clear();
 
     if (m_fullScreenRenderer)
         m_fullScreenRenderer->destroy();
 
 #if ENABLE(OILPAN)
     m_fullScreenElement = nullptr;
     m_fullScreenElementStack.clear();
 #endif
 
 }
 
 #if !ENABLE(OILPAN)
-void FullscreenElementStack::documentWasDisposed()
+void Fullscreen::documentWasDisposed()
 {
     // NOTE: the context dispose phase is not supported in oilpan. Please
     // consider using the detach phase instead.
     m_fullScreenElement = nullptr;
     m_fullScreenElementStack.clear();
 }
 #endif
 
-bool FullscreenElementStack::elementReady(Element& element, RequestType requestType)
+bool Fullscreen::elementReady(Element& element, RequestType requestType)
 {
     // A fullscreen element ready check for an element |element| returns true if all of the
     // following are true, and false otherwise:
 
     // |element| is in a document.
     if (!element.inDocument())
         return false;
 
     // |element|'s node document's fullscreen enabled flag is set.
     if (!fullscreenIsAllowedForAllOwners(element.document())) {
@@ skipping 11 matching lines @@
     }
 
     // |element| has no ancestor element whose local name is iframe and namespace is the HTML
     // namespace.
     if (Traversal<HTMLIFrameElement>::firstAncestor(element))
         return false;
 
     return true;
 }
 
-void FullscreenElementStack::requestFullscreen(Element& element, RequestType requestType)
+void Fullscreen::requestFullscreen(Element& element, RequestType requestType)
 {
     // Ignore this request if the document is not in a live frame.
     if (!document()->isActive())
         return;
 
     do {
         // 1. If any of the following conditions are true, terminate these steps and queue a task to fire
         // an event named fullscreenerror with its bubbles attribute set to true on the context object's
         // node document:
 
@@ skipping 63 matching lines @@
         m_areKeysEnabledInFullScreen = requestType != PrefixedMozillaRequest && requestType != PrefixedVideoRequest;
         document()->frameHost()->chrome().client().enterFullScreenForElement(&element);
 
         // 7. Optionally, display a message indicating how the user can exit displaying the context object fullscreen.
         return;
     } while (0);
 
     enqueueErrorEvent(element, requestType);
 }
 
-void FullscreenElementStack::fullyExitFullscreen()
+void Fullscreen::fullyExitFullscreen()
 {
     // "To fully exit fullscreen act as if the exitFullscreen() method was invoked on the top-level browsing
     // context's document and subsequently empty that document's fullscreen element stack."
     if (!fullscreenElementFrom(document()->topDocument()))
         return;
 
     // To achieve that aim, remove all the elements from the top document's stack except for the first before
     // calling exitFullscreen():
     WillBeHeapVector<std::pair<RefPtrWillBeMember<Element>, RequestType> > replacementFullscreenElementStack;
-    FullscreenElementStack& topFullscreenElementStack = from(document()->topDocument());
-    replacementFullscreenElementStack.append(topFullscreenElementStack.m_fullScreenElementStack.last());
-    topFullscreenElementStack.m_fullScreenElementStack.swap(replacementFullscreenElementStack);
-    topFullscreenElementStack.exitFullscreen();
+    Fullscreen& topFullscreen = from(document()->topDocument());
+    replacementFullscreenElementStack.append(topFullscreen.m_fullScreenElementStack.last());
+    topFullscreen.m_fullScreenElementStack.swap(replacementFullscreenElementStack);
+    topFullscreen.exitFullscreen();
 }
 
-void FullscreenElementStack::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())
@@ skipping 64 matching lines @@
     // full screen stack.
     if (!newTop) {
         host->chrome().client().exitFullScreenForElement(m_fullScreenElement.get());
         return;
     }
 
     // Otherwise, notify the chrome of the new full screen element.
     host->chrome().client().enterFullScreenForElement(newTop);
 }
 
-bool FullscreenElementStack::fullscreenEnabled(Document& document)
+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 FullscreenElementStack::willEnterFullScreenForElement(Element* element)
+void Fullscreen::willEnterFullScreenForElement(Element* element)
 {
     ASSERT(element);
     if (!document()->isActive())
         return;
 
     if (m_fullScreenRenderer)
         m_fullScreenRenderer->unwrapRenderer();
 
     m_fullScreenElement = element;
 
@@ skipping 11 matching lines @@
     if (m_fullScreenElement != document()->documentElement())
         RenderFullScreen::wrapRenderer(renderer, renderer ? renderer->parent() : 0, document());
 
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
 
     // FIXME: This should not call updateStyleIfNeeded.
     document()->setNeedsStyleRecalc(SubtreeStyleChange);
     document()->updateRenderTreeIfNeeded();
 }
 
-void FullscreenElementStack::didEnterFullScreenForElement(Element*)
+void Fullscreen::didEnterFullScreenForElement(Element*)
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->isActive())
         return;
 
     m_fullScreenElement->didBecomeFullscreenElement();
 
     m_eventQueueTimer.startOneShot(0, FROM_HERE);
 }
 
-void FullscreenElementStack::willExitFullScreenForElement(Element*)
+void Fullscreen::willExitFullScreenForElement(Element*)
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->isActive())
         return;
 
     m_fullScreenElement->willStopBeingFullscreenElement();
 }
 
-void FullscreenElementStack::didExitFullScreenForElement(Element*)
+void Fullscreen::didExitFullScreenForElement(Element*)
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->isActive())
         return;
 
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
 
     m_areKeysEnabledInFullScreen = false;
 
     if (m_fullScreenRenderer)
         m_fullScreenRenderer->unwrapRenderer();
 
     m_fullScreenElement = nullptr;
     document()->setNeedsStyleRecalc(SubtreeStyleChange);
 
     // 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 = &document()->topDocument();
     ASSERT(exitingDocument);
     from(*exitingDocument).m_eventQueueTimer.startOneShot(0, FROM_HERE);
 }
 
-void FullscreenElementStack::setFullScreenRenderer(RenderFullScreen* renderer)
+void Fullscreen::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->unwrapRenderer();
     ASSERT(!m_fullScreenRenderer);
 
     m_fullScreenRenderer = renderer;
 }
 
-void FullscreenElementStack::fullScreenRendererDestroyed()
+void Fullscreen::fullScreenRendererDestroyed()
 {
     m_fullScreenRenderer = nullptr;
 }
 
-void FullscreenElementStack::enqueueChangeEvent(Document& document, RequestType requestType)
+void Fullscreen::enqueueChangeEvent(Document& document, RequestType requestType)
 {
     RefPtrWillBeRawPtr<Event> event;
     if (requestType == UnprefixedRequest) {
         event = createEvent(EventTypeNames::fullscreenchange, document);
     } else {
-        ASSERT(document.hasFullscreenElementStack());
-        FullscreenElementStack& fullscreen = from(document);
+        ASSERT(document.hasFullscreenSupplement());
+        Fullscreen& fullscreen = from(document);
         EventTarget* target = fullscreen.fullscreenElement();
         if (!target)
             target = fullscreen.webkitCurrentFullScreenElement();
         if (!target)
             target = &document;
         event = createEvent(EventTypeNames::webkitfullscreenchange, *target);
     }
     m_eventQueue.append(event);
     // NOTE: The timer is started in didEnterFullScreenForElement/didExitFullScreenForElement.
 }
 
-void FullscreenElementStack::enqueueErrorEvent(Element& element, RequestType requestType)
+void Fullscreen::enqueueErrorEvent(Element& element, RequestType requestType)
 {
     RefPtrWillBeRawPtr<Event> event;
     if (requestType == UnprefixedRequest)
         event = createEvent(EventTypeNames::fullscreenerror, element.document());
     else
         event = createEvent(EventTypeNames::webkitfullscreenerror, element);
     m_eventQueue.append(event);
     m_eventQueueTimer.startOneShot(0, FROM_HERE);
 }
 
-void FullscreenElementStack::eventQueueTimerFired(Timer<FullscreenElementStack>*)
+void Fullscreen::eventQueueTimerFired(Timer<Fullscreen>*)
 {
     // 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.
     RefPtrWillBeRawPtr<Document> protectDocument(document());
     WillBeHeapDeque<RefPtrWillBeMember<Event> > eventQueue;
     m_eventQueue.swap(eventQueue);
 
     while (!eventQueue.isEmpty()) {
         RefPtrWillBeRawPtr<Event> event = eventQueue.takeFirst();
         Node* target = event->target()->toNode();
 
         // If the element was removed from our tree, also message the documentElement.
         if (!target->inDocument() && document()->documentElement()) {
             ASSERT(isPrefixed(event->type()));
             eventQueue.append(createEvent(event->type(), *document()->documentElement()));
         }
 
         target->dispatchEvent(event);
     }
 }
 
-void FullscreenElementStack::elementRemoved(Element& element)
+void Fullscreen::elementRemoved(Element& element)
 {
     // If an element |element| in a fullscreen element stack is removed from a document |document|,
     // run these steps:
 
     // 1. If |element| was at the top of |document|'s fullscreen element stack, act as if the
     // exitFullscreen() method was invoked on that document.
     if (fullscreenElement() == &element) {
         exitFullscreen();
         return;
     }
 
     // 2. Otherwise, remove |element| from |document|'s fullscreen element stack.
     for (size_t i = 0; i < m_fullScreenElementStack.size(); ++i) {
         if (m_fullScreenElementStack[i].first.get() == &element) {
             m_fullScreenElementStack.remove(i);
             return;
         }
     }
 
     // NOTE: |element| was not in the fullscreen element stack.
 }
 
-void FullscreenElementStack::clearFullscreenElementStack()
+void Fullscreen::clearFullscreenElementStack()
 {
     m_fullScreenElementStack.clear();
 }
 
-void FullscreenElementStack::popFullscreenElementStack()
+void Fullscreen::popFullscreenElementStack()
 {
     if (m_fullScreenElementStack.isEmpty())
         return;
 
     m_fullScreenElementStack.removeLast();
 }
 
-void FullscreenElementStack::pushFullscreenElementStack(Element& element, RequestType requestType)
+void Fullscreen::pushFullscreenElementStack(Element& element, RequestType requestType)
 {
     m_fullScreenElementStack.append(std::make_pair(&element, requestType));
 }
 
-void FullscreenElementStack::trace(Visitor* visitor)
+void Fullscreen::trace(Visitor* visitor)
 {
     visitor->trace(m_fullScreenElement);
     visitor->trace(m_fullScreenElementStack);
     visitor->trace(m_fullScreenRenderer);
     visitor->trace(m_eventQueue);
     DocumentSupplement::trace(visitor);
 }
 
 } // namespace blink