Convert FullscreenController to use WebCallbacks

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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "web/FullscreenController.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/FullscreenCallbacks.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/PageScaleConstraintsSet.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/layout/LayoutFullScreen.h"
 #include "public/platform/WebLayerTreeView.h"
 #include "public/web/WebFrameClient.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 
@@ skipping 26 matching lines @@
     return;
 
   updatePageScaleConstraints(false);
   m_webViewImpl->setPageScaleFactor(1.0f);
   if (m_webViewImpl->mainFrame()->isWebLocalFrame())
     m_webViewImpl->mainFrame()->setScrollOffset(WebSize());
   m_webViewImpl->setVisualViewportOffset(FloatPoint());
 
   m_state = State::Fullscreen;
 
-  // Notify all local frames that we have entered fullscreen.
-  for (Frame* frame = m_webViewImpl->page()->mainFrame(); frame;
-       frame = frame->tree().traverseNext()) {
-    if (!frame->isLocalFrame())
-      continue;
-    if (Document* document = toLocalFrame(frame)->document()) {
-      if (Fullscreen* fullscreen = Fullscreen::fromIfExists(*document))
-        fullscreen->didEnterFullscreen();
-    }
-  }
+  DCHECK(!m_callbacksList.isEmpty());
+  CallbacksList callbacksList;
+  callbacksList.swap(m_callbacksList);
+  for (auto& callbacks : callbacksList)
+    callbacks->onSuccess();
 }
 
 void FullscreenController::didExitFullscreen() {
   // The browser process can exit fullscreen at any time, e.g. if the user
   // presses Esc. After |Browser::EnterFullscreenModeForTab()|,
   // |Browser::ExitFullscreenModeForTab()| will make it seem like we exit when
   // not even in fullscreen. Do nothing.
   if (m_state == State::Initial)
     return;
 
   updatePageScaleConstraints(true);
 
   // Set |m_state| so that any |exitFullscreen()| calls from within
   // |Fullscreen::didExitFullscreen()| do not call
   // |WebFrameClient::exitFullscreen()| again.
   // TODO(foolip): Remove this when state changes and events are synchronized
   // with animation frames. https://crbug.com/402376
   m_state = State::ExitingFullscreen;
 
+  // If we were transitioning into fullscreen, invoke the error callbacks.
+  if (m_state == State::EnteringFullscreen) {
+    DCHECK(!m_callbacksList.isEmpty());
+    CallbacksList callbacksList;
+    callbacksList.swap(m_callbacksList);
+    for (auto& callbacks : callbacksList)
+      callbacks->onError();
+  } else {
+    DCHECK(m_callbacksList.isEmpty());
+  }
+
   // Notify all local frames that we have exited fullscreen.
   // TODO(foolip): This should only need to notify the topmost local roots. That
   // doesn't currently work because |Fullscreen::m_currentFullScreenElement|
   // isn't set for the topmost document when an iframe goes fullscreen, but can
   // be done once |m_currentFullScreenElement| is gone and all state is in the
   // fullscreen element stack. https://crbug.com/402421
   for (Frame* frame = m_webViewImpl->page()->mainFrame(); frame;
        frame = frame->tree().traverseNext()) {
     if (!frame->isLocalFrame())
       continue;
     if (Document* document = toLocalFrame(frame)->document()) {
       if (Fullscreen* fullscreen = Fullscreen::fromIfExists(*document))
         fullscreen->didExitFullscreen();
     }
   }
 
   // We need to wait until style and layout are updated in order to properly
   // restore scroll offsets since content may not be overflowing in the same way
   // until they are.
   m_state = State::NeedsScrollAndScaleRestore;
 }
 
-void FullscreenController::enterFullscreen(LocalFrame& frame) {
-  // If already fullscreen or exiting fullscreen, synchronously call
-  // |didEnterFullscreen()|. When exiting, the coming |didExitFullscren()| call
-  // will again notify all frames.
+void FullscreenController::enterFullscreen(
+    LocalFrame& frame,
+    std::unique_ptr<FullscreenCallbacks> callbacks) {
+  // If already fullscreen or exiting fullscreen, synchronously invoke the
+  // success callback. When exiting, the coming |didExitFullscren()| call will
+  // again notify all frames.
   if (m_state == State::Fullscreen || m_state == State::ExitingFullscreen) {
     State oldState = m_state;
     m_state = State::EnteringFullscreen;
-    didEnterFullscreen();
+    callbacks->onSuccess();
     m_state = oldState;
     return;
   }
 
   // We need to store these values here rather than in |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_state == State::Initial) {
     m_initialPageScaleFactor = m_webViewImpl->pageScaleFactor();
     m_initialScrollOffset = m_webViewImpl->mainFrame()->isWebLocalFrame()
                                 ? m_webViewImpl->mainFrame()->getScrollOffset()
                                 : WebSize();
     m_initialVisualViewportOffset = m_webViewImpl->visualViewportOffset();
   }
 
+  m_callbacksList.append(std::move(callbacks));
+
   // If already entering fullscreen, just wait.
   if (m_state == State::EnteringFullscreen)
     return;
 
   DCHECK(m_state == State::Initial ||
          m_state == State::NeedsScrollAndScaleRestore);
   webFrameClient(frame).enterFullscreen();
 
   m_state = State::EnteringFullscreen;
 }
@@ skipping 100 matching lines @@
   // again to ensure the final constraints pick up the latest contents size.
   m_webViewImpl->didChangeContentsSize();
   if (m_webViewImpl->mainFrameImpl() &&
       m_webViewImpl->mainFrameImpl()->frameView())
     m_webViewImpl->mainFrameImpl()->frameView()->setNeedsLayout();
 
   m_webViewImpl->updateMainFrameLayoutSize();
 }
 
 }  // namespace blink