Rename repaint to paintInvalidation in core/rendering/compositing.

Source/core/rendering/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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 557 matching lines @@
     // the squashed RenderLayer described w.r.t. referenceLayer's origin. For this purpose we already cached
     // offsetFromSquashingCLM before, which describes where the squashed RenderLayer is located w.r.t.
     // referenceLayer. So we just need to convert that point from referenceLayer space to referenceLayer
     // space. This is simply done by subtracing squashLayerOriginInOwningLayerSpace, but then the offset
     // overall needs to be negated because that's the direction that the painting code expects the
     // offset to be.
     for (size_t i = 0; i < layers.size(); ++i) {
         LayoutPoint offsetFromTransformedAncestorForSquashedLayer = layers[i].renderLayer->computeOffsetFromTransformedAncestor();
         LayoutSize offsetFromSquashLayerOrigin = (offsetFromTransformedAncestorForSquashedLayer - referenceOffsetFromTransformedAncestor) - squashLayerOriginInOwningLayerSpace;
 
-        // It is ok to repaint here, because all of the geometry needed to correctly repaint is computed by this point.
+        // It is ok to issue paint invalidation here, because all of the geometry needed to correctly invalidate paint is computed by this point.
         IntSize newOffsetFromRenderer = -IntSize(offsetFromSquashLayerOrigin.width().round(), offsetFromSquashLayerOrigin.height().round());
         LayoutSize subpixelAccumulation = offsetFromSquashLayerOrigin + newOffsetFromRenderer;
         if (layers[i].offsetFromRendererSet && layers[i].offsetFromRenderer != newOffsetFromRenderer) {
-            layers[i].renderLayer->repainter().repaintIncludingNonCompositingDescendants();
+            layers[i].renderLayer->paintInvalidator().paintInvalidationIncludingNonCompositingDescendants();
             layersNeedingPaintInvalidation.append(layers[i].renderLayer);
         }
         layers[i].offsetFromRenderer = newOffsetFromRenderer;
         layers[i].offsetFromRendererSet = true;
 
         layers[i].renderLayer->setSubpixelAccumulation(subpixelAccumulation);
     }
 
     squashingLayer->setPosition(squashLayerBounds.location());
     squashingLayer->setSize(squashLayerBounds.size());
