Reformat comments in core/layout up until LayoutMultiColumnFlowThread

third_party/WebKit/Source/core/layout/LayoutListItem.cpp

 /**
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * 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.
@@ skipping 101 matching lines @@
 static bool isList(const Node& node) {
   return isHTMLUListElement(node) || isHTMLOListElement(node);
 }
 
 // Returns the enclosing list with respect to the DOM order.
 static Node* enclosingList(const LayoutListItem* listItem) {
   Node* listItemNode = listItem->node();
   if (!listItemNode)
     return nullptr;
   Node* firstNode = nullptr;
-  // We use parentNode because the enclosing list could be a ShadowRoot that's not Element.
+  // We use parentNode because the enclosing list could be a ShadowRoot that's
+  // not Element.
   for (Node* parent = FlatTreeTraversal::parent(*listItemNode); parent;
        parent = FlatTreeTraversal::parent(*parent)) {
     if (isList(*parent))
       return parent;
     if (!firstNode)
       firstNode = parent;
   }
 
   // If there's no actual <ul> or <ol> list element, then the first found
   // node acts as our list for purposes of determining what other list items
@@ skipping 17 matching lines @@
       // We've found a nested, independent list: nothing to do here.
       current =
           LayoutTreeBuilderTraversal::nextSkippingChildren(*current, listNode);
       continue;
     }
 
     LayoutObject* layoutObject = current->layoutObject();
     if (layoutObject && layoutObject->isListItem())
       return toLayoutListItem(layoutObject);
 
-    // FIXME: Can this be optimized to skip the children of the elements without a layoutObject?
+    // FIXME: Can this be optimized to skip the children of the elements without
+    // a layoutObject?
     current = LayoutTreeBuilderTraversal::next(*current, listNode);
   }
 
   return nullptr;
 }
 
 // Returns the previous list item with respect to the DOM order.
 static LayoutListItem* previousListItem(const Node* listNode,
                                         const LayoutListItem* item) {
   Node* current = item->node();
@@ skipping 122 matching lines @@
   LayoutObject* result = parent->slowFirstChild();
   while (result && result->isListMarker())
     result = result->nextSibling();
   return result;
 }
 
 bool LayoutListItem::updateMarkerLocation() {
   ASSERT(m_marker);
 
   LayoutObject* markerParent = m_marker->parent();
-  // list-style-position:inside makes the ::marker pseudo an ordinary position:static element that should be attached to LayoutListItem block.
+  // list-style-position:inside makes the ::marker pseudo an ordinary
+  // position:static element that should be attached to LayoutListItem block.
   LayoutObject* lineBoxParent =
       m_marker->isInside() ? this : getParentOfFirstLineBox(this, m_marker);
   if (!lineBoxParent) {
     // If the marker is currently contained inside an anonymous box, then we
     // are the only item in that anonymous box (since no line box parent was
     // found). It's ok to just leave the marker where it is in this case.
     if (markerParent && markerParent->isAnonymousBlock())
       lineBoxParent = markerParent;
     else
       lineBoxParent = this;
   }
 
   if (markerParent != lineBoxParent) {
     m_marker->remove();
     lineBoxParent->addChild(m_marker, firstNonMarkerChild(lineBoxParent));
-    // TODO(rhogan): lineBoxParent and markerParent may be deleted by addChild, so they are not safe to reference here.
-    // Once we have a safe way of referencing them delete markerParent if it is an empty anonymous block.
+    // TODO(rhogan): lineBoxParent and markerParent may be deleted by addChild,
+    // so they are not safe to reference here.
+    // Once we have a safe way of referencing them delete markerParent if it is
+    // an empty anonymous block.
     m_marker->updateMarginsAndContent();
     return true;
   }
 
   return false;
 }
 
 void LayoutListItem::addOverflowFromChildren() {
   LayoutBlockFlow::addOverflowFromChildren();
   positionListMarker();
@@ skipping 187 matching lines @@
   ASSERT(listNode);
 
   bool isListReversed = false;
   HTMLOListElement* oListElement =
       isHTMLOListElement(listNode) ? toHTMLOListElement(listNode) : 0;
   if (oListElement) {
     oListElement->itemCountChanged();
     isListReversed = oListElement->isReversed();
   }
 
-  // FIXME: The n^2 protection below doesn't help if the elements were inserted after the
-  // the list had already been displayed.
+  // FIXME: The n^2 protection below doesn't help if the elements were inserted
+  // after the the list had already been displayed.
 
-  // Avoid an O(n^2) walk over the children below when they're all known to be attaching.
+  // Avoid an O(n^2) walk over the children below when they're all known to be
+  // attaching.
   if (listNode->needsAttach())
     return;
 
   for (LayoutListItem* item =
            previousOrNextItem(isListReversed, listNode, this);
        item; item = previousOrNextItem(isListReversed, listNode, item)) {
     if (!item->m_isValueUpToDate) {
       // If an item has been marked for update before, we can safely
       // assume that all the following ones have too.
       // This gives us the opportunity to stop here and avoid
       // marking the same nodes again.
       break;
     }
     item->updateValue();
   }
 }
 
 }  // namespace blink