Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/shadow/InsertionPoint.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
 void InsertionPoint::setDistributedNodes(DistributedNodes& distributedNodes) {
   // Attempt not to reattach nodes that would be distributed to the exact same
   // location by comparing the old and new distributions.
 
   size_t i = 0;
   size_t j = 0;
 
   for (; i < m_distributedNodes.size() && j < distributedNodes.size();
        ++i, ++j) {
     if (m_distributedNodes.size() < distributedNodes.size()) {
-      // If the new distribution is larger than the old one, reattach all nodes in
-      // the new distribution that were inserted.
+      // If the new distribution is larger than the old one, reattach all nodes
+      // in the new distribution that were inserted.
       for (; j < distributedNodes.size() &&
              m_distributedNodes.at(i) != distributedNodes.at(j);
            ++j)
         distributedNodes.at(j)->lazyReattachIfAttached();
       if (j == distributedNodes.size())
         break;
     } else if (m_distributedNodes.size() > distributedNodes.size()) {
-      // If the old distribution is larger than the new one, reattach all nodes in
-      // the old distribution that were removed.
+      // If the old distribution is larger than the new one, reattach all nodes
+      // in the old distribution that were removed.
       for (; i < m_distributedNodes.size() &&
              m_distributedNodes.at(i) != distributedNodes.at(j);
            ++i)
         m_distributedNodes.at(i)->lazyReattachIfAttached();
       if (i == m_distributedNodes.size())
         break;
     } else if (m_distributedNodes.at(i) != distributedNodes.at(j)) {
       // If both distributions are the same length reattach both old and new.
       m_distributedNodes.at(i)->lazyReattachIfAttached();
       distributedNodes.at(j)->lazyReattachIfAttached();
     }
   }
 
-  // If we hit the end of either list above we need to reattach all remaining nodes.
+  // If we hit the end of either list above we need to reattach all remaining
+  // nodes.
 
   for (; i < m_distributedNodes.size(); ++i)
     m_distributedNodes.at(i)->lazyReattachIfAttached();
 
   for (; j < distributedNodes.size(); ++j)
     distributedNodes.at(j)->lazyReattachIfAttached();
 
   m_distributedNodes.swap(distributedNodes);
   // Deallocate a Vector and a HashMap explicitly so that
   // Oilpan can recycle them without an intervening GC.
   distributedNodes.clear();
   m_distributedNodes.shrinkToFit();
 }
 
 void InsertionPoint::attachLayoutTree(const AttachContext& context) {
-  // We need to attach the distribution here so that they're inserted in the right order
-  // otherwise the n^2 protection inside LayoutTreeBuilder will cause them to be
-  // inserted in the wrong place later. This also lets distributed nodes benefit from
-  // the n^2 protection.
+  // We need to attach the distribution here so that they're inserted in the
+  // right order otherwise the n^2 protection inside LayoutTreeBuilder will
+  // cause them to be inserted in the wrong place later. This also lets
+  // distributed nodes benefit from the n^2 protection.
   for (size_t i = 0; i < m_distributedNodes.size(); ++i) {
     if (m_distributedNodes.at(i)->needsAttach())
       m_distributedNodes.at(i)->attachLayoutTree(context);
   }
 
   HTMLElement::attachLayoutTree(context);
 }
 
 void InsertionPoint::detachLayoutTree(const AttachContext& context) {
   for (size_t i = 0; i < m_distributedNodes.size(); ++i)
@@ skipping 30 matching lines @@
 
 bool InsertionPoint::isActive() const {
   if (!canBeActive())
     return false;
   ShadowRoot* shadowRoot = containingShadowRoot();
   DCHECK(shadowRoot);
   if (!isHTMLShadowElement(*this) ||
       shadowRoot->descendantShadowElementCount() <= 1)
     return true;
 
-  // Slow path only when there are more than one shadow elements in a shadow tree. That should be a rare case.
+  // Slow path only when there are more than one shadow elements in a shadow
+  // tree. That should be a rare case.
   const HeapVector<Member<InsertionPoint>>& insertionPoints =
       shadowRoot->descendantInsertionPoints();
   for (size_t i = 0; i < insertionPoints.size(); ++i) {
     InsertionPoint* point = insertionPoints[i].get();
     if (isHTMLShadowElement(*point))
       return point == this;
   }
   return true;
 }
 
@@ skipping 56 matching lines @@
 void InsertionPoint::removedFrom(ContainerNode* insertionPoint) {
   ShadowRoot* root = containingShadowRoot();
   if (!root)
     root = insertionPoint->containingShadowRoot();
 
   if (root) {
     if (ElementShadow* rootOwner = root->owner())
       rootOwner->setNeedsDistributionRecalc();
   }
 
-  // host can be null when removedFrom() is called from ElementShadow destructor.
+  // host can be null when removedFrom() is called from ElementShadow
+  // destructor.
   ElementShadow* rootOwner = root ? root->owner() : 0;
 
-  // Since this insertion point is no longer visible from the shadow subtree, it need to clean itself up.
+  // Since this insertion point is no longer visible from the shadow subtree, it
+  // need to clean itself up.
   clearDistribution();
 
   if (m_registeredWithShadowRoot &&
       insertionPoint->treeScope().rootNode() == root) {
     DCHECK(root);
     m_registeredWithShadowRoot = false;
     root->didRemoveInsertionPoint(this);
     if (!root->isV1() && rootOwner) {
       if (canAffectSelector())
         rootOwner->v0().willAffectSelector();
@@ skipping 44 matching lines @@
     if (!insertionPoints)
       return;
     for (size_t i = 0; i < insertionPoints->size(); ++i)
       results.append(insertionPoints->at(i).get());
     DCHECK_NE(current, insertionPoints->last().get());
     current = insertionPoints->last().get();
   }
 }
 
 }  // namespace blink