Rename repaint to paintInvalidation for remaining methods.

Source/core/rendering/RenderMultiColumnSet.cpp

 /*
  * Copyright (C) 2012 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 471 matching lines @@
             LayoutUnit ruleTop = isHorizontalWritingMode() ? paintOffset.y() + borderTop() + paddingTop() : paintOffset.y() + ruleLogicalLeft - ruleThickness / 2 + ruleAdd;
             LayoutUnit ruleBottom = isHorizontalWritingMode() ? ruleTop + contentHeight() : ruleTop + ruleThickness;
             IntRect pixelSnappedRuleRect = pixelSnappedIntRectFromEdges(ruleLeft, ruleTop, ruleRight, ruleBottom);
             drawLineForBoxSide(paintInfo.context, pixelSnappedRuleRect.x(), pixelSnappedRuleRect.y(), pixelSnappedRuleRect.maxX(), pixelSnappedRuleRect.maxY(), boxSide, ruleColor, ruleStyle, 0, 0, antialias);
         }
 
         ruleLogicalLeft = currLogicalLeftOffset;
     }
 }
 
-void RenderMultiColumnSet::repaintFlowThreadContent(const LayoutRect& repaintRect) const
+void RenderMultiColumnSet::paintInvalidationForFlowThreadContent(const LayoutRect& paintInvalidationRect) const
 {
     // Figure out the start and end columns and only check within that range so that we don't walk the
-    // entire column set. Put the repaint rect into flow thread coordinates by flipping it first.
-    LayoutRect flowThreadRepaintRect(repaintRect);
-    flowThread()->flipForWritingMode(flowThreadRepaintRect);
+    // entire column set. Put the paint invalidation rect into flow thread coordinates by flipping it first.
+    LayoutRect flowThreadPaintInvalidationRect(paintInvalidationRect);
+    flowThread()->flipForWritingMode(flowThreadPaintInvalidationRect);
 
     // Now we can compare this rect with the flow thread portions owned by each column. First let's
-    // just see if the repaint rect intersects our flow thread portion at all.
-    LayoutRect clippedRect(flowThreadRepaintRect);
+    // just see if the paint invalidation rect intersects our flow thread portion at all.
+    LayoutRect clippedRect(flowThreadPaintInvalidationRect);
     clippedRect.intersect(RenderRegion::flowThreadPortionOverflowRect());
     if (clippedRect.isEmpty())
         return;
 
     // Now we know we intersect at least one column. Let's figure out the logical top and logical
-    // bottom of the area we're repainting.
-    LayoutUnit repaintLogicalTop = isHorizontalWritingMode() ? flowThreadRepaintRect.y() : flowThreadRepaintRect.x();
-    LayoutUnit repaintLogicalBottom = (isHorizontalWritingMode() ? flowThreadRepaintRect.maxY() : flowThreadRepaintRect.maxX()) - 1;
+    // bottom of the area in which we're issuing paint invalidations.
+    LayoutUnit paintInvalidationLogicalTop = isHorizontalWritingMode() ? flowThreadPaintInvalidationRect.y() : flowThreadPaintInvalidationRect.x();
+    LayoutUnit paintInvalidationLogicalBottom = (isHorizontalWritingMode() ? flowThreadPaintInvalidationRect.maxY() : flowThreadPaintInvalidationRect.maxX()) - 1;
 
-    unsigned startColumn = columnIndexAtOffset(repaintLogicalTop);
-    unsigned endColumn = columnIndexAtOffset(repaintLogicalBottom);
+    unsigned startColumn = columnIndexAtOffset(paintInvalidationLogicalTop);
+    unsigned endColumn = columnIndexAtOffset(paintInvalidationLogicalBottom);
 
     LayoutUnit colGap = columnGap();
     unsigned colCount = actualColumnCount();
     for (unsigned i = startColumn; i <= endColumn; i++) {
         LayoutRect colRect = columnRectAt(i);
 
         // Get the portion of the flow thread that corresponds to this column.
         LayoutRect flowThreadPortion = flowThreadPortionRectAt(i);
 
         // Now get the overflow rect that corresponds to the column.
         LayoutRect flowThreadOverflowPortion = flowThreadPortionOverflowRect(flowThreadPortion, i, colCount, colGap);
 
-        // Do a repaint for this specific column.
-        repaintFlowThreadContentRectangle(repaintRect, flowThreadPortion, flowThreadOverflowPortion, colRect.location());
+        // Do a paint invalidation for this specific column.
+        paintInvalidaitonOfFlowThreadContentRectangle(paintInvalidationRect, flowThreadPortion, flowThreadOverflowPortion, colRect.location());
     }
 }
 
 void RenderMultiColumnSet::collectLayerFragments(LayerFragments& fragments, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect)
 {
     // The two rectangles passed to this method are physical, except that we pretend that there's
     // only one long column (that's how a flow thread works).
     //
     // Then there's the output from this method - the stuff we put into the list of fragments. The
     // fragment.paginationOffset point is the actual physical translation required to get from a
@@ skipping 147 matching lines @@
 
 void RenderMultiColumnSet::detachRegion()
 {
     if (m_flowThread) {
         m_flowThread->removeRegionFromThread(this);
         m_flowThread = 0;
     }
 }
 
 }