Clean up some OOPIF-related naming and comments in Fullscreen.

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 180 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)
+    , 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();
 
 }
 
-void Fullscreen::requestFullscreen(Element& element, RequestType requestType, bool forCrossProcessAncestor)
+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 (!forCrossProcessAncestor) {
+    if (!forCrossProcessDescendant) {
         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())
@@ skipping 10 matching lines @@
 
         // 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 |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) {
+        // If |forCrossProcessDescendant| is true, requestFullscreen
+        // was already called on a descendant element in another process, and
+        // getting here means that it already passed the user gesture check.
+        if (!UserGestureIndicator::utilizeUserGesture() && !forCrossProcessDescendant) {
             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 48 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(*followingOwner, requestType);
                 enqueueChangeEvent(*currentDoc, requestType);
                 continue;
             }
 
             // 4. Otherwise, do nothing for this document. It stays the same.
         } while (++current != docs.end());
 
-        m_forCrossProcessAncestor = forCrossProcessAncestor;
+        m_forCrossProcessDescendant = forCrossProcessDescendant;
 
         // 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 153 matching lines @@
     // 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 |m_forCrossProcessAncestor| is true, some of
+    // TODO(alexmos): When |m_forCrossProcessDescendant| is true, some of

[foolip, 2016/07/13 08:58:14]

I actually think this comment is wrong, the fullscreen element in each document
needs to get the same treatment. I may be missing something, but it doesn't
matter much, because this would go away with the top layer rewrite.

[alexmos, 2016/07/13 17:52:18]

The thinking behind the comment was that when all frames are in the same
process, the LayoutFullScreen::wrapLayoutObject happens only once in the deepest
document, but with OOPIFs, it currently happens once for the deepest document in
each process.  I thought doing it in the other (ancestor) processes isn't really
necessary (though it doesn't hurt), as these other ancestors are just stretching
the inner fullscreened iframe to fill up their entire viewport (via
setContainsFullScreenElement and iframe:-webkit-full-screen) -- I actually had a
prototype working where I skipped doing it, and things still seemed to work
afaict.  Maybe there are other gotchas with this that I wasn't aware of.  But
you're right that at this point it doesn't matter, as this will go away with top
layer, so it's probably not worth spending time to finish that CL.

     // 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 (m_forCrossProcessAncestor) {
+    // When |m_forCrossProcessDescendant| is true, m_fullScreenElement
+    // corresponds to the HTMLFrameOwnerElement for the out-of-process iframe
+    // that contains the actual fullscreen element.   Hence, it must also set

[foolip, 2016/07/13 08:58:14]

I'm really looking forward to getting rid of :-webkit-full-screen-ancestor :)

[alexmos, 2016/07/13 17:52:18]

That sounds great. :)  I guess that's because it isn't part of the spec anymore?
 Do we have/need counters that existing web content isn't relying on it?  I see
that Mozilla just did this too, which is exciting:
https://www.fxsitecompat.com/en-CA/docs/2016/moz-full-screen-ancestor-has-bee...

[foolip, 2016/07/13 21:40:30]

It was completely necessary before in order to get the ancestor elements out of
the way, but now the ancestor elements won't be ancestor layout objects so there
won't be much useful you can do with :-webkit-full-screen-ancestor. The use
counter is https://www.chromestatus.com/metrics/feature/timeline/popularity/628
but I don't think that's a good predictor of risk, I'd have to search
httparchive before attempting a removal.

The last remaining thing that depends on it is to remove scrollbars, but I think
that could be done without the selector.

+    // 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);
     }
 
     m_fullScreenElement->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
 
     document()->styleEngine().ensureFullscreenUAStyle();
     m_fullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
 
@@ skipping 11 matching lines @@
 void Fullscreen::didExitFullScreenForElement()
 {
     if (!m_fullScreenElement)
         return;
 
     if (!document()->isActive())
         return;
 
     m_fullScreenElement->willStopBeingFullscreenElement();
 
-    if (m_forCrossProcessAncestor)
+    if (m_forCrossProcessDescendant)
         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 = &topmostLocalAncestor(*document());
     DCHECK(exitingDocument);
     from(*exitingDocument).m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
 
-    m_forCrossProcessAncestor = false;
+    m_forCrossProcessDescendant = 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