Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/Node.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, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
+ * rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
- * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
+ * (http://www.torchmobile.com/)
  *
  * 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 515 matching lines @@
 
 void Node::remove(ExceptionState& exceptionState) {
   if (ContainerNode* parent = parentNode())
     parent->removeChild(this, exceptionState);
 }
 
 void Node::normalize() {
   updateDistribution();
 
   // Go through the subtree beneath us, normalizing all nodes. This means that
-  // any two adjacent text nodes are merged and any empty text nodes are removed.
+  // any two adjacent text nodes are merged and any empty text nodes are
+  // removed.
 
   Node* node = this;
   while (Node* firstChild = node->firstChild())
     node = firstChild;
   while (node) {
     if (node == this)
       break;
 
     if (node->getNodeType() == kTextNode)
       node = toText(node)->mergeNextSiblingNodesIfPossible();
@@ skipping 306 matching lines @@
     otherIterator = parent(*otherIterator);
   }
   DCHECK(!otherIterator);
   return nullptr;
 }
 
 void Node::reattachLayoutTree(const AttachContext& context) {
   AttachContext reattachContext(context);
   reattachContext.performingReattach = true;
 
-  // We only need to detach if the node has already been through attachLayoutTree().
+  // We only need to detach if the node has already been through
+  // attachLayoutTree().
   if (getStyleChangeType() < NeedsReattachStyleChange)
     detachLayoutTree(reattachContext);
   attachLayoutTree(reattachContext);
 }
 
 void Node::attachLayoutTree(const AttachContext&) {
   DCHECK(document().inStyleRecalc() || isDocumentNode());
   DCHECK(!document().lifecycle().inDetach());
   DCHECK(needsAttach());
   DCHECK(!layoutObject() ||
@@ skipping 16 matching lines @@
   setStyleChange(NeedsReattachStyleChange);
   clearChildNeedsStyleInvalidation();
 }
 
 void Node::reattachWhitespaceSiblingsIfNeeded(Text* start) {
   ScriptForbiddenScope forbidScriptDuringRawIteration;
   for (Node* sibling = start; sibling; sibling = sibling->nextSibling()) {
     if (sibling->isTextNode() && toText(sibling)->containsOnlyWhitespace()) {
       bool hadLayoutObject = !!sibling->layoutObject();
       toText(sibling)->reattachLayoutTreeIfNeeded();
-      // If sibling's layout object status didn't change we don't need to continue checking
-      // other siblings since their layout object status won't change either.
+      // If sibling's layout object status didn't change we don't need to
+      // continue checking other siblings since their layout object status won't
+      // change either.
       if (!!sibling->layoutObject() == hadLayoutObject)
         return;
     } else if (sibling->layoutObject()) {
       return;
     }
   }
 }
 
 const ComputedStyle* Node::virtualEnsureComputedStyle(
     PseudoId pseudoElementSpecifier) {
   return parentOrShadowHostNode()
              ? parentOrShadowHostNode()->ensureComputedStyle(
                    pseudoElementSpecifier)
              : nullptr;
 }
 
 int Node::maxCharacterOffset() const {
   ASSERT_NOT_REACHED();
   return 0;
 }
 
-// FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
-// is obviously misplaced.
+// FIXME: Shouldn't these functions be in the editing code?  Code that asks
+// questions about HTML in the core DOM class is obviously misplaced.
 bool Node::canStartSelection() const {
   if (isDisabledFormControl(this))
     return false;
 
   if (hasEditableStyle(*this))
     return true;
 
   if (layoutObject()) {
     const ComputedStyle& style = layoutObject()->styleRef();
-    // We allow selections to begin within an element that has -webkit-user-select: none set,
-    // but if the element is draggable then dragging should take priority over selection.
+    // We allow selections to begin within an element that has
+    // -webkit-user-select: none set, but if the element is draggable then
+    // dragging should take priority over selection.
     if (style.userDrag() == DRAG_ELEMENT && style.userSelect() == SELECT_NONE)
       return false;
   }
   ContainerNode* parent = FlatTreeTraversal::parent(*this);
   return parent ? parent->canStartSelection() : true;
 }
 
-// StyledElements allow inline style (style="border: 1px"), presentational attributes (ex. color),
-// class names (ex. class="foo bar") and other non-basic styling features. They also control
-// if this element can participate in style sharing.
+// StyledElements allow inline style (style="border: 1px"), presentational
+// attributes (ex. color), class names (ex. class="foo bar") and other non-basic
+// styling features. They also control if this element can participate in style
+// sharing.
 //
-// FIXME: The only things that ever go through StyleResolver that aren't StyledElements are
-// PseudoElements and VTTElements. It's possible we can just eliminate all the checks
-// since those elements will never have class names, inline style, or other things that
-// this apparently guards against.
+// FIXME: The only things that ever go through StyleResolver that aren't
+// StyledElements are PseudoElements and VTTElements. It's possible we can just
+// eliminate all the checks since those elements will never have class names,
+// inline style, or other things that this apparently guards against.
 bool Node::isStyledElement() const {
   return isHTMLElement() || isSVGElement() ||
          (isElementNode() &&
           toElement(this)->namespaceURI() == MathMLNames::mathmlNamespaceURI);
 }
 
 bool Node::canParticipateInFlatTree() const {
   // TODO(hayato): Return false for pseudo elements.
   return !isShadowRoot() && !isSlotOrActiveInsertionPoint();
 }
@@ skipping 356 matching lines @@
   if (otherNode == this)
     return kDocumentPositionEquivalent;
 
   const Attr* attr1 = getNodeType() == kAttributeNode ? toAttr(this) : nullptr;
   const Attr* attr2 =
       otherNode->getNodeType() == kAttributeNode ? toAttr(otherNode) : nullptr;
 
   const Node* start1 = attr1 ? attr1->ownerElement() : this;
   const Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
 
-  // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
-  // an orphaned attribute node.
+  // If either of start1 or start2 is null, then we are disconnected, since one
+  // of the nodes is an orphaned attribute node.
   if (!start1 || !start2) {
     unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding
                                                   : kDocumentPositionFollowing;
     return kDocumentPositionDisconnected |
            kDocumentPositionImplementationSpecific | direction;
   }
 
   HeapVector<Member<const Node>, 16> chain1;
   HeapVector<Member<const Node>, 16> chain2;
   if (attr1)
     chain1.append(attr1);
   if (attr2)
     chain2.append(attr2);
 
   if (attr1 && attr2 && start1 == start2 && start1) {
-    // We are comparing two attributes on the same node. Crawl our attribute map and see which one we hit first.
+    // We are comparing two attributes on the same node. Crawl our attribute map
+    // and see which one we hit first.
     const Element* owner1 = attr1->ownerElement();
     AttributeCollection attributes = owner1->attributes();
     for (const Attribute& attr : attributes) {
-      // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an
-      // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
-      // the same nodeType are inserted into or removed from the direct container. This would be the case, for example,
-      // when comparing two attributes of the same element, and inserting or removing additional attributes might change
-      // the order between existing attributes.
+      // If neither of the two determining nodes is a child node and nodeType is
+      // the same for both determining nodes, then an implementation-dependent
+      // order between the determining nodes is returned. This order is stable
+      // as long as no nodes of the same nodeType are inserted into or removed
+      // from the direct container. This would be the case, for example, when
+      // comparing two attributes of the same element, and inserting or removing
+      // additional attributes might change the order between existing
+      // attributes.
       if (attr1->getQualifiedName() == attr.name())
         return kDocumentPositionImplementationSpecific |
                kDocumentPositionFollowing;
       if (attr2->getQualifiedName() == attr.name())
         return kDocumentPositionImplementationSpecific |
                kDocumentPositionPreceding;
     }
 
     ASSERT_NOT_REACHED();
     return kDocumentPositionDisconnected;
   }
 
-  // If one node is in the document and the other is not, we must be disconnected.
-  // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
-  // comparing Attr nodes here, since they return false from isConnected() all the time (which seems like a bug).
+  // If one node is in the document and the other is not, we must be
+  // disconnected.  If the nodes have different owning documents, they must be
+  // disconnected.  Note that we avoid comparing Attr nodes here, since they
+  // return false from isConnected() all the time (which seems like a bug).
   if (start1->isConnected() != start2->isConnected() ||
       (treatment == TreatShadowTreesAsDisconnected &&
        start1->treeScope() != start2->treeScope())) {
     unsigned short direction = (this > otherNode) ? kDocumentPositionPreceding
                                                   : kDocumentPositionFollowing;
     return kDocumentPositionDisconnected |
            kDocumentPositionImplementationSpecific | direction;
   }
 
-  // We need to find a common ancestor container, and then compare the indices of the two immediate children.
+  // We need to find a common ancestor container, and then compare the indices
+  // of the two immediate children.
   const Node* current;
   for (current = start1; current; current = current->parentOrShadowHostNode())
     chain1.append(current);
   for (current = start2; current; current = current->parentOrShadowHostNode())
     chain2.append(current);
 
   unsigned index1 = chain1.size();
   unsigned index2 = chain2.size();
 
   // If the two elements don't have a common root, they're not in the same tree.
@@ skipping 35 matching lines @@
         }
 
         return Node::kDocumentPositionPreceding | connection;
       }
 
       if (!child2->nextSibling())
         return kDocumentPositionFollowing | connection;
       if (!child1->nextSibling())
         return kDocumentPositionPreceding | connection;
 
