Make Fullscreen::requestFullscreen and exitFullscreen static

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 203 matching lines @@
 
     if (m_fullScreenLayoutObject)
         m_fullScreenLayoutObject->destroy();
 
     m_currentFullScreenElement = nullptr;
     m_fullscreenElementStack.clear();
 }
 
 void Fullscreen::requestFullscreen(Element& element, RequestType requestType, bool forCrossProcessDescendant)
 {
+    Document& doc = element.document();

[eae, 2016/09/08 19:28:38]

s/doc/document/

[foolip, 2016/09/08 20:00:57]

This was actually deliberate to match the comments from the spec, but the
current spec doesn't have that local variable, so I'll go back to document and
it'll look alright a few CLs later.

+
     // Use counters only need to be incremented in the process of the actual
     // fullscreen element.
     if (!forCrossProcessDescendant) {
-        if (document()->isSecureContext()) {
-            UseCounter::count(document(), UseCounter::FullscreenSecureOrigin);
+        if (doc.isSecureContext()) {
+            UseCounter::count(doc, UseCounter::FullscreenSecureOrigin);
         } else {
-            UseCounter::count(document(), UseCounter::FullscreenInsecureOrigin);
-            HostsUsingFeatures::countAnyWorld(*document(), HostsUsingFeatures::Feature::FullscreenInsecureHost);
+            UseCounter::count(doc, UseCounter::FullscreenInsecureOrigin);
+            HostsUsingFeatures::countAnyWorld(doc, HostsUsingFeatures::Feature::FullscreenInsecureHost);
         }
     }
 
     // Ignore this request if the document is not in a live frame.
-    if (!document()->isActive())
+    if (!doc.isActive())
         return;
 
     // If |element| is on top of |doc|'s fullscreen element stack, terminate these substeps.
-    if (&element == fullscreenElement())
+    if (&element == fullscreenElementFrom(doc))
         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;
 
         // Fullscreen is not supported.
-        if (!fullscreenIsSupported(element.document()))
+        if (!fullscreenIsSupported(doc))
             break;
 
         // This algorithm is not allowed to request fullscreen.
         // An algorithm is allowed to request fullscreen if one of the following
         // is true:
         //  - the algorithm is triggered by a user activation.
         //  - the algorithm is triggered by a user generated orientation change.
         //
         // 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() && !ScopedOrientationChangeIndicator::processingOrientationChange() && !forCrossProcessDescendant) {
             String message = ExceptionMessages::failedToExecute("requestFullscreen",
                 "Element", "API can only be initiated by a user gesture.");
-            document()->addConsoleMessage(
+            doc.addConsoleMessage(
                 ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
             break;
         }
 
         // 2. Let doc be element's node document. (i.e. "this")
-        Document* currentDoc = document();
 
         // 3. Let docs be all doc's ancestor browsing context's documents (if any) and doc.
         //
         // For OOPIF scenarios, |docs| will only contain documents for local
         // ancestors, and remote ancestors will be processed in their
         // respective processes.  This preserves the spec's event firing order
         // for local ancestors, but not for remote ancestors.  However, that
         // difference shouldn't be observable in practice: a fullscreenchange
         // event handler would need to postMessage a frame in another renderer
         // process, where the message should be queued up and processed after
         // the IPC that dispatches fullscreenchange.
         HeapDeque<Member<Document>> docs;
 
-        docs.prepend(currentDoc);
-        for (Frame* frame = currentDoc->frame()->tree().parent(); frame; frame = frame->tree().parent()) {
+        docs.prepend(&doc);
+        for (Frame* frame = doc.frame()->tree().parent(); frame; frame = frame->tree().parent()) {
             if (frame->isLocalFrame())
                 docs.prepend(toLocalFrame(frame)->document());
         }
 
         // 4. For each document in docs, run these substeps:
         HeapDeque<Member<Document>>::iterator current = docs.begin(), following = docs.begin();
 
         do {
             ++following;
 
             // 1. Let following document be the document after document in docs, or null if there is no
             // such document.
             Document* currentDoc = *current;
             Document* followingDoc = following != docs.end() ? *following : nullptr;
 
             // 2. If following document is null, push context object on document's fullscreen element
             // stack, and queue a task to fire an event named fullscreenchange with its bubbles attribute
             // set to true on the document.
             if (!followingDoc) {
                 from(*currentDoc).pushFullscreenElementStack(element, requestType);
-                enqueueChangeEvent(*currentDoc, requestType);
+                from(doc).enqueueChangeEvent(*currentDoc, requestType);
                 continue;
             }
 
             // 3. Otherwise, if document's fullscreen element stack is either empty or its top element
             // is not following document's browsing context container,
             Element* topElement = fullscreenElementFrom(*currentDoc);
             HTMLFrameOwnerElement* followingOwner = findContainerForDescendant(*currentDoc, *followingDoc);
             if (!topElement || topElement != followingOwner) {
                 // ...push following document's browsing context container on document's fullscreen element
                 // 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);
+                from(doc).enqueueChangeEvent(*currentDoc, requestType);
                 continue;
             }
 
             // 4. Otherwise, do nothing for this document. It stays the same.
         } while (++current != docs.end());
 
-        m_forCrossProcessDescendant = forCrossProcessDescendant;
+        from(doc).m_forCrossProcessDescendant = forCrossProcessDescendant;
 
         // 5. Return, and run the remaining steps asynchronously.
         // 6. Optionally, perform some animation.
-        document()->frameHost()->chromeClient().enterFullscreenForElement(&element);
+        doc.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);
+    from(doc).enqueueErrorEvent(element, requestType);
 }
 
 void Fullscreen::fullyExitFullscreen(Document& document)
 {
     // To fully exit fullscreen, run these steps:
 
     // 1. Let |doc| be the top-level browsing context's document.
     //
     // Since the top-level browsing context's document might be unavailable in
     // OOPIF scenarios (i.e., when the top frame is remote), this actually uses
     // the Document of the topmost local ancestor frame.  Without OOPIF, this
     // will be the top frame's document.  With OOPIF, each renderer process for
     // the current page will separately call fullyExitFullscreen to cover all
     // local frames in each process.
     Document& doc = topmostLocalAncestor(document);
 
     // 2. If |doc|'s fullscreen element stack is empty, terminate these steps.
     if (!fullscreenElementFrom(doc))
         return;
 
     // 3. Remove elements from |doc|'s fullscreen element stack until only the top element is left.
     size_t stackSize = from(doc).m_fullscreenElementStack.size();
     from(doc).m_fullscreenElementStack.remove(0, stackSize - 1);
     DCHECK_EQ(from(doc).m_fullscreenElementStack.size(), 1u);
 
     // 4. Act as if the exitFullscreen() method was invoked on |doc|.
-    from(doc).exitFullscreen();
+    exitFullscreen(doc);
 }
 
-void Fullscreen::exitFullscreen()
+void Fullscreen::exitFullscreen(Document& doc)
 {
     // The exitFullscreen() method must run these steps:
 
     // 1. Let doc be the context object. (i.e. "this")
-    Document* currentDoc = document();
-    if (!currentDoc->isActive())
+    if (!doc.isActive())
         return;
 
     // 2. If doc's fullscreen element stack is empty, terminate these steps.
-    if (m_fullscreenElementStack.isEmpty())
+    if (!fullscreenElementFrom(doc))
         return;
 
     // 3. Let descendants be all the doc's descendant browsing context's documents with a non-empty fullscreen
     // element stack (if any), ordered so that the child of the doc is last and the document furthest
     // away from the doc is first.
     HeapDeque<Member<Document>> descendants;
-    for (Frame* descendant = document()->frame() ? document()->frame()->tree().traverseNext() : 0; descendant; descendant = descendant->tree().traverseNext()) {
+    for (Frame* descendant = doc.frame() ? doc.frame()->tree().traverseNext() : 0; descendant; descendant = descendant->tree().traverseNext()) {
         if (!descendant->isLocalFrame())
             continue;
         DCHECK(toLocalFrame(descendant)->document());
         if (fullscreenElementFrom(*toLocalFrame(descendant)->document()))
             descendants.prepend(toLocalFrame(descendant)->document());
     }
 
     // 4. For each descendant in descendants, empty descendant's fullscreen element stack, and queue a
     // task to fire an event named fullscreenchange with its bubbles attribute set to true on descendant.
     for (auto& descendant : descendants) {
         DCHECK(descendant);
         RequestType requestType = from(*descendant).m_fullscreenElementStack.last().second;
         from(*descendant).clearFullscreenElementStack();
-        enqueueChangeEvent(*descendant, requestType);
+        from(doc).enqueueChangeEvent(*descendant, requestType);
     }
 
     // 5. While doc is not null, run these substeps:
     Element* newTop = 0;
+    Document* currentDoc = &doc;
     while (currentDoc) {

[eae, 2016/09/08 19:28:38]

currentDoc is never changed (other than to null) in the while loop. This smells
bad. How about using while(true) with a break statement instead?

[foolip, 2016/09/08 20:00:58]

currentDoc is never used after the loop, so I'll see about making it a for loop
to make that clear as well.

[foolip, 2016/09/08 22:19:01]

Oh wait, currentDoc actually is changed in the loop. I went with a for loop
still, that keeps it close to the comments. (This will all change soon anyway.)

         RequestType requestType = from(*currentDoc).m_fullscreenElementStack.last().second;
 
         // 1. Pop the top element of doc's fullscreen element stack.
         from(*currentDoc).popFullscreenElementStack();
 
         //    If doc's fullscreen element stack is non-empty and the element now at the top is either
         //    not in a document or its node document is not doc, repeat this substep.
         newTop = fullscreenElementFrom(*currentDoc);
         if (newTop && (!newTop->isConnected() || newTop->document() != currentDoc))
             continue;
 
         // 2. Queue a task to fire an event named fullscreenchange with its bubbles attribute set to true
         // on doc.
-        enqueueChangeEvent(*currentDoc, requestType);
+        from(doc).enqueueChangeEvent(*currentDoc, requestType);
 
         // 3. If doc's fullscreen element stack is empty and doc's browsing context has a browsing context
         // container, set doc to that browsing context container's node document.
         //
         // OOPIF: If browsing context container's document is in another
         // process, keep moving up the ancestor chain and looking for a
         // browsing context container with a local document.
         // TODO(alexmos): Deal with nested fullscreen cases, see
         // https://crbug.com/617369.
         if (!newTop) {
             Frame* frame = currentDoc->frame()->tree().parent();
             while (frame && frame->isRemoteFrame())
                 frame = frame->tree().parent();
             if (frame) {
                 currentDoc = toLocalFrame(frame)->document();
                 continue;
             }
         }
 
         // 4. Otherwise, set doc to null.
         currentDoc = 0;
     }
 
     // 6. Return, and run the remaining steps asynchronously.
     // 7. Optionally, perform some animation.
 
-    FrameHost* host = document()->frameHost();
+    FrameHost* host = doc.frameHost();
 
     // Speculative fix for engaget.com/videos per crbug.com/336239.
     // FIXME: This check is wrong. We DCHECK(document->isActive()) above
     // so this should be redundant and should be removed!
     if (!host)
         return;
 
     // Only exit out of full screen window mode if there are no remaining elements in the
     // full screen stack.
     if (!newTop) {
         // FIXME: if the frame exiting fullscreen is not the frame that entered
         // fullscreen (but a parent frame for example),
         // m_currentFullScreenElement might be null. We want to pass an element
         // that is part of the document so we will pass the documentElement in
         // that case. This should be fix by exiting fullscreen for a frame
         // instead of an element, see https://crbug.com/441259
+        Element* currentFullScreenElement = currentFullScreenElementFrom(doc);

[eae, 2016/09/08 19:28:38]

const?

[foolip, 2016/09/08 22:19:01]

ChromeClient::exitFullscreenForElement takes a non-const pointer, so that
doesn't compile. I think that's right, because it will eventually mutate some
state via Element::setContainsFullScreenElement and similar.

         host->chromeClient().exitFullscreenForElement(
-            m_currentFullScreenElement ? m_currentFullScreenElement.get() : document()->documentElement());
+            currentFullScreenElement ? currentFullScreenElement : doc.documentElement());
         return;
     }
 
     // Otherwise, notify the chrome of the new full screen element.
     host->chromeClient().enterFullscreenForElement(newTop);
 }
 
 bool Fullscreen::fullscreenEnabled(Document& document)
 {
     // 4. The fullscreenEnabled attribute must return true if the context object has its
@@ skipping 169 matching lines @@
 }
 
 void Fullscreen::elementRemoved(Element& oldNode)
 {
     // Whenever the removing steps run with an |oldNode| and |oldNode| is in its node document's
     // fullscreen element stack, run these steps:
 
     // 1. If |oldNode| is at the top of its node document's fullscreen element stack, act as if the
     //    exitFullscreen() method was invoked on that document.
     if (fullscreenElement() == &oldNode) {
-        exitFullscreen();
+        exitFullscreen(oldNode.document());
         return;
     }
 
     // 2. Otherwise, remove |oldNode| from its node document's fullscreen element stack.
     for (size_t i = 0; i < m_fullscreenElementStack.size(); ++i) {
         if (m_fullscreenElementStack[i].first.get() == &oldNode) {
             m_fullscreenElementStack.remove(i);
             return;
         }
     }
@@ skipping 22 matching lines @@
 DEFINE_TRACE(Fullscreen)
 {
     visitor->trace(m_currentFullScreenElement);
     visitor->trace(m_fullscreenElementStack);
     visitor->trace(m_eventQueue);
     Supplement<Document>::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 } // namespace blink