Reflow comments in core/dom/.

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) 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.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 73 matching lines @@
       "requestFullscreen", "Element",
       "API can only be initiated by a user gesture.");
   document.addConsoleMessage(
       ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
 
   return false;
 }
 
 // https://fullscreen.spec.whatwg.org/#fullscreen-is-supported
 bool fullscreenIsSupported(const Document& document) {
-  // Fullscreen is supported if there is no previously-established user preference,
-  // security risk, or platform limitation.
+  // Fullscreen is supported if there is no previously-established user
+  // preference, security risk, or platform limitation.
   return !document.settings() || document.settings()->fullscreenSupported();
 }
 
 // https://fullscreen.spec.whatwg.org/#fullscreen-element-ready-check
 bool fullscreenElementReady(const Element& element) {
-  // A fullscreen element ready check for an element |element| returns true if all of the
-  // following are true, and false otherwise:
+  // A fullscreen element ready check for an element |element| returns true if
+  // all of the following are true, and false otherwise:
 
   // |element| is in a document.
   if (!element.isConnected())
     return false;
 
   // |element|'s node document is allowed to use the feature indicated by
   // attribute name allowfullscreen.
   if (!allowedToUseFullscreen(element.document().frame()))
     return false;
 
-  // |element|'s node document's fullscreen element stack is either empty or its top element is an
-  // inclusive ancestor of |element|.
+  // |element|'s node document's fullscreen element stack is either empty or its
+  // top element is an inclusive ancestor of |element|.
   if (const Element* topElement =
           Fullscreen::fullscreenElementFrom(element.document())) {
     if (!topElement->contains(&element))
       return false;
   }
 
-  // |element| has no ancestor element whose local name is iframe and namespace is the HTML
-  // namespace.
+  // |element| has no ancestor element whose local name is iframe and namespace
+  // is the HTML namespace.
   if (Traversal<HTMLIFrameElement>::firstAncestor(element))
     return false;
 
-  // |element|'s node document's browsing context either has a browsing context container and the
-  // fullscreen element ready check returns true for |element|'s node document's browsing
-  // context's browsing context container, or it has no browsing context container.
+  // |element|'s node document's browsing context either has a browsing context
+  // container and the fullscreen element ready check returns true for
+  // |element|'s node document's browsing context's browsing context container,
+  // or it has no browsing context container.
   if (const Element* owner = element.document().localOwner()) {
     if (!fullscreenElementReady(*owner))
       return false;
   }
 
   return true;
 }
 
 bool isPrefixed(const AtomicString& type) {
   return type == EventTypeNames::webkitfullscreenchange ||
@@ skipping 108 matching lines @@
       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| is on top of |doc|'s fullscreen element stack, terminate these
+  // substeps.
   if (&element == fullscreenElementFrom(document))
     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:
+    // 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(document))
       break;
 
     // This algorithm is not allowed to request fullscreen.
     // OOPIF: If |forCrossProcessDescendant| is true, requestFullscreen was
     // already called on a descendant element in another process, and
     // getting here means that it was already allowed to request fullscreen.
     if (!forCrossProcessDescendant && !allowedToRequestFullscreen(document))
       break;
 
     // 2. Let doc be element's node document. (i.e. "this")
 
-    // 3. Let docs be all doc's ancestor browsing context's documents (if any) and doc.
+    // 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(&document);
     for (Frame* frame = document.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.
+      // 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.
+      // 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);
         from(document).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,
+      // 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.
+        // ...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);
         from(document).enqueueChangeEvent(*currentDoc, requestType);
         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.
     document.frameHost()->chromeClient().enterFullscreenForElement(&element);
 
-    // 7. Optionally, display a message indicating how the user can exit displaying the context object fullscreen.
+    // 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
 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.
+  // 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|.
   exitFullscreen(doc);
 }
 
 // https://fullscreen.spec.whatwg.org/#exit-fullscreen
 void Fullscreen::exitFullscreen(Document& document) {
   // The exitFullscreen() method must run these steps:
 
   // 1. Let doc be the context object. (i.e. "this")
   if (!document.isActive())
     return;
 
   // 2. If doc's fullscreen element stack is empty, terminate these steps.
   if (!fullscreenElementFrom(document))
     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.
+  // 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() : nullptr;
        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.
+  // 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();
     from(document).enqueueChangeEvent(*descendant, requestType);
   }
 
   // 5. While doc is not null, run these substeps:
   Element* newTop = nullptr;
   for (Document* currentDoc = &document; currentDoc;) {
     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.
+    //    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.
+    // 2. Queue a task to fire an event named fullscreenchange with its bubbles
+    // attribute set to true on doc.
     from(document).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.
+    // 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();
@@ skipping 11 matching lines @@
   // 7. Optionally, perform some animation.
 
   FrameHost* host = document.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.
+  // 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(document);
     host->chromeClient().exitFullscreenForElement(
         currentFullScreenElement ? currentFullScreenElement
@@ skipping 17 matching lines @@
 void Fullscreen::didEnterFullscreenForElement(Element* element) {
   DCHECK(element);
   if (!document()->isActive())
     return;
 
   if (m_fullScreenLayoutObject)
     m_fullScreenLayoutObject->unwrapLayoutObject();
 
   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.
+  // 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 =
         ComputedStyle::clone(layoutObject->styleRef());
   }
 
   // TODO(alexmos): When |m_forCrossProcessDescendant| is true, some of
   // this layout work has already been done in another process, so it should
@@ skipping 50 matching lines @@
   if (m_fullScreenLayoutObject)
     LayoutFullScreenItem(m_fullScreenLayoutObject).unwrapLayoutObject();
 
   document()->styleEngine().ensureFullscreenUAStyle();
   m_currentFullScreenElement->pseudoStateChanged(CSSSelector::PseudoFullScreen);
   m_currentFullScreenElement = 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.
+  // 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_forCrossProcessDescendant = false;
 }
 
 void Fullscreen::setFullScreenLayoutObject(LayoutFullScreen* layoutObject) {
@@ skipping 31 matching lines @@
     DCHECK(document.hasFullscreenSupplement());
     Fullscreen& fullscreen = from(document);
     EventTarget* target = fullscreen.fullscreenElement();
     if (!target)
       target = fullscreen.currentFullScreenElement();
     if (!target)
       target = &document;
     event = createEvent(EventTypeNames::webkitfullscreenchange, *target);
   }
   m_eventQueue.append(event);
-  // NOTE: The timer is started in didEnterFullscreenForElement/didExitFullscreen.
+  // NOTE: The timer is started in
+  // didEnterFullscreenForElement/didExitFullscreen.
 }
 
 void Fullscreen::enqueueErrorEvent(Element& element, RequestType requestType) {
   Event* event;
   if (requestType == UnprefixedRequest)
     event = createEvent(EventTypeNames::fullscreenerror, element.document());
   else
     event = createEvent(EventTypeNames::webkitfullscreenerror, element);
   m_eventQueue.append(event);
   m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void Fullscreen::eventQueueTimerFired(TimerBase*) {
   HeapDeque<Member<Event>> eventQueue;
   m_eventQueue.swap(eventQueue);
 
   while (!eventQueue.isEmpty()) {
     Event* event = eventQueue.takeFirst();
     Node* target = event->target()->toNode();
 
-    // If the element was removed from our tree, also message the documentElement.
+    // If the element was removed from our tree, also message the
+    // documentElement.
     if (!target->isConnected() && document()->documentElement()) {
       DCHECK(isPrefixed(event->type()));
       eventQueue.append(
           createEvent(event->type(), *document()->documentElement()));
     }
 
     target->dispatchEvent(event);
   }
 }
 
 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:
+  // 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.
+  // 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(oldNode.document());
     return;
   }
 
-  // 2. Otherwise, remove |oldNode| from its node document's fullscreen element stack.
+  // 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;
     }
   }
 
   // NOTE: |oldNode| was not in the fullscreen element stack.
 }
 
@@ skipping 15 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