-      // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
+      // Otherwise we need to see which node occurs first.  Crawl backwards from
+      // child2 looking for child1.
       for (const Node* child = child2->previousSibling(); child;
            child = child->previousSibling()) {
         if (child == child1)
           return kDocumentPositionFollowing | connection;
       }
       return kDocumentPositionPreceding | connection;
     }
   }
 
-  // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
-  // chain is the ancestor.
+  // There was no difference between the two parent chains, i.e., one was a
+  // subset of the other.  The shorter chain is the ancestor.
   return index1 < index2
              ? kDocumentPositionFollowing | kDocumentPositionContainedBy |
                    connection
              : kDocumentPositionPreceding | kDocumentPositionContains |
                    connection;
 }
 
 String Node::debugName() const {
   StringBuilder name;
   name.append(debugNodeName());
@@ skipping 287 matching lines @@
   LOG(INFO) << "\n" << stream.str();
 }
 
 #endif
 
 // --------
 
 Element* Node::enclosingLinkEventParentOrSelf() const {
   const Node* result = nullptr;
   for (const Node* node = this; node; node = FlatTreeTraversal::parent(*node)) {
-    // For imagemaps, the enclosing link node is the associated area element not the image itself.
-    // So we don't let images be the enclosingLinkNode, even though isLink sometimes returns true
-    // for them.
+    // For imagemaps, the enclosing link node is the associated area element not
+    // the image itself.  So we don't let images be the enclosingLinkNode, even
+    // though isLink sometimes returns true for them.
     if (node->isLink() && !isHTMLImageElement(*node)) {
-      // Casting to Element is safe because only HTMLAnchorElement, HTMLImageElement and
-      // SVGAElement can return true for isLink().
+      // Casting to Element is safe because only HTMLAnchorElement,
+      // HTMLImageElement and SVGAElement can return true for isLink().
       result = node;
       break;
     }
   }
 
   return toElement(const_cast<Node*>(result));
 }
 
 const AtomicString& Node::interfaceName() const {
   return EventTargetNames::Node;
@@ skipping 45 matching lines @@
   document().addListenerTypeIfNeeded(eventType);
   if (FrameHost* frameHost = document().frameHost())
     frameHost->eventHandlerRegistry().didAddEventHandler(
         *this, eventType, registeredListener.options());
 }
 
 void Node::removedEventListener(
     const AtomicString& eventType,
     const RegisteredEventListener& registeredListener) {
   EventTarget::removedEventListener(eventType, registeredListener);
-  // FIXME: Notify Document that the listener has vanished. We need to keep track of a number of
-  // listeners for each type, not just a bool - see https://bugs.webkit.org/show_bug.cgi?id=33861
+  // FIXME: Notify Document that the listener has vanished. We need to keep
+  // track of a number of listeners for each type, not just a bool - see
+  // https://bugs.webkit.org/show_bug.cgi?id=33861
   if (FrameHost* frameHost = document().frameHost())
     frameHost->eventHandlerRegistry().didRemoveEventHandler(
         *this, eventType, registeredListener.options());
 }
 
 void Node::removeAllEventListeners() {
   if (hasEventListeners() && document().frameHost())
     document().frameHost()->eventHandlerRegistry().didRemoveAllEventHandlers(
         *this);
   EventTarget::removeAllEventListeners();
@@ skipping 126 matching lines @@
       mutationObserverRegistry();
   DCHECK(registry);
   if (!registry)
     return;
 
   size_t index = registry->find(registration);
   DCHECK_NE(index, kNotFound);
   if (index == kNotFound)
     return;
 
-  // FIXME: Simplify the registration/transient registration logic to make this understandable by humans.
-  // The explicit dispose() is needed to have the registration
-  // object unregister itself promptly.
+  // FIXME: Simplify the registration/transient registration logic to make this
+  // understandable by humans.  The explicit dispose() is needed to have the
+  // registration object unregister itself promptly.
   registration->dispose();
   registry->remove(index);
 }
 
 void Node::registerTransientMutationObserver(
     MutationObserverRegistration* registration) {
   ensureRareData().ensureMutationObserverData().transientRegistry.add(
       registration);
 }
 
