Reflow comments in core/dom/.

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

 /*
  * Copyright (C) 2011, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 235 matching lines @@
     return false;
 
   for (Element* element = &toElement(rootNode); element;
        element = element->parentElement()) {
     if (element->hasClass() && element->classNames().contains(className))
       return true;
   }
   return false;
 }
 
-// If returns true, traversalRoots has the elements that may match the selector query.
+// If returns true, traversalRoots has the elements that may match the selector
+// query.
 //
-// If returns false, traversalRoots has the rootNode parameter or descendants of rootNode representing
-// the subtree for which we can limit the querySelector traversal.
+// If returns false, traversalRoots has the rootNode parameter or descendants of
+// rootNode representing the subtree for which we can limit the querySelector
+// traversal.
 //
-// The travseralRoots may be empty, regardless of the returned bool value, if this method finds that the selectors won't
-// match any element.
+// The travseralRoots may be empty, regardless of the returned bool value, if
+// this method finds that the selectors won't match any element.
 template <typename SelectorQueryTrait>
 void SelectorDataList::findTraverseRootsAndExecute(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
-  // We need to return the matches in document order. To use id lookup while there is possiblity of multiple matches
-  // we would need to sort the results. For now, just traverse the document in that case.
+  // We need to return the matches in document order. To use id lookup while
+  // there is possiblity of multiple matches we would need to sort the
+  // results. For now, just traverse the document in that case.
   DCHECK_EQ(m_selectors.size(), 1u);
 
   bool isRightmostSelector = true;
   bool startFromParent = false;
 
   for (const CSSSelector* selector = m_selectors[0]; selector;
        selector = selector->tagHistory()) {
     if (selector->match() == CSSSelector::Id && rootNode.isInTreeScope() &&
         !rootNode.containingTreeScope().containsMultipleElementsWithId(
             selector->value())) {
@@ skipping 14 matching lines @@
 
       if (startFromParent && adjustedNode)
         adjustedNode = adjustedNode->parentNode();
 
       executeForTraverseRoot<SelectorQueryTrait>(*m_selectors[0], adjustedNode,
                                                  DoesNotMatchTraverseRoots,
                                                  rootNode, output);
       return;
     }
 
-    // If we have both CSSSelector::Id and CSSSelector::Class at the same time, we should use Id
-    // to find traverse root.
+    // If we have both CSSSelector::Id and CSSSelector::Class at the same time,
+    // we should use Id to find traverse root.
     if (!SelectorQueryTrait::shouldOnlyMatchFirstElement && !startFromParent &&
         selector->match() == CSSSelector::Class) {
       if (isRightmostSelector) {
         ClassElementList<AllElements> traverseRoots(rootNode,
                                                     selector->value());
         executeForTraverseRoots<SelectorQueryTrait>(
             *m_selectors[0], traverseRoots, MatchesTraverseRoots, rootNode,
             output);
         return;
       }
-      // Since there exists some ancestor element which has the class name, we need to see all children of rootNode.
+      // Since there exists some ancestor element which has the class name, we
+      // need to see all children of rootNode.
       if (ancestorHasClassName(rootNode, selector->value())) {
         executeForTraverseRoot<SelectorQueryTrait>(*m_selectors[0], &rootNode,
                                                    DoesNotMatchTraverseRoots,
                                                    rootNode, output);
         return;
       }
 
       ClassElementList<OnlyRoots> traverseRoots(rootNode, selector->value());
       executeForTraverseRoots<SelectorQueryTrait>(
           *m_selectors[0], traverseRoots, DoesNotMatchTraverseRoots, rootNode,
@@ skipping 92 matching lines @@
 void SelectorDataList::executeSlow(
     ContainerNode& rootNode,
     typename SelectorQueryTrait::OutputType& output) const {
   for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
     if (selectorListMatches<SelectorQueryTrait>(rootNode, element, output) &&
         SelectorQueryTrait::shouldOnlyMatchFirstElement)
       return;
   }
 }
 
-// FIXME: Move the following helper functions, authorShadowRootOf, firstWithinTraversingShadowTree,
-// nextTraversingShadowTree to the best place, e.g. NodeTraversal.
+// FIXME: Move the following helper functions, authorShadowRootOf,
+// firstWithinTraversingShadowTree, nextTraversingShadowTree to the best place,
+// e.g. NodeTraversal.
 static ShadowRoot* authorShadowRootOf(const ContainerNode& node) {
   if (!node.isElementNode() || !isShadowHost(&node))
     return nullptr;
 
   ElementShadow* shadow = toElement(node).shadow();
   DCHECK(shadow);
   for (ShadowRoot* shadowRoot = &shadow->oldestShadowRoot(); shadowRoot;
        shadowRoot = shadowRoot->youngerShadowRoot()) {
     if (shadowRoot->type() == ShadowRootType::V0 ||
         shadowRoot->type() == ShadowRootType::Open)
@@ skipping 87 matching lines @@
     }
     return;
   }
 
   DCHECK_EQ(m_selectors.size(), 1u);
   DCHECK(!rootNode.document().inQuirksMode());
 
   const CSSSelector& selector = *m_selectors[0];
   const CSSSelector& firstSelector = selector;
 
-  // Fast path for querySelector*('#id'), querySelector*('tag#id'), querySelector*('tag[id=example]').
+  // Fast path for querySelector*('#id'), querySelector*('tag#id'),
+  // querySelector*('tag[id=example]').
   if (const CSSSelector* idSelector = selectorForIdLookup(firstSelector)) {
     const AtomicString& idToMatch = idSelector->value();
     if (rootNode.treeScope().containsMultipleElementsWithId(idToMatch)) {
       const HeapVector<Member<Element>>& elements =
           rootNode.treeScope().getAllElementsById(idToMatch);
       size_t count = elements.size();
       for (size_t i = 0; i < count; ++i) {
         Element& element = *elements[i];
         if (!(isTreeScopeRoot(rootNode) || element.isDescendantOf(&rootNode)))
           continue;
@@ skipping 89 matching lines @@
 
   return m_entries.add(selectors, SelectorQuery::adopt(std::move(selectorList)))
       .storedValue->value.get();
 }
 
 void SelectorQueryCache::invalidate() {
   m_entries.clear();
 }
 
 }  // namespace blink