Convert FullscreenController to use WebCallbacks

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)
@@ skipping 14 matching lines @@
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "core/dom/Fullscreen.h"
 
 #include "bindings/core/v8/ConditionalFeatures.h"
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
+#include "core/dom/FullscreenCallbacks.h"
 #include "core/dom/StyleEngine.h"
 #include "core/events/Event.h"
 #include "core/frame/HostsUsingFeatures.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/LayoutBlockFlow.h"
@@ skipping 261 matching lines @@
 void Fullscreen::contextDestroyed() {
   m_eventQueue.clear();
 
   if (m_fullScreenLayoutObject)
     m_fullScreenLayoutObject->destroy();
 
   m_currentFullScreenElement = nullptr;
   m_fullscreenElementStack.clear();
 }
 
+// RequestFullscreenCallbacks hold the data for a pending request.
+// FullscreenController invokes the success or error callback.
+class RequestFullscreenCallbacks final : public FullscreenCallbacks {
+  USING_FAST_MALLOC(RequestFullscreenCallbacks);
+  WTF_MAKE_NONCOPYABLE(RequestFullscreenCallbacks);
+
+ public:
+  static std::unique_ptr<FullscreenCallbacks>
+  create(Document& document, Element& element, Fullscreen::RequestType type) {
+    return wrapUnique(new RequestFullscreenCallbacks(document, element, type));
+  }
+
+  void onSuccess() override {
+    Fullscreen::from(*m_document).didEnterFullscreen(*m_element);
+  }
+
+  void onError() override {
+    Fullscreen::from(*m_document).enqueueErrorEvent(*m_element, m_type);
+  }
+
+ private:
+  RequestFullscreenCallbacks(Document& document,
+                             Element& element,
+                             Fullscreen::RequestType type)
+      : m_document(document), m_element(element), m_type(type) {}
+  Persistent<Document> m_document;
+  Persistent<Element> m_element;
+  Fullscreen::RequestType m_type;
+};
+
 // https://fullscreen.spec.whatwg.org/#dom-element-requestfullscreen
 void Fullscreen::requestFullscreen(Element& element,
                                    RequestType requestType,
                                    bool forCrossProcessDescendant) {
   Document& document = element.document();
 
   // Use counters only need to be incremented in the process of the actual
   // fullscreen element.
   if (!forCrossProcessDescendant) {
     if (document.isSecureContext()) {
@@ skipping 99 matching lines @@
         continue;
       }
 
       // 4. Otherwise, do nothing for this document. It stays the same.
     } while (++current != docs.end());
 
     from(document).m_forCrossProcessDescendant = forCrossProcessDescendant;
 
     // 5. Return, and run the remaining steps asynchronously.
     // 6. Optionally, perform some animation.
-    from(document).m_pendingFullscreenElement = &element;
-    document.frame()->chromeClient().enterFullscreen(*document.frame());
+    document.frame()->chromeClient().enterFullscreen(
+        *document.frame(),
+        RequestFullscreenCallbacks::create(document, element, requestType));
 
     // 7. Optionally, display a message indicating how the user can exit
     // displaying the context object fullscreen.
     return;
   } while (false);
 
   from(document).enqueueErrorEvent(element, requestType);
 }
 
 // https://fullscreen.spec.whatwg.org/#fully-exit-fullscreen
@@ skipping 108 matching lines @@
   // 6. Return, and run the remaining steps asynchronously.
   // 7. Optionally, perform some animation.
 
   // Only exit fullscreen mode if the fullscreen element stack is empty.
   if (!newTop) {
     document.frame()->chromeClient().exitFullscreen(*document.frame());
     return;
   }
 
   // Otherwise, enter fullscreen for the fullscreen element stack's top element.
