reflow comments in core/paint

third_party/WebKit/Source/core/paint/GridPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/GridPainter.h"
 
 #include "core/layout/LayoutGrid.h"
 #include "core/paint/BlockPainter.h"
 #include "core/paint/PaintInfo.h"
 #include <algorithm>
 
 namespace blink {
 
 static GridSpan dirtiedGridAreas(const Vector<LayoutUnit>& coordinates,
                                  LayoutUnit start,
                                  LayoutUnit end) {
   // This function does a binary search over the coordinates.
-  // This doesn't work with grid items overflowing their grid areas, but that is managed with m_gridItemsOverflowingGridArea.
+  // This doesn't work with grid items overflowing their grid areas, but that is
+  // managed with m_gridItemsOverflowingGridArea.
 
   size_t startGridAreaIndex =
       std::upper_bound(coordinates.begin(), coordinates.end() - 1, start) -
       coordinates.begin();
   if (startGridAreaIndex > 0)
     --startGridAreaIndex;
 
   size_t endGridAreaIndex =
       std::upper_bound(coordinates.begin() + startGridAreaIndex,
                        coordinates.end() - 1, end) -
@@ skipping 22 matching lines @@
 void GridPainter::paintChildren(const PaintInfo& paintInfo,
                                 const LayoutPoint& paintOffset) {
   ASSERT(!m_layoutGrid.needsLayout());
 
   LayoutRect localPaintInvalidationRect =
       LayoutRect(paintInfo.cullRect().m_rect);
   localPaintInvalidationRect.moveBy(-paintOffset);
 
   Vector<LayoutUnit> columnPositions = m_layoutGrid.columnPositions();
   if (!m_layoutGrid.styleRef().isLeftToRightDirection()) {
-    // Translate columnPositions in RTL as we need the physical coordinates of the columns in order to call dirtiedGridAreas().
+    // Translate columnPositions in RTL as we need the physical coordinates of
+    // the columns in order to call dirtiedGridAreas().
     for (size_t i = 0; i < columnPositions.size(); i++)
       columnPositions[i] =
           m_layoutGrid.translateRTLCoordinate(columnPositions[i]);
-    // We change the order of tracks in columnPositions, as in RTL the leftmost track will be the last one.
+    // We change the order of tracks in columnPositions, as in RTL the leftmost
+    // track will be the last one.
     std::sort(columnPositions.begin(), columnPositions.end());
   }
 
   GridSpan dirtiedColumns =
       dirtiedGridAreas(columnPositions, localPaintInvalidationRect.x(),
                        localPaintInvalidationRect.maxX());
   GridSpan dirtiedRows = dirtiedGridAreas(m_layoutGrid.rowPositions(),
                                           localPaintInvalidationRect.y(),
                                           localPaintInvalidationRect.maxY());
 
   if (!m_layoutGrid.styleRef().isLeftToRightDirection()) {
-    // As we changed the order of tracks previously, we need to swap the dirtied columns in RTL.
+    // As we changed the order of tracks previously, we need to swap the dirtied
+    // columns in RTL.
     size_t lastLine = columnPositions.size() - 1;
     dirtiedColumns = GridSpan::translatedDefiniteGridSpan(
         lastLine - dirtiedColumns.endLine(),
         lastLine - dirtiedColumns.startLine());
   }
 
   Vector<std::pair<LayoutBox*, size_t>> gridItemsToBePainted;
 
   for (const auto& row : dirtiedRows) {
     for (const auto& column : dirtiedColumns) {
@@ skipping 11 matching lines @@
           std::make_pair(item, m_layoutGrid.paintIndexForGridItem(item)));
   }
 
   // Sort grid items following order-modified document order.
   // See http://www.w3.org/TR/css-flexbox/#order-modified-document-order
   std::stable_sort(gridItemsToBePainted.begin(), gridItemsToBePainted.end(),
                    GridItemsSorter());
 
   LayoutBox* previous = 0;
   for (const auto& gridItemAndPaintIndex : gridItemsToBePainted) {
-    // We might have duplicates because of spanning children are included in all cells they span.
-    // Skip them here to avoid painting items several times.
+    // We might have duplicates because of spanning children are included in all
+    // cells they span.  Skip them here to avoid painting items several times.
     LayoutBox* current = gridItemAndPaintIndex.first;
     if (current == previous)
       continue;
 
     BlockPainter(m_layoutGrid)
         .paintAllChildPhasesAtomically(*current, paintInfo, paintOffset);
     previous = current;
   }
 }
 
 }  // namespace blink