Rename Repaint to Paint Invalidation part 3

Source/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 130 matching lines @@
 }
 
 void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyle)
 {
     RenderStyle* oldStyle = style();
     if (oldStyle) {
         // The background of the root element or the body element could propagate up to
         // the canvas.  Just dirty the entire canvas when our style changes substantially.
         if ((diff.needsRepaint() || diff.needsLayout()) && node()
             && (isHTMLHtmlElement(*node()) || isHTMLBodyElement(*node()))) {
-            view()->repaint();
+            view()->paintInvalidationForWholeRenderer();
 
             if (oldStyle->hasEntirelyFixedBackground() != newStyle.hasEntirelyFixedBackground())
                 view()->compositor()->setNeedsUpdateFixedBackground();
         }
 
         // When a layout hint happens and an object's position style changes, we have to do a layout
         // to dirty the render tree using the old position value now.
         if (diff.needsFullLayout() && parent() && oldStyle->position() != newStyle.position()) {
             markContainingBlocksForLayout();
             if (oldStyle->position() == StaticPosition)
-                repaint();
+                paintInvalidationForWholeRenderer();
             else if (newStyle.hasOutOfFlowPosition())
                 parent()->setChildNeedsLayout();
             if (isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
                 removeFloatingOrPositionedChildFromBlockLists();
         }
     // FIXME: This branch runs when !oldStyle, which means that layout was never called
     // so what's the point in invalidating the whole view that we never painted?
-    } else if (isBody())
-        view()->repaint();
+    } else if (isBody()) {
+        view()->paintInvalidationForWholeRenderer();
+    }
 
     RenderBoxModelObject::styleWillChange(diff, newStyle);
 }
 
 void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
 {
     // Horizontal writing mode definition is updated in RenderBoxModelObject::updateFromStyle,
     // (as part of the RenderBoxModelObject::styleDidChange call below). So, we can safely cache the horizontal
     // writing mode value before style change here.
     bool oldHorizontalWritingMode = isHorizontalWritingMode();
@@ skipping 103 matching lines @@
 
     bool boxHasOverflowClip = false;
     if (!styleToUse->isOverflowVisible() && isRenderBlock() && !isViewObject) {
         // If overflow has been propagated to the viewport, it has no effect here.
         if (node() != document().viewportDefiningElement()) {
             boxHasOverflowClip = true;
             if (!hasOverflowClip()) {
                 // If we are getting an overflow clip, preemptively erase any overflowing content.
                 // FIXME: This should probably consult RenderOverflow.
                 if (!RuntimeEnabledFeatures::repaintAfterLayoutEnabled())
-                    repaint();
+                    paintInvalidationForWholeRenderer();
             }
         }
     }
 
     if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled() && (boxHasOverflowClip != hasOverflowClip())) {
         // FIXME: This shouldn't be required if we tracked the visual overflow
         // generated by positioned children or self painting layers. crbug.com/345403
         for (RenderObject* child = slowFirstChild(); child; child = child->nextSibling())
             child->setShouldDoFullPaintInvalidationIfSelfPaintingLayer(true);
     }
@@ skipping 1188 matching lines @@
 
 void RenderBox::imageChanged(WrappedImagePtr image, const IntRect*)
 {
     if (!parent())
         return;
 
     AllowPaintInvalidationScope scoper(frameView());
 
     if ((style()->borderImage().image() && style()->borderImage().image()->data() == image) ||
         (style()->maskBoxImage().image() && style()->maskBoxImage().image()->data() == image)) {
-        repaint();
+        paintInvalidationForWholeRenderer();
         return;
     }
 
     ShapeValue* shapeOutsideValue = style()->shapeOutside();
     if (!frameView()->isInPerformLayout() && isFloating() && shapeOutsideValue && shapeOutsideValue->image() && shapeOutsideValue->image()->data() == image) {
         ShapeOutsideInfo::ensureInfo(*this).markShapeAsDirty();
         markShapeOutsideDependentsForLayout();
     }
 
     bool didFullRepaint = repaintLayerRectsForImage(image, style()->backgroundLayers(), true);
@@ skipping 35 matching lines @@
                     layerRenderer = this;
                     rendererRect = borderBoxRect();
                 }
             }
 
             BackgroundImageGeometry geometry;
             layerRenderer->calculateBackgroundImageGeometry(0, curLayer, rendererRect, geometry);
             if (geometry.hasNonLocalGeometry()) {
                 // Rather than incur the costs of computing the paintContainer for renderers with fixed backgrounds
                 // in order to get the right destRect, just repaint the entire renderer.
-                layerRenderer->repaint();
+                layerRenderer->paintInvalidationForWholeRenderer();
                 return true;
             }
 
-            layerRenderer->repaintRectangle(geometry.destRect());
+            layerRenderer->invalidatePaintRectangle(geometry.destRect());
             if (geometry.destRect() == rendererRect)
                 return true;
         }
     }
     return false;
 }
 
 void RenderBox::invalidateTreeAfterLayout(const RenderLayerModelObject& paintInvalidationContainer)
 {
     // FIXME: Currently only using this logic for RenderBox and its ilk. Ideally, RenderBlockFlows with
@@ skipping 30 matching lines @@
 
     if ((onlyNeededPositionedMovementLayout() && compositingState() != PaintsIntoOwnBacking)
         || (shouldDoFullPaintInvalidationIfSelfPaintingLayer()
             && hasLayer()
             && layer()->isSelfPaintingLayer())) {
         setShouldDoFullPaintInvalidationAfterLayout(true);
     }
 
     const LayoutRect& newPaintInvalidationRect = previousPaintInvalidationRect();
     const LayoutPoint& newPositionFromPaintInvalidationContainer = previousPositionFromPaintInvalidationContainer();
-    bool didFullPaintInvalidation = repaintAfterLayoutIfNeeded(&newPaintInvalidationContainer,
+    bool didFullPaintInvalidation = invalidatePaintAfterLayoutIfNeeded(&newPaintInvalidationContainer,
         shouldDoFullPaintInvalidationAfterLayout(), oldPaintInvalidationRect, oldPositionFromPaintInvalidationContainer,
         &newPaintInvalidationRect, &newPositionFromPaintInvalidationContainer);
 
     if (!didFullPaintInvalidation)
-        repaintOverflowIfNeeded();
+        invalidatePaintForOverflowIfNeeded();
 
     // Issue paint invalidations for any scrollbars if there is a scrollable area for this renderer.
     if (enclosingLayer()) {
         if (RenderLayerScrollableArea* area = enclosingLayer()->scrollableArea()) {
             if (area->hasVerticalBarDamage())
-                repaintRectangle(area->verticalBarDamage());
+                invalidatePaintRectangle(area->verticalBarDamage());
             if (area->hasHorizontalBarDamage())
-                repaintRectangle(area->horizontalBarDamage());
+                invalidatePaintRectangle(area->horizontalBarDamage());
             area->resetScrollbarDamage();
         }
     }
 
     // FIXME: LayoutState should be enabled for other paint invalidation containers than the RenderView. crbug.com/363834
     if (establishesNewPaintInvalidationContainer && !isRenderView()) {
         LayoutStateDisabler disabler(*this);
         RenderObject::invalidateTreeAfterLayout(newPaintInvalidationContainer);
     } else {
         // FIXME: This concept of a tree walking state for fast lookups should be generalized away from
@@ skipping 478 matching lines @@
     o->mapRectToRepaintBacking(repaintContainer, rect, fixed);
 }
 
 void RenderBox::repaintDuringLayoutIfMoved(const LayoutRect& oldRect)
 {
     if (oldRect.location() != m_frameRect.location()) {
         LayoutRect newRect = m_frameRect;
         // The child moved.  Invalidate the object's old and new positions.  We have to do this
         // since the object may not have gotten a layout.
         m_frameRect = oldRect;
-        repaint();
+        paintInvalidationForWholeRenderer();
         repaintOverhangingFloats(true);
         m_frameRect = newRect;
-        repaint();
+        paintInvalidationForWholeRenderer();
         repaintOverhangingFloats(true);
     }
 }
 
 void RenderBox::repaintOverhangingFloats(bool)
 {
 }
 
 void RenderBox::updateLogicalWidth()
 {
@@ skipping 2554 matching lines @@
         return 0;
 
     if (!layoutState && !flowThreadContainingBlock())
         return 0;
 
     RenderBlock* containerBlock = containingBlock();
     return containerBlock->offsetFromLogicalTopOfFirstPage() + logicalTop();
 }
 
 } // namespace WebCore