-  from(document).m_pendingFullscreenElement = newTop;
-  from(document).didEnterFullscreen();
+  from(document).didEnterFullscreen(*newTop);
 }
 
 // https://fullscreen.spec.whatwg.org/#dom-document-fullscreenenabled
 bool Fullscreen::fullscreenEnabled(Document& document) {
   // The fullscreenEnabled attribute's getter must return true if the context
   // object is allowed to use the feature indicated by attribute name
   // allowfullscreen and fullscreen is supported, and false otherwise.
   return allowedToUseFullscreen(document.frame()) &&
          fullscreenIsSupported(document);
 }
 
-void Fullscreen::didEnterFullscreen() {
-  if (!document()->isActive() || !document()->frame())
+void Fullscreen::didEnterFullscreen(Element& element) {
+  if (!document() || !document()->isActive() || !document()->frame())
     return;
 
   // Start the timer for events enqueued by |requestFullscreen()|. The hover
   // state update is scheduled first so that it's done when the events fire.
   document()->frame()->eventHandler().scheduleHoverStateUpdate();
   m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
 
-  Element* element = m_pendingFullscreenElement.release();
-  if (!element)
+  if (m_currentFullScreenElement == &element)
     return;
 
-  if (m_currentFullScreenElement == element)
-    return;
-
-  if (!element->isConnected() || &element->document() != document()) {
+  if (!element.isConnected() || &element.document() != document()) {
     // The element was removed or has moved to another document since the
     // |requestFullscreen()| call. Exit fullscreen again to recover.
     // TODO(foolip): Fire a fullscreenerror event. This is currently difficult
     // because the fullscreenchange event has already been enqueued and possibly
     // even fired. https://crbug.com/402376
     LocalFrame& frame = *document()->frame();
     frame.chromeClient().exitFullscreen(frame);
     return;
   }
 
+  if (m_currentFullScreenElement == &element)
+    return;
+
   if (m_fullScreenLayoutObject)
     m_fullScreenLayoutObject->unwrapLayoutObject();
 
   Element* previousElement = m_currentFullScreenElement;
-  m_currentFullScreenElement = 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_currentFullScreenElement->layoutObject();
   bool shouldCreatePlaceholder = layoutObject && layoutObject->isBox();
   if (shouldCreatePlaceholder) {
     m_savedPlaceholderFrameRect = toLayoutBox(layoutObject)->frameRect();
     m_savedPlaceholderComputedStyle =
@@ skipping 23 matching lines @@
   m_currentFullScreenElement
       ->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
 
   document()->styleEngine().ensureUAStyleForFullscreen();
   m_currentFullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
 
   // FIXME: This should not call updateStyleAndLayoutTree.
   document()->updateStyleAndLayoutTree();
 
   document()->frame()->chromeClient().fullscreenElementChanged(previousElement,
-                                                               element);
+                                                               &element);
 }
 
 void Fullscreen::didExitFullscreen() {
-  if (!document()->isActive() || !document()->frame())
+  if (!document() || !document()->isActive() || !document()->frame())
     return;
 
   // Start the timer for events enqueued by |exitFullscreen()|. The hover state
   // update is scheduled first so that it's done when the events fire.
   document()->frame()->eventHandler().scheduleHoverStateUpdate();
   m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
 
   // If fullscreen was canceled by the browser, e.g. if the user pressed Esc,
   // then |exitFullscreen()| was never called. Let |fullyExitFullscreen()| clear
   // the fullscreen element stack and fire any events as necessary.
@@ skipping 132 matching lines @@
 
   m_fullscreenElementStack.pop_back();
 }
 
 void Fullscreen::pushFullscreenElementStack(Element& element,
                                             RequestType requestType) {
   m_fullscreenElementStack.append(std::make_pair(&element, requestType));
 }
 
 DEFINE_TRACE(Fullscreen) {
-  visitor->trace(m_pendingFullscreenElement);
   visitor->trace(m_fullscreenElementStack);
   visitor->trace(m_currentFullScreenElement);
   visitor->trace(m_eventQueue);
   Supplement<Document>::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
 }
 
 }  // namespace blink