Rename "paint invalidation rect" etc. to "visual rect".

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>
@@ skipping 30 matching lines @@
 static inline bool compareOrderModifiedDocumentOrder(
     const std::pair<LayoutBox*, size_t>& firstItem,
     const std::pair<LayoutBox*, size_t>& secondItem) {
   return firstItem.second < secondItem.second;
 }
 
 void GridPainter::paintChildren(const PaintInfo& paintInfo,
                                 const LayoutPoint& paintOffset) {
   ASSERT(!m_layoutGrid.needsLayout());
 
-  LayoutRect localPaintInvalidationRect =
-      LayoutRect(paintInfo.cullRect().m_rect);
-  localPaintInvalidationRect.moveBy(-paintOffset);
+  LayoutRect localVisualRect = LayoutRect(paintInfo.cullRect().m_rect);
+  localVisualRect.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().
     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.
     std::sort(columnPositions.begin(), columnPositions.end());
   }
 
-  GridSpan dirtiedColumns =
-      dirtiedGridAreas(columnPositions, localPaintInvalidationRect.x(),
-                       localPaintInvalidationRect.maxX());
-  GridSpan dirtiedRows = dirtiedGridAreas(m_layoutGrid.rowPositions(),
-                                          localPaintInvalidationRect.y(),
-                                          localPaintInvalidationRect.maxY());
+  GridSpan dirtiedColumns = dirtiedGridAreas(
+      columnPositions, localVisualRect.x(), localVisualRect.maxX());
+  GridSpan dirtiedRows = dirtiedGridAreas(
+      m_layoutGrid.rowPositions(), localVisualRect.y(), localVisualRect.maxY());
 
   if (!m_layoutGrid.styleRef().isLeftToRightDirection()) {
     // 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) {
       const Vector<LayoutBox*, 1>& children =
           m_layoutGrid.gridCell(row, column);
       for (auto* child : children)
         gridItemsToBePainted.append(
             std::make_pair(child, m_layoutGrid.paintIndexForGridItem(child)));
     }
   }
 
   for (auto* item : m_layoutGrid.itemsOverflowingGridArea()) {
-    if (item->frameRect().intersects(localPaintInvalidationRect))
+    if (item->frameRect().intersects(localVisualRect))
       gridItemsToBePainted.append(
           std::make_pair(item, m_layoutGrid.paintIndexForGridItem(item)));
   }
 
   std::stable_sort(gridItemsToBePainted.begin(), gridItemsToBePainted.end(),
                    compareOrderModifiedDocumentOrder);
 
   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.
     LayoutBox* current = gridItemAndPaintIndex.first;
     if (current == previous)
       continue;
 
     BlockPainter(m_layoutGrid)
         .paintAllChildPhasesAtomically(*current, paintInfo, paintOffset);
     previous = current;
   }
 }
 
 }  // namespace blink