Rename repaint to paintInvalidation for remaining methods.

Source/core/rendering/RenderRegion.cpp

 /*
  * Copyright (C) 2011 Adobe Systems Incorporated. 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.
@@ skipping 101 matching lines @@
     // FIXME: We need to find a way to set up overflow properly. Our flow thread hasn't gotten a layout
     // yet, so we can't look to it for correct information. It's possible we could wait until after the RenderFlowThread
     // gets a layout, and then try to propagate overflow information back to the region, and then mark for a second layout.
     // That second layout would then be able to use the information from the RenderFlowThread to set up overflow.
     //
     // The big problem though is that overflow needs to be region-specific. We can't simply use the RenderFlowThread's global
     // overflow values, since then we'd always think any narrow region had huge overflow (all the way to the width of the
     // RenderFlowThread itself).
 }
 
-void RenderRegion::repaintFlowThreadContentRectangle(const LayoutRect& repaintRect, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const LayoutPoint& regionLocation) const
+void RenderRegion::paintInvalidaitonOfFlowThreadContentRectangle(const LayoutRect& paintInvalidationRect, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const LayoutPoint& regionLocation) const
 {
     ASSERT(isValid());
 
-    // We only have to issue a repaint in this region if the region rect intersects the repaint rect.
+    // We only have to issue a paint invalidation in this region if the region rect intersects the paint invalidation rect.
     LayoutRect flippedFlowThreadPortionRect(flowThreadPortionRect);
     LayoutRect flippedFlowThreadPortionOverflowRect(flowThreadPortionOverflowRect);
     flowThread()->flipForWritingMode(flippedFlowThreadPortionRect); // Put the region rects into physical coordinates.
     flowThread()->flipForWritingMode(flippedFlowThreadPortionOverflowRect);
 
-    LayoutRect clippedRect(repaintRect);
+    LayoutRect clippedRect(paintInvalidationRect);
     clippedRect.intersect(flippedFlowThreadPortionOverflowRect);
     if (clippedRect.isEmpty())
         return;
 
     // Put the region rect into the region's physical coordinate space.
     clippedRect.setLocation(regionLocation + (clippedRect.location() - flippedFlowThreadPortionRect.location()));
 
-    // Now switch to the region's writing mode coordinate space and let it repaint itself.
+    // Now switch to the region's writing mode coordinate space and let it issue paint invalidations itself.
     flipForWritingMode(clippedRect);
 
-    // Issue the repaint.
     invalidatePaintRectangle(clippedRect);
 }
 
 LayoutUnit RenderRegion::logicalTopOfFlowThreadContentRect(const LayoutRect& rect) const
 {
     ASSERT(isValid());
     return flowThread()->isHorizontalWritingMode() ? rect.y() : rect.x();
 }
 
 LayoutUnit RenderRegion::logicalBottomOfFlowThreadContentRect(const LayoutRect& rect) const
 {
     ASSERT(isValid());
     return flowThread()->isHorizontalWritingMode() ? rect.maxY() : rect.maxX();
 }
 
 void RenderRegion::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     if (!isValid()) {
         RenderBlockFlow::computeIntrinsicLogicalWidths(minLogicalWidth, maxLogicalWidth);
         return;
     }
 
     minLogicalWidth = m_flowThread->minPreferredLogicalWidth();
     maxLogicalWidth = m_flowThread->maxPreferredLogicalWidth();
 }
 
 } // namespace blink