@@ skipping 329 matching lines @@
   DCHECK(isHTMLElement() || isSVGElement());
   DCHECK(CustomElementState::Custom != getCustomElementState());
   setFlag(V0CustomElementFlag);
   setFlag(newState == V0Upgraded, V0CustomElementUpgradedFlag);
 
   if (oldState == V0NotCustomElement || newState == V0Upgraded)
     toElement(this)->pseudoStateChanged(CSSSelector::PseudoUnresolved);
 }
 
 void Node::checkSlotChange() {
-  // Common check logic is used in both cases, "after inserted" and "before removed".
+  // Common check logic is used in both cases, "after inserted" and "before
+  // removed".
   if (!isSlotable())
     return;
   if (ShadowRoot* root = v1ShadowRootOfParent()) {
     // Relevant DOM Standard:
     // https://dom.spec.whatwg.org/#concept-node-insert
-    // - 6.1.2: If parent is a shadow host and node is a slotable, then assign a slot for node.
+    // - 6.1.2: If parent is a shadow host and node is a slotable, then assign a
+    //   slot for node.
     // https://dom.spec.whatwg.org/#concept-node-remove
-    // - 10. If node is assigned, then run assign slotables for node’s assigned slot.
+    // - 10. If node is assigned, then run assign slotables for node’s assigned
+    //   slot.
 
-    // Although DOM Standard requires "assign a slot for node / run assign slotables" at this timing,
-    // we skip it as an optimization.
+    // Although DOM Standard requires "assign a slot for node / run assign
+    // slotables" at this timing, we skip it as an optimization.
     if (HTMLSlotElement* slot = root->ensureSlotAssignment().findSlot(*this))
       slot->enqueueSlotChangeEvent();
   } else {
     // Relevant DOM Standard:
     // https://dom.spec.whatwg.org/#concept-node-insert
-    // - 6.1.3: If parent is a slot whose assigned nodes is the empty list, then run signal a slot change for parent.
+    // - 6.1.3: If parent is a slot whose assigned nodes is the empty list, then
+    //   run signal a slot change for parent.
     // https://dom.spec.whatwg.org/#concept-node-remove
-    // - 11. If parent is a slot whose assigned nodes is the empty list, then run signal a slot change for parent.
+    // - 11. If parent is a slot whose assigned nodes is the empty list, then
+    //   run signal a slot change for parent.
     Element* parent = parentElement();
     if (parent && isHTMLSlotElement(parent)) {
       HTMLSlotElement& parentSlot = toHTMLSlotElement(*parent);
       if (ShadowRoot* root = containingShadowRoot()) {
         if (root && root->isV1() && !parentSlot.hasAssignedNodesSlow())
           parentSlot.enqueueSlotChangeEvent();
       }
     }
   }
 }
@@ skipping 14 matching lines @@
 DEFINE_TRACE_WRAPPERS(Node) {
   visitor->traceWrappers(parentOrShadowHostOrTemplateHostNode());
   visitor->traceWrappers(m_previous);
   visitor->traceWrappers(m_next);
   if (hasRareData())
     visitor->traceWrappers(rareData());
   EventTarget::traceWrappers(visitor);
 }
 
 unsigned Node::lengthOfContents() const {
-  // This switch statement must be consistent with that of Range::processContentsBetweenOffsets.
+  // This switch statement must be consistent with that of
+  // Range::processContentsBetweenOffsets.
   switch (getNodeType()) {
     case Node::kTextNode:
     case Node::kCdataSectionNode:
     case Node::kCommentNode:
     case Node::kProcessingInstructionNode:
       return toCharacterData(this)->length();
     case Node::kElementNode:
     case Node::kDocumentNode:
     case Node::kDocumentFragmentNode:
       return toContainerNode(this)->countChildren();
@@ skipping 48 matching lines @@
   if (node) {
     std::stringstream stream;
     node->printNodePathTo(stream);
     LOG(INFO) << stream.str();
   } else {
     LOG(INFO) << "Cannot showNodePath for <null>";
   }
 }
 
 #endif