Rename Repaint to Paint Invalidation Part 4

Source/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 244 matching lines @@
 {
     TRACE_EVENT0("blink_rendering", "RenderLayer::updateLayerPositionsAfterLayout");
 
     // FIXME: Remove incremental compositing updates after fixing the chicken/egg issues
     // https://code.google.com/p/chromium/issues/detail?id=343756
     DisableCompositingQueryAsserts disabler;
 
     RenderGeometryMap geometryMap(UseTransforms);
     if (this != rootLayer)
         geometryMap.pushMappingsToAncestor(parent(), 0);
-    updateLayerPositionRecursive(&geometryMap, rootLayer->renderer()->containerForRepaint(), flags);
+    updateLayerPositionRecursive(&geometryMap, rootLayer->renderer()->containerForPaintInvalidation(), flags);
 }
 
 void RenderLayer::updateLayerPositionRecursive(RenderGeometryMap* geometryMap, const RenderLayerModelObject* paintInvalidationContainer, UpdateLayerPositionsFlags flags)
 {
     // For performance reasons we only check if the RenderObject has moved if we
     // have a geometryMap. If not, blank out the paint invalidation container so we
     // can skip doing any further work to update it.
     if (!geometryMap)
         paintInvalidationContainer = 0;
 
@@ skipping 194 matching lines @@
 
     if (renderer()->hasOverflowClip())
         flags |= HasSeenAncestorWithOverflowClip;
 
     if ((flags & IsOverflowScroll) && (flags & HasSeenAncestorWithOverflowClip) && !m_canSkipRepaintRectsUpdateOnScroll) {
         // FIXME: We could track the repaint container as we walk down the tree.
         repainter().computeRepaintRects();
     } else {
         // Check that RenderLayerRepainter's cached rects are correct.
         // FIXME: re-enable these assertions when the issue with table cells is resolved: https://bugs.webkit.org/show_bug.cgi?id=103432
-        // ASSERT(repainter().m_repaintRect == renderer()->clippedOverflowRectForRepaint(renderer()->containerForRepaint()));
+        // ASSERT(repainter().m_repaintRect == renderer()->clippedOverflowRectForPaintInvalidation(renderer()->containerForPaintInvalidation()));
     }
 
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->updateLayerPositionsAfterScroll(flags);
 
     // We don't update our reflection as scrolling is a translation which does not change the size()
     // of an object, thus RenderReplica will still repaint itself properly as the layer position was
     // updated above.
 }
 
@@ skipping 181 matching lines @@
             return;
         }
         if (curr->stackingNode() == ancestorStackingContextNode)
             return;
     }
 }
 
 void RenderLayer::mapRectToRepaintBacking(const RenderObject* renderObject, const RenderLayerModelObject* repaintContainer, LayoutRect& rect)
 {
     if (!repaintContainer->groupedMapping()) {
-        renderObject->mapRectToRepaintBacking(repaintContainer, rect);
+        renderObject->mapRectToPaintInvalidationBacking(repaintContainer, rect);
         return;
     }
 
     ASSERT(repaintContainer->layer()->enclosingTransformedAncestor());
     ASSERT(repaintContainer->layer()->enclosingTransformedAncestor()->renderer());
 
     // FIXME: this defensive code should not have to exist. None of these pointers should ever be 0. See crbug.com/370410.
     RenderLayerModelObject* transformedAncestor = 0;
     if (RenderLayer* ancestor = repaintContainer->layer()->enclosingTransformedAncestor())
         transformedAncestor = ancestor->renderer();
     if (!transformedAncestor)
         return;
 
     // If the transformedAncestor is actually the RenderView, we might get
     // confused and think that we can use LayoutState. Ideally, we'd made
     // LayoutState work for all composited layers as well, but until then
     // we need to disable LayoutState for squashed layers.
     LayoutStateDisabler layoutStateDisabler(*transformedAncestor);
 
     // This code adjusts the repaint rectangle to be in the space of the transformed ancestor of the grouped (i.e. squashed)
     // layer. This is because all layers that squash together need to repaint w.r.t. a single container that is
     // an ancestor of all of them, in order to properly take into account any local transforms etc.
     // FIXME: remove this special-case code that works around the repainting code structure.
-    renderObject->mapRectToRepaintBacking(transformedAncestor, rect);
+    renderObject->mapRectToPaintInvalidationBacking(transformedAncestor, rect);
     rect.moveBy(-repaintContainer->groupedMapping()->squashingOffsetFromTransformedAncestor());
 
     return;
 }
 
 LayoutRect RenderLayer::computeRepaintRect(const RenderObject* renderObject, const RenderLayer* repaintContainer)
 {
     if (!repaintContainer->groupedMapping())
-        return renderObject->computeRepaintRect(repaintContainer->renderer());
-    LayoutRect rect = renderObject->clippedOverflowRectForRepaint(repaintContainer->renderer());
+        return renderObject->computePaintInvalidationRect(repaintContainer->renderer());
+    LayoutRect rect = renderObject->clippedOverflowRectForPaintInvalidation(repaintContainer->renderer());
     mapRectToRepaintBacking(repaintContainer->renderer(), repaintContainer->renderer(), rect);
     return rect;
 }
 
 void RenderLayer::setHasVisibleContent()
 {
     if (m_hasVisibleContent && !m_visibleContentStatusDirty) {
         ASSERT(!parent() || parent()->hasVisibleDescendant());
         return;
     }
@@ skipping 3137 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif