Move willEnterFullscreen to WebRemoteFrame.

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 147 matching lines @@
 
 bool Fullscreen::isFullScreen(Document& document)
 {
     return currentFullScreenElementFrom(document);
 }
 
 Fullscreen::Fullscreen(Document& document)
     : ContextLifecycleObserver(&document)
     , m_fullScreenLayoutObject(nullptr)
     , m_eventQueueTimer(this, &Fullscreen::eventQueueTimerFired)
+    , m_forCrossProcessAncestor(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();
 
 }
 
-void Fullscreen::requestFullscreen(Element& element, RequestType requestType)
+void Fullscreen::requestFullscreen(Element& element, RequestType requestType, bool forCrossProcessAncestor)
 {
-    if (document()->isSecureContext()) {
-        UseCounter::count(document(), UseCounter::FullscreenSecureOrigin);
-    } else {
-        UseCounter::count(document(), UseCounter::FullscreenInsecureOrigin);
-        HostsUsingFeatures::countAnyWorld(*document(), HostsUsingFeatures::Feature::FullscreenInsecureHost);
+    // Use counters only need to be incremented in the process of the actual
+    // fullscreen element.
+    if (!forCrossProcessAncestor) {
+        if (document()->isSecureContext()) {
+            UseCounter::count(document(), UseCounter::FullscreenSecureOrigin);
+        } else {
+            UseCounter::count(document(), UseCounter::FullscreenInsecureOrigin);
+            HostsUsingFeatures::countAnyWorld(*document(), HostsUsingFeatures::Feature::FullscreenInsecureHost);
+        }
     }
 
     // Ignore this request if the document is not in a live frame.
     if (!document()->isActive())
         return;
 
     // If |element| is on top of |doc|'s fullscreen element stack, terminate these substeps.
     if (&element == fullscreenElement())
         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:
 
         // The fullscreen element ready check returns false.
         if (!fullscreenElementReady(element))
             break;
 
         // This algorithm is not allowed to show a pop-up:
         //   An algorithm is allowed to show a pop-up if, in the task in which the algorithm is running, either:
         //   - an activation behavior is currently being processed whose click event was trusted, or
         //   - the event listener for a trusted click event is being handled.
-        if (!UserGestureIndicator::utilizeUserGesture()) {
+        //
+        // If |forCrossProcessAncestor| is true, requestFullscreen was already
+        // called on an element in another process, and getting here means that
+        // it already passed the user gesture check.
+        if (!UserGestureIndicator::utilizeUserGesture() && !forCrossProcessAncestor) {
             String message = ExceptionMessages::failedToExecute("requestFullScreen",
                 "Element", "API can only be initiated by a user gesture.");
             document()->addConsoleMessage(
                 ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
             break;
         }
 
         // Fullscreen is not supported.
         if (!fullscreenIsSupported(element.document()))
             break;
@@ skipping 37 matching lines @@
                 // stack, and queue a task to fire an event named fullscreenchange with its bubbles attribute
                 // set to true on document.
                 from(*currentDoc).pushFullscreenElementStack(*followingDoc->localOwner(), requestType);
                 enqueueChangeEvent(*currentDoc, requestType);
                 continue;
             }
 
             // 4. Otherwise, do nothing for this document. It stays the same.
         } while (++current != docs.end());
 
+        m_forCrossProcessAncestor = forCrossProcessAncestor;
+
         // 5. Return, and run the remaining steps asynchronously.
         // 6. Optionally, perform some animation.
         document()->frameHost()->chromeClient().enterFullScreenForElement(&element);
 
         // 7. Optionally, display a message indicating how the user can exit displaying the context object fullscreen.
         return;
     } while (false);
 
     enqueueErrorEvent(element, requestType);
 }
@@ skipping 112 matching lines @@
 
 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, bool isAncestorOfFullscreenElement)
+void Fullscreen::didEnterFullScreenForElement(Element* element)
 {
     DCHECK(element);
     if (!document()->isActive())
         return;
 
     if (m_fullScreenLayoutObject)
         m_fullScreenLayoutObject->unwrapLayoutObject();
 
     m_fullScreenElement = 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();
     bool shouldCreatePlaceholder = layoutObject && layoutObject->isBox();
     if (shouldCreatePlaceholder) {
         m_savedPlaceholderFrameRect = toLayoutBox(layoutObject)->frameRect();
         m_savedPlaceholderComputedStyle = ComputedStyle::clone(layoutObject->styleRef());
     }
 
-    // TODO(alexmos): When |isAncestorOfFullscreenElement| is true, some of
+    // TODO(alexmos): When |m_forCrossProcessAncestor| 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())
         LayoutFullScreen::wrapLayoutObject(layoutObject, layoutObject ? layoutObject->parent() : 0, document());
 
-    if (isAncestorOfFullscreenElement) {
+    if (m_forCrossProcessAncestor) {
         DCHECK(m_fullScreenElement->isFrameOwnerElement());
         DCHECK(toHTMLFrameOwnerElement(m_fullScreenElement)->contentFrame()->isRemoteFrame());
         m_fullScreenElement->setContainsFullScreenElement(true);
     }
 
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
 
     document()->styleEngine().ensureFullscreenUAStyle();
     m_fullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
 
     // FIXME: This should not call updateStyleAndLayoutTree.
     document()->updateStyleAndLayoutTree();
 
     m_fullScreenElement->didBecomeFullscreenElement();
 
     if (document()->frame())
         document()->frame()->eventHandler().scheduleHoverStateUpdate();
 
     m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
-void Fullscreen::didExitFullScreenForElement(bool isAncestorOfFullscreenElement)
+void Fullscreen::didExitFullScreenForElement()
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->isActive())
         return;
 
     m_fullScreenElement->willStopBeingFullscreenElement();
 
-    if (isAncestorOfFullscreenElement)
+    if (m_forCrossProcessAncestor)
         m_fullScreenElement->setContainsFullScreenElement(false);
 
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
 
     if (m_fullScreenLayoutObject)
         LayoutFullScreenItem(m_fullScreenLayoutObject).unwrapLayoutObject();
 
     document()->styleEngine().ensureFullscreenUAStyle();
     m_fullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
     m_fullScreenElement = 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 = &document()->topDocument();
     DCHECK(exitingDocument);
     from(*exitingDocument).m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
+
+    m_forCrossProcessAncestor = false;
 }
 
 void Fullscreen::setFullScreenLayoutObject(LayoutFullScreen* layoutObject)
 {
     if (layoutObject == m_fullScreenLayoutObject)
         return;
 
     if (layoutObject && m_savedPlaceholderComputedStyle) {
         layoutObject->createPlaceholder(m_savedPlaceholderComputedStyle.release(), m_savedPlaceholderFrameRect);
     } else if (layoutObject && m_fullScreenLayoutObject && m_fullScreenLayoutObject->placeholder()) {
@@ skipping 106 matching lines @@
 DEFINE_TRACE(Fullscreen)
 {
     visitor->trace(m_fullScreenElement);
     visitor->trace(m_fullScreenElementStack);
     visitor->trace(m_eventQueue);
     Supplement<Document>::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink