Rename repaint to paintInvalidation in core/rendering/compositing.

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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 50 matching lines @@
 namespace blink {
 
 RenderLayerCompositor::RenderLayerCompositor(RenderView& renderView)
     : m_renderView(renderView)
     , m_compositingReasonFinder(renderView)
     , m_pendingUpdateType(CompositingUpdateNone)
     , m_hasAcceleratedCompositing(true)
     , m_compositing(false)
     , m_rootShouldAlwaysCompositeDirty(true)
     , m_needsUpdateFixedBackground(false)
-    , m_isTrackingRepaints(false)
+    , m_isTrackingPaintInvalidations(false)
     , m_rootLayerAttachment(RootLayerUnattached)
     , m_inOverlayFullscreenVideo(false)
 {
     updateAcceleratedCompositingSettings();
 }
 
 RenderLayerCompositor::~RenderLayerCompositor()
 {
     ASSERT(m_rootLayerAttachment == RootLayerUnattached);
 }
@@ skipping 222 matching lines @@
     if (!hasAcceleratedCompositing()) {
         updateWithoutAcceleratedCompositing(updateType);
         return;
     }
 
     if (updateType == CompositingUpdateNone)
         return;
 
     RenderLayer* updateRoot = rootRenderLayer();
 
-    Vector<RenderLayer*> layersNeedingRepaint;
+    Vector<RenderLayer*> layersNeedingPaintInvalidation;
 
     if (updateType >= CompositingUpdateAfterCompositingInputChange) {
         CompositingInputsUpdater(updateRoot).update();
 
 #if ENABLE(ASSERT)
         // FIXME: Move this check to the end of the compositing update.
         CompositingInputsUpdater::assertNeedsCompositingInputsUpdateBitsCleared(updateRoot);
 #endif
 
         CompositingRequirementsUpdater(m_renderView, m_compositingReasonFinder).update(updateRoot);
 
         CompositingLayerAssigner layerAssigner(this);
-        layerAssigner.assign(updateRoot, layersNeedingRepaint);
+        layerAssigner.assign(updateRoot, layersNeedingPaintInvalidation);
 
         bool layersChanged = layerAssigner.layersChanged();
 
         {
             TRACE_EVENT0("blink", "RenderLayerCompositor::updateAfterCompositingChange");
             if (const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView.frameView()->scrollableAreas()) {
                 for (FrameView::ScrollableAreaSet::iterator it = scrollableAreas->begin(); it != scrollableAreas->end(); ++it)
                     layersChanged |= (*it)->updateAfterCompositingChange();
             }
         }
 
         if (layersChanged)
             updateType = std::max(updateType, CompositingUpdateRebuildTree);
     }
 
     if (updateType != CompositingUpdateNone) {
         GraphicsLayerUpdater updater;
-        updater.update(*updateRoot, layersNeedingRepaint);
+        updater.update(*updateRoot, layersNeedingPaintInvalidation);
 
         if (updater.needsRebuildTree())
             updateType = std::max(updateType, CompositingUpdateRebuildTree);
 
 #if ENABLE(ASSERT)
         // FIXME: Move this check to the end of the compositing update.
         GraphicsLayerUpdater::assertNeedsToUpdateGraphicsLayerBitsCleared(*updateRoot);
 #endif
     }
 
@@ skipping 13 matching lines @@
 
         if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled())
             applyOverlayFullscreenVideoAdjustment();
     }
 
     if (m_needsUpdateFixedBackground) {
         rootFixedBackgroundsChanged();
         m_needsUpdateFixedBackground = false;
     }
 
-    for (unsigned i = 0; i < layersNeedingRepaint.size(); i++) {
-        RenderLayer* layer = layersNeedingRepaint[i];
-        layer->repainter().computeRepaintRectsIncludingNonCompositingDescendants();
+    for (unsigned i = 0; i < layersNeedingPaintInvalidation.size(); i++) {
+        RenderLayer* layer = layersNeedingPaintInvalidation[i];
+        layer->paintInvalidator().computePaintInvalidationRectsIncludingNonCompositingDescendants();
 
-        repaintOnCompositingChange(layer);
+        paintInvalidationOnCompositingChange(layer);
     }
 
     // Inform the inspector that the layer tree has changed.
     if (m_renderView.frame()->isMainFrame())
         InspectorInstrumentation::layerTreeDidChange(m_renderView.frame());
 }
 
 bool RenderLayerCompositor::allocateOrClearCompositedLayerMapping(RenderLayer* layer, const CompositingStateTransitionType compositedLayerUpdate)
 {
     bool compositedLayerMappingChanged = false;
 
     // FIXME: It would be nice to directly use the layer's compositing reason,
     // but allocateOrClearCompositedLayerMapping also gets called without having updated compositing
     // requirements fully.
     switch (compositedLayerUpdate) {
     case AllocateOwnCompositedLayerMapping:
         ASSERT(!layer->hasCompositedLayerMapping());
         setCompositingModeEnabled(true);
 
-        // If we need to repaint, do so before allocating the compositedLayerMapping and clearing out the groupedMapping.
-        repaintOnCompositingChange(layer);
+        // If we need to issue paint invalidations, do so before allocating the compositedLayerMapping and clearing out the groupedMapping.
+        paintInvalidationOnCompositingChange(layer);
 
         // If this layer was previously squashed, we need to remove its reference to a groupedMapping right away, so
-        // that computing repaint rects will know the layer's correct compositingState.
+        // that computing paint invalidation rects will know the layer's correct compositingState.
         // FIXME: do we need to also remove the layer from it's location in the squashing list of its groupedMapping?
         // Need to create a test where a squashed layer pops into compositing. And also to cover all other
         // sorts of compositingState transitions.
         layer->setLostGroupedMapping(false);
         layer->setGroupedMapping(0);
 
         layer->ensureCompositedLayerMapping();
         compositedLayerMappingChanged = true;
 
         // At this time, the ScrollingCooridnator only supports the top-level frame.
@@ skipping 43 matching lines @@
     // If a fixed position layer gained/lost a compositedLayerMapping or the reason not compositing it changed,
     // the scrolling coordinator needs to recalculate whether it can do fast scrolling.
     if (compositedLayerMappingChanged) {
         if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
             scrollingCoordinator->frameViewFixedObjectsDidChange(m_renderView.frameView());
     }
 
     return compositedLayerMappingChanged;
 }
 
-void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer)
+void RenderLayerCompositor::paintInvalidationOnCompositingChange(RenderLayer* layer)
 {
-    // If the renderer is not attached yet, no need to repaint.
+    // If the renderer is not attached yet, no need to issue paint invalidations.
     if (layer->renderer() != &m_renderView && !layer->renderer()->parent())
         return;
 
-    layer->repainter().repaintIncludingNonCompositingDescendants();
+    layer->paintInvalidator().paintInvalidationIncludingNonCompositingDescendants();
 }
 
 void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
 {
     if (m_overflowControlsHostLayer)
         m_overflowControlsHostLayer->setPosition(contentsOffset);
 }
 
 void RenderLayerCompositor::frameViewDidChangeSize()
 {
@@ skipping 88 matching lines @@
     // We skip dumping the scroll and clip layers to keep layerTreeAsText output
     // similar between platforms (unless we explicitly request dumping from the
     // root.
     GraphicsLayer* rootLayer = m_rootContentLayer.get();
     if (flags & LayerTreeIncludesRootLayer)
         rootLayer = rootGraphicsLayer();
 
     String layerTreeText = rootLayer->layerTreeAsText(flags);
 
     // The true root layer is not included in the dump, so if we want to report
-    // its repaint rects, they must be included here.
-    if (flags & LayerTreeIncludesRepaintRects)
+    // its paint invalidation rects, they must be included here.
+    if (flags & LayerTreeIncludesPaintInvalidationRects)
         return m_renderView.frameView()->trackedPaintInvalidationRectsAsText() + layerTreeText;
 
     return layerTreeText;
 }
 
 RenderLayerCompositor* RenderLayerCompositor::frameContentsCompositor(RenderPart* renderer)
 {
     if (!renderer->node()->isFrameOwnerElement())
         return 0;
 
@@ skipping 212 matching lines @@
     RenderLayer* viewLayer = m_renderView.layer();
     if (!viewLayer)
         return 0;
 
     if (viewLayer->compositingState() == PaintsIntoOwnBacking && viewLayer->compositedLayerMapping()->backgroundLayerPaintsFixedRootBackground())
         return viewLayer->compositedLayerMapping()->backgroundLayer();
 
     return 0;
 }
 
-static void resetTrackedRepaintRectsRecursive(GraphicsLayer* graphicsLayer)
+static void resetTrackedPaintInvalidationRectsRecursive(GraphicsLayer* graphicsLayer)
 {
     if (!graphicsLayer)
         return;
 
-    graphicsLayer->resetTrackedRepaints();
+    graphicsLayer->resetTrackedPaintInvalidations();
 
     for (size_t i = 0; i < graphicsLayer->children().size(); ++i)
-        resetTrackedRepaintRectsRecursive(graphicsLayer->children()[i]);
+        resetTrackedPaintInvalidationRectsRecursive(graphicsLayer->children()[i]);
 
     if (GraphicsLayer* replicaLayer = graphicsLayer->replicaLayer())
-        resetTrackedRepaintRectsRecursive(replicaLayer);
+        resetTrackedPaintInvalidationRectsRecursive(replicaLayer);
 
     if (GraphicsLayer* maskLayer = graphicsLayer->maskLayer())
-        resetTrackedRepaintRectsRecursive(maskLayer);
+        resetTrackedPaintInvalidationRectsRecursive(maskLayer);
 
     if (GraphicsLayer* clippingMaskLayer = graphicsLayer->contentsClippingMaskLayer())
-        resetTrackedRepaintRectsRecursive(clippingMaskLayer);
+        resetTrackedPaintInvalidationRectsRecursive(clippingMaskLayer);
 }
 
-void RenderLayerCompositor::resetTrackedRepaintRects()
+void RenderLayerCompositor::resetTrackedPaintInvalidationRects()
 {
     if (GraphicsLayer* rootLayer = rootGraphicsLayer())
-        resetTrackedRepaintRectsRecursive(rootLayer);
+        resetTrackedPaintInvalidationRectsRecursive(rootLayer);
 }
 
-void RenderLayerCompositor::setTracksRepaints(bool tracksRepaints)
+void RenderLayerCompositor::setTracksPaintInvalidations(bool tracksPaintInvalidations)
 {
     ASSERT(lifecycle().state() == DocumentLifecycle::PaintInvalidationClean);
-    m_isTrackingRepaints = tracksRepaints;
+    m_isTrackingPaintInvalidations = tracksPaintInvalidations;
 }
 
-bool RenderLayerCompositor::isTrackingRepaints() const
+bool RenderLayerCompositor::isTrackingPaintInvalidations() const
 {
-    return m_isTrackingRepaints;
+    return m_isTrackingPaintInvalidations;
 }
 
 static bool shouldCompositeOverflowControls(FrameView* view)
 {
     if (Page* page = view->frame().page()) {
         if (ScrollingCoordinator* scrollingCoordinator = page->scrollingCoordinator())
             if (scrollingCoordinator->coordinatesScrollingForFrameView(view))
                 return true;
     }
 
@@ skipping 301 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink