Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/ContainerNode.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 59 matching lines @@
     fragment.removeChildren();
     return;
   }
   nodes.append(&node);
   if (ContainerNode* oldParent = node.parentNode())
     oldParent->removeChild(&node, exceptionState);
 }
 
 void ContainerNode::parserTakeAllChildrenFrom(ContainerNode& oldParent) {
   while (Node* child = oldParent.firstChild()) {
-    // Explicitly remove since appending can fail, but this loop shouldn't be infinite.
+    // Explicitly remove since appending can fail, but this loop shouldn't be
+    // infinite.
     oldParent.parserRemoveChild(*child);
     parserAppendChild(child);
   }
 }
 
 ContainerNode::~ContainerNode() {
   DCHECK(needsAttach());
 }
 
 DISABLE_CFI_PERF
@@ skipping 32 matching lines @@
       isElementNode()) {
     DCHECK(isChildTypeAllowed(*newChild));
     if (containsConsideringHostElements(*newChild)) {
       exceptionState.throwDOMException(
           HierarchyRequestError, "The new child element contains the parent.");
       return false;
     }
     return true;
   }
 
-  // This should never happen, but also protect release builds from tree corruption.
+  // This should never happen, but also protect release builds from tree
+  // corruption.
   DCHECK(!newChild->isPseudoElement());
   if (newChild->isPseudoElement()) {
     exceptionState.throwDOMException(
         HierarchyRequestError, "The new child element is a pseudo-element.");
     return false;
   }
 
   return checkAcceptChildGuaranteedNodeTypes(*newChild, oldChild,
                                              exceptionState);
 }
@@ skipping 144 matching lines @@
   ChildListMutationScope mutation(*this);
   insertNodeVector(targets, refChild, AdoptAndInsertBefore());
   return newChild;
 }
 
 void ContainerNode::insertBeforeCommon(Node& nextChild, Node& newChild) {
 #if DCHECK_IS_ON()
   DCHECK(EventDispatchForbiddenScope::isEventDispatchForbidden());
 #endif
   DCHECK(ScriptForbiddenScope::isScriptForbidden());
-  DCHECK(
-      !newChild
-           .parentNode());  // Use insertBefore if you need to handle reparenting (and want DOM mutation events).
+  // Use insertBefore if you need to handle reparenting (and want DOM mutation
+  // events).
+  DCHECK(!newChild.parentNode());
   DCHECK(!newChild.nextSibling());
   DCHECK(!newChild.previousSibling());
   DCHECK(!newChild.isShadowRoot());
 
   Node* prev = nextChild.previousSibling();
   DCHECK_NE(m_lastChild, prev);
   nextChild.setPreviousSibling(&newChild);
   if (prev) {
     DCHECK_NE(firstChild(), nextChild);
     DCHECK_EQ(prev->nextSibling(), nextChild);
@@ skipping 164 matching lines @@
 
 DEFINE_TRACE_WRAPPERS(ContainerNode) {
   visitor->traceWrappers(m_firstChild);
   visitor->traceWrappers(m_lastChild);
   Node::traceWrappers(visitor);
 }
 
 Node* ContainerNode::removeChild(Node* oldChild,
                                  ExceptionState& exceptionState) {
   // NotFoundError: Raised if oldChild is not a child of this node.
-  // FIXME: We should never really get PseudoElements in here, but editing will sometimes
-  // attempt to remove them still. We should fix that and enable this ASSERT.
-  // DCHECK(!oldChild->isPseudoElement())
+  // FIXME: We should never really get PseudoElements in here, but editing will
+  // sometimes attempt to remove them still. We should fix that and enable this
+  // DCHECK.  DCHECK(!oldChild->isPseudoElement())
   if (!oldChild || oldChild->parentNode() != this ||
       oldChild->isPseudoElement()) {
     exceptionState.throwDOMException(
         NotFoundError, "The node to be removed is not a child of this node.");
     return nullptr;
   }
 
   Node* child = oldChild;
 
   document().removeFocusedElementOfSubtree(child);
@@ skipping 81 matching lines @@
 
   Node* prev = oldChild.previousSibling();
   Node* next = oldChild.nextSibling();
   removeBetween(prev, next, oldChild);
 
   notifyNodeRemoved(oldChild);
   childrenChanged(ChildrenChange::forRemoval(oldChild, prev, next,
                                              ChildrenChangeSourceParser));
 }
 
-// This differs from other remove functions because it forcibly removes all the children,
-// regardless of read-only status or event exceptions, e.g.
+// This differs from other remove functions because it forcibly removes all the
+// children, regardless of read-only status or event exceptions, e.g.
 void ContainerNode::removeChildren(SubtreeModificationAction action) {
   if (!m_firstChild)
     return;
 
   // Do any prep work needed before actually starting to detach
   // and remove... e.g. stop loading frames, fire unload events.
   willRemoveChildren();
 
   {
-    // Removing focus can cause frames to load, either via events (focusout, blur)
-    // or widget updates (e.g., for <embed>).
+    // Removing focus can cause frames to load, either via events (focusout,
+    // blur) or widget updates (e.g., for <embed>).
     SubframeLoadingDisabler disabler(*this);
 
     // Exclude this node when looking for removed focusedElement since only
     // children will be removed.
     // This must be later than willRemoveChildren, which might change focus
     // state of a child.
     document().removeFocusedElementOfSubtree(this, true);
 
     // Removing a node from a selection can cause widget updates.
     document().nodeChildrenWillBeRemoved(*this);
@@ skipping 114 matching lines @@
       notifyNodeInsertedInternal(*shadowRoot, postInsertionNotificationTargets);
   }
 }
 
 void ContainerNode::notifyNodeRemoved(Node& root) {
   ScriptForbiddenScope forbidScript;
   EventDispatchForbiddenScope assertNoEventDispatch;
 
   for (Node& node : NodeTraversal::inclusiveDescendantsOf(root)) {
     // As an optimization we skip notifying Text nodes and other leaf nodes
-    // of removal when they're not in the Document tree and not in a shadow root since the virtual
-    // call to removedFrom is not needed.
+    // of removal when they're not in the Document tree and not in a shadow root
+    // since the virtual call to removedFrom is not needed.
     if (!node.isContainerNode() && !node.isInTreeScope())
       continue;
     node.removedFrom(this);
     for (ShadowRoot* shadowRoot = node.youngestShadowRoot(); shadowRoot;
          shadowRoot = shadowRoot->olderShadowRoot())
       notifyNodeRemoved(*shadowRoot);
   }
 }
 
 DISABLE_CFI_PERF
@@ skipping 73 matching lines @@
     }
     DCHECK(o);
 
     if (!o->isInline() || o->isAtomicInlineLevel()) {
       point = o->localToAbsolute(FloatPoint(), UseTransforms);
       return true;
     }
 
     if (p->node() && p->node() == this && o->isText() && !o->isBR() &&
         !toLayoutText(o)->hasTextBoxes()) {
-      // Do nothing - skip unrendered whitespace that is a child or next sibling of the anchor.
-      // FIXME: This fails to skip a whitespace sibling when there was also a whitespace child (because p has moved).
+      // Do nothing - skip unrendered whitespace that is a child or next sibling
+      // of the anchor.
+      // FIXME: This fails to skip a whitespace sibling when there was also a
+      // whitespace child (because p has moved).
     } else if ((o->isText() && !o->isBR()) || o->isAtomicInlineLevel()) {
       point = FloatPoint();
       if (o->isText()) {
         if (toLayoutText(o)->firstTextBox())
           point.move(
               toLayoutText(o)->linesBoundingBox().x(),
               toLayoutText(o)->firstTextBox()->root().lineTop().toFloat());
         point = o->localToAbsolute(point, UseTransforms);
       } else {
         DCHECK(o->isBox());
         LayoutBox* box = toLayoutBox(o);
         point.moveBy(box->location());
         point = o->container()->localToAbsolute(point, UseTransforms);
       }
       return true;
     }
   }
 
-  // If the target doesn't have any children or siblings that could be used to calculate the scroll position, we must be
-  // at the end of the document. Scroll to the bottom. FIXME: who said anything about scrolling?
+  // If the target doesn't have any children or siblings that could be used to
+  // calculate the scroll position, we must be at the end of the
+  // document. Scroll to the bottom.
+  // FIXME: who said anything about scrolling?
   if (!o && document().view()) {
     point = FloatPoint(0, document().view()->contentsHeight());
     return true;
   }
   return false;
 }
 
 static inline LayoutObject* endOfContinuations(LayoutObject* layoutObject) {
   LayoutObject* prev = nullptr;
   LayoutObject* cur = layoutObject;
@@ skipping 26 matching lines @@
   LayoutObject* startContinuation = nullptr;
   // Find the last text/image child, to get a position.
   while (o) {
     if (LayoutObject* oLastChild = o->slowLastChild()) {
       o = oLastChild;
     } else if (o != layoutObject() && o->previousSibling()) {
       o = o->previousSibling();
     } else {
       LayoutObject* prev = nullptr;
       while (!prev) {
-        // Check if the current layoutObject has contiunation and move the location for
-        // finding the layoutObject to the end of continuations if there is the continuation.
-        // Skip to check the contiunation on contiunations section
+        // Check if the current layoutObject has contiunation and move the
+        // location for finding the layoutObject to the end of continuations if
+        // there is the continuation.  Skip to check the contiunation on
+        // contiunations section
         if (startContinuation == o) {
           startContinuation = nullptr;
         } else if (!startContinuation) {
           if (LayoutObject* continuation = endOfContinuations(o)) {
             startContinuation = o;
             prev = continuation;
             break;
           }
         }
         // Prevent to overrun out of own layout tree
@@ skipping 46 matching lines @@
       upperLeft = lowerRight;
   }
 
   FloatSize size = lowerRight.expandedTo(upperLeft) - upperLeft;
   if (std::isnan(size.width()) || std::isnan(size.height()))
     return LayoutRect();
 
   return enclosingLayoutRect(FloatRect(upperLeft, size));
 }
 
-// This is used by FrameSelection to denote when the active-state of the page has changed
-// independent of the focused element changing.
+// This is used by FrameSelection to denote when the active-state of the page
+// has changed independent of the focused element changing.
 void ContainerNode::focusStateChanged() {
-  // If we're just changing the window's active state and the focused node has no
-  // layoutObject we can just ignore the state change.
+  // If we're just changing the window's active state and the focused node has
+  // no layoutObject we can just ignore the state change.
   if (!layoutObject())
     return;
 
   if (computedStyle()->affectedByFocus()) {
     StyleChangeType changeType =
         computedStyle()->hasPseudoStyle(PseudoIdFirstLetter)
             ? SubtreeStyleChange
             : LocalStyleChange;
     setNeedsStyleRecalc(
         changeType,
         StyleChangeReasonForTracing::createWithExtraData(
             StyleChangeReason::PseudoClass, StyleChangeExtraData::Focus));
   }
   if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus())
     toElement(this)->pseudoStateChanged(CSSSelector::PseudoFocus);
 
   LayoutTheme::theme().controlStateChanged(*layoutObject(), FocusControlState);
 }
 
 void ContainerNode::setFocus(bool received) {
   // Recurse up author shadow trees to mark shadow hosts if it matches :focus.
-  // TODO(kochi): Handle UA shadows which marks multiple nodes as focused such as
-  // <input type="date"> the same way as author shadow.
+  // TODO(kochi): Handle UA shadows which marks multiple nodes as focused such
+  // as <input type="date"> the same way as author shadow.
   if (ShadowRoot* root = containingShadowRoot()) {
     if (root->type() != ShadowRootType::UserAgent)
       ownerShadowHost()->setFocus(received);
   }
 
-  // If this is an author shadow host and indirectly focused (has focused element within
-  // its shadow root), update focus.
+  // If this is an author shadow host and indirectly focused (has focused
+  // element within its shadow root), update focus.
   if (isElementNode() && document().focusedElement() &&
       document().focusedElement() != this) {
     if (toElement(this)->authorShadowRoot())
       received =
           received && toElement(this)->authorShadowRoot()->delegatesFocus();
   }
 
   if (focused() == received)
     return;
 
   Node::setFocus(received);
 
   focusStateChanged();
 
   if (layoutObject() || received)
     return;
 
-  // If :focus sets display: none, we lose focus but still need to recalc our style.
+  // If :focus sets display: none, we lose focus but still need to recalc our
+  // style.
   if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus())
     toElement(this)->pseudoStateChanged(CSSSelector::PseudoFocus);
   else
     setNeedsStyleRecalc(
         LocalStyleChange,
         StyleChangeReasonForTracing::createWithExtraData(
             StyleChangeReason::PseudoClass, StyleChangeExtraData::Focus));
 }
 
 void ContainerNode::setActive(bool down) {
@@ skipping 65 matching lines @@
   if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByDrag())
     toElement(this)->pseudoStateChanged(CSSSelector::PseudoDrag);
 }
 
 void ContainerNode::setHovered(bool over) {
   if (over == hovered())
     return;
 
   Node::setHovered(over);
 
-  // If :hover sets display: none we lose our hover but still need to recalc our style.
+  // If :hover sets display: none we lose our hover but still need to recalc our
+  // style.
   if (!layoutObject()) {
     if (over)
       return;
     if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByHover())
       toElement(this)->pseudoStateChanged(CSSSelector::PseudoHover);
     else
       setNeedsStyleRecalc(
           LocalStyleChange,
           StyleChangeReasonForTracing::createWithExtraData(
               StyleChangeReason::PseudoClass, StyleChangeExtraData::Hover));
@@ skipping 133 matching lines @@
 void ContainerNode::setRestyleFlag(DynamicRestyleFlags mask) {
   DCHECK(isElementNode() || isShadowRoot());
   ensureRareData().setRestyleFlag(mask);
 }
 
 void ContainerNode::recalcDescendantStyles(StyleRecalcChange change) {
   DCHECK(document().inStyleRecalc());
   DCHECK(change >= UpdatePseudoElements || childNeedsStyleRecalc());
   DCHECK(!needsStyleRecalc());
 
-  // This loop is deliberately backwards because we use insertBefore in the layout tree, and want to avoid
-  // a potentially n^2 loop to find the insertion point while resolving style. Having us start from the last
-  // child and work our way back means in the common case, we'll find the insertion point in O(1) time.
-  // See crbug.com/288225
+  // This loop is deliberately backwards because we use insertBefore in the
+  // layout tree, and want to avoid a potentially n^2 loop to find the insertion
+  // point while resolving style.  Having us start from the last child and work
+  // our way back means in the common case, we'll find the insertion point in
+  // O(1) time.  See crbug.com/288225
   StyleResolver& styleResolver = document().ensureStyleResolver();
   Text* lastTextNode = nullptr;
   for (Node* child = lastChild(); child; child = child->previousSibling()) {
     if (child->isTextNode()) {
       toText(child)->recalcTextStyle(change, lastTextNode);
       lastTextNode = toText(child);
     } else if (child->isElementNode()) {
       Element* element = toElement(child);
       if (element->shouldCallRecalcStyle(change))
         element->recalcStyle(change, lastTextNode);
@@ skipping 74 matching lines @@
 void ContainerNode::invalidateNodeListCachesInAncestors(
     const QualifiedName* attrName,
     Element* attributeOwnerElement) {
   if (hasRareData() && (!attrName || isAttributeNode())) {
     if (NodeListsNodeData* lists = rareData()->nodeLists()) {
       if (ChildNodeList* childNodeList = lists->childNodeList(*this))
         childNodeList->invalidateCache();
     }
   }
 
-  // Modifications to attributes that are not associated with an Element can't invalidate NodeList caches.
+  // Modifications to attributes that are not associated with an Element can't
+  // invalidate NodeList caches.
   if (attrName && !attributeOwnerElement)
     return;
 
   if (!document().shouldInvalidateNodeListCaches(attrName))
     return;
 
   document().invalidateNodeListCaches(attrName);
 
   for (ContainerNode* node = this; node; node = node->parentNode()) {
     if (NodeListsNodeData* lists = node->nodeLists())
@@ skipping 13 matching lines @@
     const AtomicString& namespaceURI,
     const AtomicString& localName) {
   if (namespaceURI == starAtom)
     return getElementsByTagName(localName);
 
   return ensureCachedCollection<TagCollection>(
       TagCollectionType, namespaceURI.isEmpty() ? nullAtom : namespaceURI,
       localName);
 }
 
-// Takes an AtomicString in argument because it is common for elements to share the same name attribute.
-// Therefore, the NameNodeList factory function expects an AtomicString type.
+// Takes an AtomicString in argument because it is common for elements to share
+// the same name attribute.  Therefore, the NameNodeList factory function
+// expects an AtomicString type.
 NameNodeList* ContainerNode::getElementsByName(
     const AtomicString& elementName) {
   return ensureCachedCollection<NameNodeList>(NameNodeListType, elementName);
 }
 
-// Takes an AtomicString in argument because it is common for elements to share the same set of class names.
-// Therefore, the ClassNodeList factory function expects an AtomicString type.
+// Takes an AtomicString in argument because it is common for elements to share
+// the same set of class names.  Therefore, the ClassNodeList factory function
+// expects an AtomicString type.
 ClassCollection* ContainerNode::getElementsByClassName(
     const AtomicString& classNames) {
   return ensureCachedCollection<ClassCollection>(ClassCollectionType,
                                                  classNames);
 }
 
 RadioNodeList* ContainerNode::radioNodeList(const AtomicString& name,
                                             bool onlyMatchImgElements) {
   DCHECK(isHTMLFormElement(this) || isHTMLFieldSetElement(this));
   CollectionType type =
       onlyMatchImgElements ? RadioImgNodeListType : RadioNodeListType;
   return ensureCachedCollection<RadioNodeList>(type, name);
 }
 
 Element* ContainerNode::getElementById(const AtomicString& id) const {
   if (isInTreeScope()) {
     // Fast path if we are in a tree scope: call getElementById() on tree scope
     // and check if the matching element is in our subtree.
     Element* element = containingTreeScope().getElementById(id);
     if (!element)
       return nullptr;
     if (element->isDescendantOf(this))
       return element;
   }
 
-  // Fall back to traversing our subtree. In case of duplicate ids, the first element found will be returned.
+  // Fall back to traversing our subtree. In case of duplicate ids, the first
+  // element found will be returned.
   for (Element& element : ElementTraversal::descendantsOf(*this)) {
     if (element.getIdAttribute() == id)
       return &element;
   }
   return nullptr;
 }
 
 NodeListsNodeData& ContainerNode::ensureNodeLists() {
   return ensureRareData().ensureNodeLists();
 }
@@ skipping 10 matching lines @@
     return true;
 
   if (node->isElementNode() && toElement(node)->shadow())
     return true;
 
   return false;
 }
 #endif
 
 }  // namespace blink