@@ skipping 801 matching lines @@
 {
     bool layerChanged = false;
     if (needsForegroundLayer) {
         if (!m_foregroundLayer) {
             m_foregroundLayer = createGraphicsLayer(CompositingReasonLayerForForeground);
             m_foregroundLayer->setDrawsContent(true);
             m_foregroundLayer->setPaintingPhase(GraphicsLayerPaintForeground);
             layerChanged = true;
         }
     } else if (m_foregroundLayer) {
-        FloatRect repaintRect(FloatPoint(), m_foregroundLayer->size());
         m_foregroundLayer->removeFromParent();
         m_foregroundLayer = nullptr;
         layerChanged = true;
     }
 
     return layerChanged;
 }
 
 bool CompositedLayerMapping::updateBackgroundLayer(bool needsBackgroundLayer)
 {
@@ skipping 470 matching lines @@
 
 bool CompositedLayerMapping::updateRequiresOwnBackingStoreForAncestorReasons(const RenderLayer* compositingAncestorLayer)
 {
     unsigned previousRequiresOwnBackingStoreForAncestorReasons = m_requiresOwnBackingStoreForAncestorReasons;
     bool previousPaintsIntoCompositedAncestor = paintsIntoCompositedAncestor();
     bool canPaintIntoAncestor = compositingAncestorLayer
         && (compositingAncestorLayer->compositedLayerMapping()->mainGraphicsLayer()->drawsContent()
             || compositingAncestorLayer->compositedLayerMapping()->paintsIntoCompositedAncestor());
 
     if (paintsIntoCompositedAncestor() != previousPaintsIntoCompositedAncestor)
-        compositor()->repaintOnCompositingChange(&m_owningLayer);
+        compositor()->paintInvalidationOnCompositingChange(&m_owningLayer);
 
     m_requiresOwnBackingStoreForAncestorReasons = !canPaintIntoAncestor;
 
     return m_requiresOwnBackingStoreForAncestorReasons != previousRequiresOwnBackingStoreForAncestorReasons;
 }
 
 bool CompositedLayerMapping::updateRequiresOwnBackingStoreForIntrinsicReasons()
 {
     unsigned previousRequiresOwnBackingStoreForIntrinsicReasons = m_requiresOwnBackingStoreForIntrinsicReasons;
     bool previousPaintsIntoCompositedAncestor = paintsIntoCompositedAncestor();
     RenderObject* renderer = m_owningLayer.renderer();
     m_requiresOwnBackingStoreForIntrinsicReasons = m_owningLayer.isRootLayer()
         || (m_owningLayer.compositingReasons() & CompositingReasonComboReasonsThatRequireOwnBacking)
         || m_owningLayer.transform()
         || m_owningLayer.clipsCompositingDescendantsWithBorderRadius() // FIXME: Revisit this if the paintsIntoCompositedAncestor state is removed.
         || renderer->isTransparent()
         || renderer->hasMask()
         || renderer->hasReflection()
         || renderer->hasFilter();
 
     if (paintsIntoCompositedAncestor() != previousPaintsIntoCompositedAncestor)
-        compositor()->repaintOnCompositingChange(&m_owningLayer);
+        compositor()->paintInvalidationOnCompositingChange(&m_owningLayer);
 
 
     return m_requiresOwnBackingStoreForIntrinsicReasons != previousRequiresOwnBackingStoreForIntrinsicReasons;
 }
 
 void CompositedLayerMapping::setBlendMode(blink::WebBlendMode blendMode)
 {
     if (m_ancestorClippingLayer) {
         m_ancestorClippingLayer->setBlendMode(blendMode);
         m_graphicsLayer->setBlendMode(blink::WebBlendModeNormal);
@@ skipping 17 matching lines @@
     }
 };
 
 void CompositedLayerMapping::setSquashingContentsNeedDisplay()
 {
     ApplyToGraphicsLayers(this, SetContentsNeedsDisplayFunctor(), ApplyToSquashingLayer);
 }
 
 void CompositedLayerMapping::setContentsNeedDisplay()
 {
-    // FIXME: need to split out repaints for the background.
+    // FIXME: need to split out paint invalidations for the background.
     ASSERT(!paintsIntoCompositedAncestor());
     ApplyToGraphicsLayers(this, SetContentsNeedsDisplayFunctor(), ApplyToContentLayers);
 }
 
 struct SetContentsNeedsDisplayInRectFunctor {
     void operator() (GraphicsLayer* layer) const
     {
         if (layer->drawsContent()) {
             IntRect layerDirtyRect = r;
             layerDirtyRect.move(-layer->offsetFromRenderer());
             layer->setNeedsDisplayInRect(layerDirtyRect);
         }
     }
 
     IntRect r;
 };
 
 // r is in the coordinate space of the layer's render object
 void CompositedLayerMapping::setContentsNeedDisplayInRect(const LayoutRect& r)
 {
-    // FIXME: need to split out repaints for the background.
+    // FIXME: need to split out paint invalidations for the background.
     ASSERT(!paintsIntoCompositedAncestor());
 
     SetContentsNeedsDisplayInRectFunctor functor = {
         pixelSnappedIntRect(r.location() + m_owningLayer.subpixelAccumulation(), r.size())
     };
     ApplyToGraphicsLayers(this, functor, ApplyToContentLayers);
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const RenderObject* renderObject, const Vector<GraphicsLayerPaintInfo>& layers)
 {
@@ skipping 175 matching lines @@
         m_owningLayer.scrollableArea()->paintResizer(&context, IntPoint(), transformedClip);
         context.restore();
     }
     InspectorInstrumentation::didPaint(m_owningLayer.renderer(), graphicsLayer, &context, clip);
 #if ENABLE(ASSERT)
     if (Page* page = renderer()->frame()->page())
         page->setIsPainting(false);
 #endif
 }
 
-bool CompositedLayerMapping::isTrackingRepaints() const
+bool CompositedLayerMapping::isTrackingPaintInvalidations() const
 {
     GraphicsLayerClient* client = compositor();
-    return client ? client->isTrackingRepaints() : false;
+    return client ? client->isTrackingPaintInvalidations() : false;
 }
 
 #if ENABLE(ASSERT)
 void CompositedLayerMapping::verifyNotPainting()
 {
     ASSERT(!renderer()->frame()->page() || !renderer()->frame()->page()->isPainting());
 }
 #endif
 
 void CompositedLayerMapping::notifyAnimationStarted(const GraphicsLayer*, double monotonicTime)
@@ skipping 15 matching lines @@
     GraphicsLayerPaintInfo paintInfo;
     paintInfo.renderLayer = squashedLayer;
     // NOTE: composited bounds are updated elsewhere
     // NOTE: offsetFromRenderer is updated elsewhere
 
     // Change tracking on squashing layers: at the first sign of something changed, just invalidate the layer.
     // FIXME: Perhaps we can find a tighter more clever mechanism later.
     bool updatedAssignment = false;
     if (nextSquashedLayerIndex < m_squashedLayers.size()) {
         if (paintInfo.renderLayer != m_squashedLayers[nextSquashedLayerIndex].renderLayer) {
-            compositor()->repaintOnCompositingChange(squashedLayer);
+            compositor()->paintInvalidationOnCompositingChange(squashedLayer);
             updatedAssignment = true;
             m_squashedLayers[nextSquashedLayerIndex] = paintInfo;
         }
     } else {
-        compositor()->repaintOnCompositingChange(squashedLayer);
+        compositor()->paintInvalidationOnCompositingChange(squashedLayer);
         m_squashedLayers.append(paintInfo);
         updatedAssignment = true;
     }
     squashedLayer->setGroupedMapping(this);
     return updatedAssignment;
 }
 
 void CompositedLayerMapping::removeRenderLayerFromSquashingGraphicsLayer(const RenderLayer* layer)
 {
     size_t layerIndex = kNotFound;
@@ skipping 60 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink