Rename Repaint to Paint Invalidation Part 4

Source/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 108 matching lines @@
 #endif
 
 struct SameSizeAsRenderObject {
     virtual ~SameSizeAsRenderObject() { } // Allocate vtable pointer.
     void* pointers[5];
 #ifndef NDEBUG
     unsigned m_debugBitfields : 2;
 #endif
     unsigned m_bitfields;
     unsigned m_bitfields2;
-    LayoutRect rect; // Stores the previous repaint rect.
-    LayoutPoint position; // Stores the previous position from the repaint container.
+    LayoutRect rect; // Stores the previous paint invalidation rect.
+    LayoutPoint position; // Stores the previous position from the paint invalidation container.
 };
 
 COMPILE_ASSERT(sizeof(RenderObject) == sizeof(SameSizeAsRenderObject), RenderObject_should_stay_small);
 
 bool RenderObject::s_affectsParentBlock = false;
 
 void* RenderObject::operator new(size_t sz)
 {
     ASSERT(isMainThread());
     return partitionAlloc(Partitions::getRenderingPartition(), sz);
@@ skipping 601 matching lines @@
 
         o->m_bitfields.setPreferredLogicalWidthsDirty(true);
         if (o->style()->hasOutOfFlowPosition())
             // A positioned object has no effect on the min/max width of its containing block ever.
             // We can optimize this case and not go up any further.
             break;
         o = container;
     }
 }
 
-void RenderObject::setLayerNeedsFullRepaintForPositionedMovementLayout()
+void RenderObject::setLayerNeedsFullPaintInvalidationForPositionedMovementLayout()
 {
     ASSERT(hasLayer());
     toRenderLayerModelObject(this)->layer()->repainter().setRepaintStatus(NeedsFullRepaintForPositionedMovementLayout);
 }
 
-RenderBlock* RenderObject::containerForFixedPosition(const RenderLayerModelObject* repaintContainer, bool* repaintContainerSkipped) const
+RenderBlock* RenderObject::containerForFixedPosition(const RenderLayerModelObject* paintInvalidationContainer, bool* paintInvalidationContainerSkipped) const
 {
-    ASSERT(!repaintContainerSkipped || !*repaintContainerSkipped);
+    ASSERT(!paintInvalidationContainerSkipped || !*paintInvalidationContainerSkipped);
     ASSERT(!isText());
     ASSERT(style()->position() == FixedPosition);
 
     RenderObject* ancestor = parent();
     for (; ancestor && !ancestor->canContainFixedPositionObjects(); ancestor = ancestor->parent()) {
-        if (repaintContainerSkipped && ancestor == repaintContainer)
-            *repaintContainerSkipped = true;
+        if (paintInvalidationContainerSkipped && ancestor == paintInvalidationContainer)
+            *paintInvalidationContainerSkipped = true;
     }
 
     ASSERT(!ancestor || !ancestor->isAnonymousBlock());
     return toRenderBlock(ancestor);
 }
 
 RenderBlock* RenderObject::containingBlock() const
 {
     RenderObject* o = parent();
     if (!o && isRenderScrollbarPart())
@@ skipping 61 matching lines @@
 }
 
 bool RenderObject::canRenderBorderImage() const
 {
     ASSERT(style()->hasBorder());
 
     StyleImage* borderImage = style()->borderImage().image();
     return borderImage && borderImage->canRender(*this, style()->effectiveZoom()) && borderImage->isLoaded();
 }
 
-bool RenderObject::mustRepaintFillLayersOnWidthChange(const FillLayer& layer) const
+bool RenderObject::mustInvalidateFillLayersPaintOnWidthChange(const FillLayer& layer) const
 {
     // Nobody will use multiple layers without wanting fancy positioning.
     if (layer.next())
         return true;
 
     // Make sure we have a valid image.
     StyleImage* img = layer.image();
     if (!img || !img->canRender(*this, style()->effectiveZoom()))
         return false;
 
@@ skipping 16 matching lines @@
             return true;
         if (img->isGeneratedImage() && layer.sizeLength().width().isAuto())
             return true;
     } else if (img->usesImageContainerSize()) {
         return true;
     }
 
     return false;
 }
 
-bool RenderObject::mustRepaintFillLayersOnHeightChange(const FillLayer& layer) const
+bool RenderObject::mustInvalidateFillLayersPaintOnHeightChange(const FillLayer& layer) const
 {
     // Nobody will use multiple layers without wanting fancy positioning.
     if (layer.next())
         return true;
 
     // Make sure we have a valid image.
     StyleImage* img = layer.image();
     if (!img || !img->canRender(*this, style()->effectiveZoom()))
         return false;
 
@@ skipping 16 matching lines @@
             return true;
         if (img->isGeneratedImage() && layer.sizeLength().height().isAuto())
             return true;
     } else if (img->usesImageContainerSize()) {
         return true;
     }
 
     return false;
 }
 
-bool RenderObject::mustRepaintBackgroundOrBorderOnWidthChange() const
+bool RenderObject::mustInvalidateBackgroundOrBorderPaintOnWidthChange() const
 {
-    if (hasMask() && mustRepaintFillLayersOnWidthChange(*style()->maskLayers()))
+    if (hasMask() && mustInvalidateFillLayersPaintOnWidthChange(*style()->maskLayers()))
         return true;
 
     // If we don't have a background/border/mask, then nothing to do.
     if (!hasBoxDecorations())
         return false;
 
-    if (mustRepaintFillLayersOnWidthChange(*style()->backgroundLayers()))
+    if (mustInvalidateFillLayersPaintOnWidthChange(*style()->backgroundLayers()))
         return true;
 
     // Our fill layers are ok. Let's check border.
     if (style()->hasBorder() && canRenderBorderImage())
         return true;
 
     return false;
 }
 
-bool RenderObject::mustRepaintBackgroundOrBorderOnHeightChange() const
+bool RenderObject::mustInvalidateBackgroundOrBorderPaintOnHeightChange() const
 {
-    if (hasMask() && mustRepaintFillLayersOnHeightChange(*style()->maskLayers()))
+    if (hasMask() && mustInvalidateFillLayersPaintOnHeightChange(*style()->maskLayers()))
         return true;
 
     // If we don't have a background/border/mask, then nothing to do.
     if (!hasBoxDecorations())
         return false;
 
-    if (mustRepaintFillLayersOnHeightChange(*style()->backgroundLayers()))
+    if (mustInvalidateFillLayersPaintOnHeightChange(*style()->backgroundLayers()))
         return true;
 
     // Our fill layers are ok.  Let's check border.
     if (style()->hasBorder() && canRenderBorderImage())
         return true;
 
     return false;
 }
 
 void RenderObject::drawLineForBoxSide(GraphicsContext* graphicsContext, int x1, int y1, int x2, int y2,
@@ skipping 368 matching lines @@
                 pos.move(box->locationOffset()); // FIXME: Snap offsets? crbug.com/350474
                 box->addFocusRingRects(rects, flooredIntPoint(pos), paintContainer);
             }
         } else {
             current->addFocusRingRects(rects, additionalOffset, paintContainer);
         }
     }
 }
 
 // FIXME: In repaint-after-layout, we should be able to change the logic to remove the need for this function. See crbug.com/368416.
-LayoutPoint RenderObject::positionFromRepaintContainer(const RenderLayerModelObject* repaintContainer) const
+LayoutPoint RenderObject::positionFromPaintInvalidationContainer(const RenderLayerModelObject* paintInvalidationContainer) const
 {
-    // FIXME: This assert should be re-enabled when we move repaint to after compositing update. crbug.com/360286
-    // ASSERT(containerForRepaint() == repaintContainer);
+    // FIXME: This assert should be re-enabled when we move paint invalidation to after compositing update. crbug.com/360286
+    // ASSERT(containerForPaintInvalidation() == paintInvalidationContainer);
 
     LayoutPoint offset = isBox() ? toRenderBox(this)->location() : LayoutPoint();
-    if (repaintContainer == this)
+    if (paintInvalidationContainer == this)
         return offset;
 
-    return roundedIntPoint(localToContainerPoint(offset, repaintContainer));
+    return roundedIntPoint(localToContainerPoint(offset, paintInvalidationContainer));
 }
 
 IntRect RenderObject::absoluteBoundingBoxRect() const
 {
     Vector<FloatQuad> quads;
     absoluteQuads(quads);
 
     size_t n = quads.size();
     if (!n)
         return IntRect();
@@ skipping 16 matching lines @@
 
     LayoutRect result = rects[0];
     for (size_t i = 1; i < n; ++i)
         result.unite(rects[i]);
     return pixelSnappedIntRect(result);
 }
 
 void RenderObject::absoluteFocusRingQuads(Vector<FloatQuad>& quads)
 {
     Vector<IntRect> rects;
-    const RenderLayerModelObject* container = containerForRepaint();
+    const RenderLayerModelObject* container = containerForPaintInvalidation();
     addFocusRingRects(rects, LayoutPoint(localToContainerPoint(FloatPoint(), container)), container);
     size_t count = rects.size();
     for (size_t i = 0; i < count; ++i)
         quads.append(container->localToAbsoluteQuad(FloatQuad(rects[i])));
 }
 
 FloatRect RenderObject::absoluteBoundingBoxRectForRange(const Range* range)
 {
     if (!range || !range->startContainer())
         return FloatRect();
@@ skipping 24 matching lines @@
     topLevelRect = result;
     for (RenderObject* current = slowFirstChild(); current; current = current->nextSibling())
         current->addAbsoluteRectForLayer(result);
     return result;
 }
 
 void RenderObject::paint(PaintInfo&, const LayoutPoint&)
 {
 }
 
-const RenderLayerModelObject* RenderObject::containerForRepaint() const
+const RenderLayerModelObject* RenderObject::containerForPaintInvalidation() const
 {
     if (!isRooted())
         return 0;
 
     return adjustCompositedContainerForSpecialAncestors(enclosingCompositedContainer());
 }
 
 const RenderLayerModelObject* RenderObject::enclosingCompositedContainer() const
 {
     RenderLayerModelObject* container = 0;
     if (view()->usesCompositing()) {
         // FIXME: CompositingState is not necessarily up to date for many callers of this function.
         DisableCompositingQueryAsserts disabler;
 
         if (RenderLayer* compositingLayer = enclosingLayer()->enclosingCompositingLayerForRepaint())
             container = compositingLayer->renderer();
     }
     return container;
 }
 
-const RenderLayerModelObject* RenderObject::adjustCompositedContainerForSpecialAncestors(const RenderLayerModelObject* repaintContainer) const
+const RenderLayerModelObject* RenderObject::adjustCompositedContainerForSpecialAncestors(const RenderLayerModelObject* paintInvalidationContainer) const
 {
 
     if (document().view()->hasSoftwareFilters()) {
         if (RenderLayer* enclosingFilterLayer = enclosingLayer()->enclosingFilterLayer())
             return enclosingFilterLayer->renderer();
     }
 
-    // If we have a flow thread, then we need to do individual repaints within the RenderRegions instead.
-    // Return the flow thread as a repaint container in order to create a chokepoint that allows us to change
-    // repainting to do individual region repaints.
+    // If we have a flow thread, then we need to do individual paint invalidations within the RenderRegions instead.
+    // Return the flow thread as a paint invalidation container in order to create a chokepoint that allows us to change
+    // paint invalidation to do individual region paint invalidations.
     if (RenderFlowThread* parentRenderFlowThread = flowThreadContainingBlock()) {
-        // If we have already found a repaint container then we will repaint into that container only if it is part of the same
-        // flow thread. Otherwise we will need to catch the repaint call and send it to the flow thread.
-        if (!repaintContainer || repaintContainer->flowThreadContainingBlock() != parentRenderFlowThread)
-            repaintContainer = parentRenderFlowThread;
+        // If we have already found a paint invalidation container then we will invalidate paints in that container only if it is part of the same
+        // flow thread. Otherwise we will need to catch the paint invalidation call and send it to the flow thread.
+        if (!paintInvalidationContainer || paintInvalidationContainer->flowThreadContainingBlock() != parentRenderFlowThread)
+            paintInvalidationContainer = parentRenderFlowThread;
     }
-    return repaintContainer ? repaintContainer : view();
+    return paintInvalidationContainer ? paintInvalidationContainer : view();
 }
 
-bool RenderObject::isRepaintContainer() const
+bool RenderObject::isPaintInvalidationContainer() const
 {
     return hasLayer() && toRenderLayerModelObject(this)->layer()->isRepaintContainer();
 }
 
 template<typename T> PassRefPtr<JSONValue> jsonObjectForRect(const T& rect)
 {
     RefPtr<JSONObject> object = JSONObject::create();
     object->setNumber("x", rect.x());
     object->setNumber("y", rect.y());
     object->setNumber("width", rect.width());
     object->setNumber("height", rect.height());
     return object.release();
 }
 
-static PassRefPtr<JSONValue> jsonObjectForRepaintInfo(const IntRect& rect, const String& invalidationReason)
+static PassRefPtr<JSONValue> jsonObjectForPaintInvalidationInfo(const IntRect& rect, const String& invalidationReason)
 {
     RefPtr<JSONObject> object = JSONObject::create();
     object->setValue("rect", jsonObjectForRect(rect));
     object->setString("invalidation_reason", invalidationReason);
     return object.release();
 }
 
-LayoutRect RenderObject::computeRepaintRect(const RenderLayerModelObject* repaintContainer) const
+LayoutRect RenderObject::computePaintInvalidationRect(const RenderLayerModelObject* paintInvalidationContainer) const
 {
-    return clippedOverflowRectForRepaint(repaintContainer);
+    return clippedOverflowRectForPaintInvalidation(paintInvalidationContainer);
 }
 
 void RenderObject::invalidatePaintUsingContainer(const RenderLayerModelObject* paintInvalidationContainer, const IntRect& r, InvalidationReason invalidationReason) const
 {
     if (r.isEmpty())
         return;
 
     // FIXME: This should be an assert, but editing/selection can trigger this case to invalidate
     // the selection. crbug.com/368140.
     if (!isRooted())
         return;
 
     TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "RenderObject::invalidatePaintUsingContainer()",
         "object", this->debugName().ascii(),
-        "info", TracedValue::fromJSONValue(jsonObjectForRepaintInfo(r, invalidationReasonToString(invalidationReason))));
+        "info", TracedValue::fromJSONValue(jsonObjectForPaintInvalidationInfo(r, invalidationReasonToString(invalidationReason))));
 
     // FIXME: Don't read compositing state here since we do this in the middle of recalc/layout.
     DisableCompositingQueryAsserts disabler;
     if (paintInvalidationContainer->compositingState() == PaintsIntoGroupedBacking) {
         ASSERT(paintInvalidationContainer->groupedMapping());
         ASSERT(paintInvalidationContainer->layer());
 
         // Not clean, but if squashing layer does not yet exist here (e.g. paint invalidation coming from within recomputing compositing requirements)
         // then it's ok to just exit here, since the squashing layer will get invalidate when it is newly created.
         if (!paintInvalidationContainer->groupedMapping()->squashingLayer())
@@ skipping 27 matching lines @@
 {
     if (!isRooted())
         return;
 
     if (view()->document().printing())
         return; // Don't invalidate paints if we're printing.
 
     // FIXME: really, we're in the paint invalidation phase here, and the following queries are legal.
     // Until those states are fully fledged, I'll just disable the ASSERTS.
     DisableCompositingQueryAsserts disabler;
-    const RenderLayerModelObject* paintInvalidationContainer = containerForRepaint();
-    LayoutRect paintInvalidationRect = boundsRectForRepaint(paintInvalidationContainer);
-    invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(paintInvalidationRect), InvalidationRepaint);
+    const RenderLayerModelObject* paintInvalidationContainer = containerForPaintInvalidation();
+    LayoutRect paintInvalidationRect = boundsRectForPaintInvalidation(paintInvalidationContainer);
+    invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(paintInvalidationRect), InvalidationPaint);
 }
 
-LayoutRect RenderObject::boundsRectForRepaint(const RenderLayerModelObject* repaintContainer) const
+LayoutRect RenderObject::boundsRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer) const
 {
-    if (!repaintContainer)
-        return computeRepaintRect(repaintContainer);
-    return RenderLayer::computeRepaintRect(this, repaintContainer->layer());
+    if (!paintInvalidationContainer)
+        return computePaintInvalidationRect(paintInvalidationContainer);
+    return RenderLayer::computeRepaintRect(this, paintInvalidationContainer->layer());
 }
 
 void RenderObject::invalidatePaintRectangle(const LayoutRect& r) const
 {
     if (!isRooted())
         return;
 
     if (view()->document().printing())
         return; // Don't invalidate paints if we're printing.
 
     LayoutRect dirtyRect(r);
 
     if (!RuntimeEnabledFeatures::repaintAfterLayoutEnabled()) {
         // FIXME: layoutDelta needs to be applied in parts before/after transforms and
         // paint invalidation containers. https://bugs.webkit.org/show_bug.cgi?id=23308
         dirtyRect.move(view()->layoutDelta());
     }
 
-    const RenderLayerModelObject* paintInvalidationContainer = containerForRepaint();
+    const RenderLayerModelObject* paintInvalidationContainer = containerForPaintInvalidation();
     RenderLayer::mapRectToRepaintBacking(this, paintInvalidationContainer, dirtyRect);
-    invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(dirtyRect), InvalidationRepaintRectangle);
+    invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(dirtyRect), InvalidationPaintRectangle);
 }
 
 IntRect RenderObject::pixelSnappedAbsoluteClippedOverflowRect() const
 {
     return pixelSnappedIntRect(absoluteClippedOverflowRect());
 }
 
 const char* RenderObject::invalidationReasonToString(InvalidationReason reason) const
 {
     switch (reason) {
@@ skipping 10 matching lines @@
     case InvalidationBoundsChange:
         return "bounds change";
     case InvalidationLocationChange:
         return "location change";
     case InvalidationScroll:
         return "scroll";
     case InvalidationSelection:
         return "selection";
     case InvalidationLayer:
         return "layer";
-    case InvalidationRepaint:
+    case InvalidationPaint:
         return "invalidate paint";
-    case InvalidationRepaintRectangle:
+    case InvalidationPaintRectangle:
         return "invalidate paint rectangle";
     }
     ASSERT_NOT_REACHED();
     return "";
 }
 
 void RenderObject::invalidateTreeAfterLayout(const RenderLayerModelObject& paintInvalidationContainer)
 {
     // If we didn't need paint invalidation then our children don't need as well.
     // Skip walking down the tree as everything should be fine below us.
@@ skipping 18 matching lines @@
 }
 
 bool RenderObject::invalidatePaintAfterLayoutIfNeeded(const RenderLayerModelObject* paintInvalidationContainer, bool wasSelfLayout,
     const LayoutRect& oldBounds, const LayoutPoint& oldLocation, const LayoutRect* newBoundsPtr, const LayoutPoint* newLocationPtr)
 {
     RenderView* v = view();
     if (v->document().printing())
         return false; // Don't invalidate paints if we're printing.
 
     // This ASSERT fails due to animations.  See https://bugs.webkit.org/show_bug.cgi?id=37048
-    // ASSERT(!newBoundsPtr || *newBoundsPtr == clippedOverflowRectForRepaint(paintInvalidationContainer));
-    LayoutRect newBounds = newBoundsPtr ? *newBoundsPtr : computeRepaintRect();
-    LayoutPoint newLocation = newLocationPtr ? (*newLocationPtr) : positionFromRepaintContainer(paintInvalidationContainer);
+    // ASSERT(!newBoundsPtr || *newBoundsPtr == clippedOverflowRectForPaintInvalidation(paintInvalidationContainer));
+    LayoutRect newBounds = newBoundsPtr ? *newBoundsPtr : computePaintInvalidationRect();
+    LayoutPoint newLocation = newLocationPtr ? (*newLocationPtr) : positionFromPaintInvalidationContainer(paintInvalidationContainer);
 
     // FIXME: This should use a ConvertableToTraceFormat when they are available in Blink.
     TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "RenderObject::invalidatePaintAfterLayoutIfNeeded()",
         "object", this->debugName().ascii(),
         "info", TracedValue::fromJSONValue(jsonObjectForOldAndNewRects(oldBounds, newBounds)));
 
     InvalidationReason invalidationReason = wasSelfLayout ? InvalidationSelfLayout : InvalidationIncremental;
 
     // Presumably a background or a border exists if border-fit:lines was specified.
     if (invalidationReason == InvalidationIncremental && style()->borderFit() == BorderFitLines)
@@ skipping 11 matching lines @@
     if (invalidationReason == InvalidationIncremental && compositingState() != PaintsIntoOwnBacking && newLocation != oldLocation)
         invalidationReason = InvalidationLocationChange;
 
     // If the bounds are the same then we know that none of the statements below
     // can match, so we can early out since we will not need to do any
     // invalidation.
     if (invalidationReason == InvalidationIncremental && oldBounds == newBounds)
         return false;
 
     if (invalidationReason == InvalidationIncremental) {
-        if (oldBounds.width() != newBounds.width() && mustRepaintBackgroundOrBorderOnWidthChange())
+        if (oldBounds.width() != newBounds.width() && mustInvalidateBackgroundOrBorderPaintOnWidthChange())
             invalidationReason = InvalidationBoundsChangeWithBackground;
-        else if (oldBounds.height() != newBounds.height() && mustRepaintBackgroundOrBorderOnHeightChange())
+        else if (oldBounds.height() != newBounds.height() && mustInvalidateBackgroundOrBorderPaintOnHeightChange())
             invalidationReason = InvalidationBoundsChangeWithBackground;
     }
 
     // If we shifted, we don't know the exact reason so we are conservative and trigger a full invalidation. Shifting could
     // be caused by some layout property (left / top) or some in-flow renderer inserted / removed before us in the tree.
     if (invalidationReason == InvalidationIncremental && newBounds.location() != oldBounds.location())
         invalidationReason = InvalidationBoundsChange;
 
     // If the size is zero on one of our bounds then we know we're going to have
     // to do a full invalidation of either old bounds or new bounds. If we fall
@@ skipping 34 matching lines @@
         invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(newBounds.x(), oldBounds.maxY(), newBounds.width(), deltaBottom), invalidationReason);
     else if (deltaBottom < 0)
         invalidatePaintUsingContainer(paintInvalidationContainer, pixelSnappedIntRect(oldBounds.x(), newBounds.maxY(), oldBounds.width(), -deltaBottom), invalidationReason);
 
     // FIXME: This is a limitation of our visual overflow being a single rectangle.
     if (!style()->boxShadow() && !style()->hasBorderImageOutsets() && !style()->hasOutline())
         return false;
 
     // We didn't move, but we did change size. Invalidate the delta, which will consist of possibly
     // two rectangles (but typically only one).
-    RenderStyle* outlineStyle = outlineStyleForRepaint();
+    RenderStyle* outlineStyle = outlineStyleForPaintInvalidation();
     LayoutUnit outlineWidth = outlineStyle->outlineSize();
     LayoutBoxExtent insetShadowExtent = style()->getBoxShadowInsetExtent();
     LayoutUnit width = absoluteValue(newBounds.width() - oldBounds.width());
     if (width) {
         LayoutUnit shadowLeft;
         LayoutUnit shadowRight;
         style()->getBoxShadowHorizontalExtent(shadowLeft, shadowRight);
         int borderRight = isBox() ? toRenderBox(this)->borderRight() : 0;
         LayoutUnit boxWidth = isBox() ? toRenderBox(this)->width() : LayoutUnit();
         LayoutUnit minInsetRightShadowExtent = min<LayoutUnit>(-insetShadowExtent.right(), min<LayoutUnit>(newBounds.width(), oldBounds.width()));
@@ skipping 37 matching lines @@
 void RenderObject::invalidatePaintForOverflow()
 {
 }
 
 void RenderObject::invalidatePaintForOverflowIfNeeded()
 {
     if (shouldInvalidateOverflowForPaint())
         invalidatePaintForOverflow();
 }
 
-bool RenderObject::checkForRepaint() const
+bool RenderObject::checkForPaintInvalidation() const
 {
     return !document().view()->needsFullPaintInvalidation() && everHadLayout();
 }
 
-bool RenderObject::checkForRepaintDuringLayout() const
+bool RenderObject::checkForPaintInvalidationDuringLayout() const
 {
-    return !RuntimeEnabledFeatures::repaintAfterLayoutEnabled() && checkForRepaint();
+    return !RuntimeEnabledFeatures::repaintAfterLayoutEnabled() && checkForPaintInvalidation();
 }
 
-LayoutRect RenderObject::rectWithOutlineForRepaint(const RenderLayerModelObject* repaintContainer, LayoutUnit outlineWidth) const
+LayoutRect RenderObject::rectWithOutlineForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, LayoutUnit outlineWidth) const
 {
-    LayoutRect r(clippedOverflowRectForRepaint(repaintContainer));
+    LayoutRect r(clippedOverflowRectForPaintInvalidation(paintInvalidationContainer));
     r.inflate(outlineWidth);
     return r;
 }
 
-LayoutRect RenderObject::clippedOverflowRectForRepaint(const RenderLayerModelObject*) const
+LayoutRect RenderObject::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject*) const
 {
     ASSERT_NOT_REACHED();
     return LayoutRect();
 }
 
-void RenderObject::mapRectToRepaintBacking(const RenderLayerModelObject* repaintContainer, LayoutRect& rect, bool fixed) const
+void RenderObject::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, bool fixed) const
 {
-    if (repaintContainer == this)
+    if (paintInvalidationContainer == this)
         return;
 
     if (RenderObject* o = parent()) {
         if (o->isRenderBlockFlow()) {
             RenderBlock* cb = toRenderBlock(o);
             if (cb->hasColumns())
                 cb->adjustRectForColumns(rect);
         }
 
         if (o->hasOverflowClip()) {
             RenderBox* boxParent = toRenderBox(o);
             boxParent->applyCachedClipAndScrollOffsetForRepaint(rect);
             if (rect.isEmpty())
                 return;
         }
 
-        o->mapRectToRepaintBacking(repaintContainer, rect, fixed);
+        o->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, fixed);
     }
 }
 
-void RenderObject::computeFloatRectForRepaint(const RenderLayerModelObject*, FloatRect&, bool) const
+void RenderObject::computeFloatRectForPaintInvalidation(const RenderLayerModelObject*, FloatRect&, bool) const
 {
     ASSERT_NOT_REACHED();
 }
 
 void RenderObject::dirtyLinesFromChangedChild(RenderObject*)
 {
 }
 
 #ifndef NDEBUG
 
@@ skipping 125 matching lines @@
             block->children()->appendChildNode(block, childlist->removeChildNode(parent(), this));
         }
     }
 }
 
 StyleDifference RenderObject::adjustStyleDifference(StyleDifference diff, unsigned contextSensitiveProperties) const
 {
     if (contextSensitiveProperties & ContextSensitivePropertyTransform && isSVG())
         diff.setNeedsFullLayout();
 
-    // If transform changed, and the layer does not paint into its own separate backing, then we need to repaint.
+    // If transform changed, and the layer does not paint into its own separate backing, then we need to invalidate paints.
     if (contextSensitiveProperties & ContextSensitivePropertyTransform) {
         // Text nodes share style with their parents but transforms don't apply to them,
         // hence the !isText() check.
         if (!isText() && (!hasLayer() || !toRenderLayerModelObject(this)->layer()->styleDeterminedCompositingReasons()))
             diff.setNeedsRepaintLayer();
         else
             diff.setNeedsRecompositeLayer();
     }
 
-    // If opacity or zIndex changed, and the layer does not paint into its own separate backing, then we need to repaint (also
+    // If opacity or zIndex changed, and the layer does not paint into its own separate backing, then we need to invalidate paints (also
     // ignoring text nodes)
     if (contextSensitiveProperties & (ContextSensitivePropertyOpacity | ContextSensitivePropertyZIndex)) {
         if (!isText() && (!hasLayer() || !toRenderLayerModelObject(this)->layer()->styleDeterminedCompositingReasons()))
             diff.setNeedsRepaintLayer();
         else
             diff.setNeedsRecompositeLayer();
     }
 
-    // If filter changed, and the layer does not paint into its own separate backing or it paints with filters, then we need to repaint.
+    // If filter changed, and the layer does not paint into its own separate backing or it paints with filters, then we need to invalidate paints.
     if ((contextSensitiveProperties & ContextSensitivePropertyFilter) && hasLayer()) {
         RenderLayer* layer = toRenderLayerModelObject(this)->layer();
         if (!layer->styleDeterminedCompositingReasons() || layer->paintsWithFilters())
             diff.setNeedsRepaintLayer();
         else
             diff.setNeedsRecompositeLayer();
     }
 
     if ((contextSensitiveProperties & ContextSensitivePropertyTextOrColor) && !diff.needsRepaint()
         && hasImmediateNonWhitespaceTextChildOrPropertiesDependentOnColor())
         diff.setNeedsRepaintObject();
 
     // The answer to layerTypeRequired() for plugins, iframes, and canvas can change without the actual
     // style changing, since it depends on whether we decide to composite these elements. When the
     // layer status of one of these elements changes, we need to force a layout.
     if (!diff.needsFullLayout() && style() && isLayerModelObject()) {
         bool requiresLayer = toRenderLayerModelObject(this)->layerTypeRequired() != NoLayer;
         if (hasLayer() != requiresLayer)
             diff.setNeedsFullLayout();
     }
 
-    // If we have no layer(), just treat a RepaintLayer hint as a normal Repaint.
+    // If we have no layer(), just treat a RepaintLayer hint as a normal paint invalidation.
     if (diff.needsRepaintLayer() && !hasLayer()) {
         diff.clearNeedsRepaint();
         diff.setNeedsRepaintObject();
     }
 
     return diff;
 }
 
 void RenderObject::setPseudoStyle(PassRefPtr<RenderStyle> pseudoStyle)
 {
@@ skipping 81 matching lines @@
     styleDidChange(diff, oldStyle.get());
 
     // FIXME: |this| might be destroyed here. This can currently happen for a RenderTextFragment when
     // its first-letter block gets an update in RenderTextFragment::styleDidChange. For RenderTextFragment(s),
     // we will safely bail out with the doesNotNeedLayout flag. We might want to broaden this condition
     // in the future as we move renderer changes out of layout and into style changes.
     if (doesNotNeedLayout)
         return;
 
     // Now that the layer (if any) has been updated, we need to adjust the diff again,
-    // check whether we should layout now, and decide if we need to repaint.
+    // check whether we should layout now, and decide if we need to invalidate paints.
     StyleDifference updatedDiff = adjustStyleDifference(diff, contextSensitiveProperties);
 
     if (!diff.needsFullLayout()) {
         if (updatedDiff.needsFullLayout())
             setNeedsLayoutAndPrefWidthsRecalc();
         else if (updatedDiff.needsPositionedMovementLayout())
             setNeedsPositionedMovementLayout();
     }
 
     if (contextSensitiveProperties & ContextSensitivePropertyTransform && !needsLayout()) {
         if (RenderBlock* container = containingBlock())
             container->setNeedsOverflowRecalcAfterStyleChange();
         if (isBox())
             toRenderBox(this)->updateLayerTransform();
     }
 
     if (updatedDiff.needsRepaint()) {
-        // Repaint with the new style, e.g., for example if we go from not having
+        // Invalidate paints with the new style, e.g., for example if we go from not having
         // an outline to having an outline.
         if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled() && needsLayout())
             setShouldDoFullPaintInvalidationAfterLayout(true);
         else if (!selfNeedsLayout())
             paintInvalidationForWholeRenderer();
     }
 }
 
 static inline bool rendererHasBackground(const RenderObject* renderer)
 {
@@ skipping 136 matching lines @@
 
         // Ditto.
         if (needsOverflowRecalcAfterStyleChange() && oldStyle->position() != m_style->position())
             markContainingBlocksForOverflowRecalc();
 
         if (diff.needsFullLayout())
             setNeedsLayoutAndPrefWidthsRecalc();
     } else if (diff.needsPositionedMovementLayout())
         setNeedsPositionedMovementLayout();
 
-    // Don't check for repaint here; we need to wait until the layer has been
-    // updated by subclasses before we know if we have to repaint (in setStyle()).
+    // Don't check for paint invalidation here; we need to wait until the layer has been
+    // updated by subclasses before we know if we have to invalidate paints (in setStyle()).
 
     if (oldStyle && !areCursorsEqual(oldStyle, style())) {
         if (LocalFrame* frame = this->frame())
             frame->eventHandler().scheduleCursorUpdate();
     }
 }
 
 void RenderObject::propagateStyleToAnonymousChildren(bool blockChildrenOnly)
 {
     // FIXME: We could save this call when the change only affected non-inherited properties.
@@ skipping 82 matching lines @@
 }
 
 FloatQuad RenderObject::absoluteToLocalQuad(const FloatQuad& quad, MapCoordinatesFlags mode) const
 {
     TransformState transformState(TransformState::UnapplyInverseTransformDirection, quad.boundingBox().center(), quad);
     mapAbsoluteToLocalPoint(mode, transformState);
     transformState.flatten();
     return transformState.lastPlanarQuad();
 }
 
-void RenderObject::mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
+void RenderObject::mapLocalToContainer(const RenderLayerModelObject* paintInvalidationContainer, TransformState& transformState, MapCoordinatesFlags mode, bool* wasFixed) const
 {
-    if (repaintContainer == this)
+    if (paintInvalidationContainer == this)
         return;
 
     RenderObject* o = parent();
     if (!o)
         return;
 
     // FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
     LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());
     if (mode & ApplyContainerFlip && o->isBox()) {
         if (o->style()->isFlippedBlocksWritingMode())
             transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);
         mode &= ~ApplyContainerFlip;
     }
 
     transformState.move(o->columnOffset(roundedLayoutPoint(transformState.mappedPoint())));
 
     if (o->hasOverflowClip())
         transformState.move(-toRenderBox(o)->scrolledContentOffset());
 
-    o->mapLocalToContainer(repaintContainer, transformState, mode, wasFixed);
+    o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed);
 }
 
 const RenderObject* RenderObject::pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap& geometryMap) const
 {
     ASSERT_UNUSED(ancestorToStopAt, ancestorToStopAt != this);
 
     RenderObject* container = parent();
     if (!container)
         return 0;
 
@@ skipping 39 matching lines @@
 
         TransformationMatrix perspectiveMatrix;
         perspectiveMatrix.applyPerspective(containerObject->style()->perspective());
 
         transform.translateRight3d(-perspectiveOrigin.x(), -perspectiveOrigin.y(), 0);
         transform = perspectiveMatrix * transform;
         transform.translateRight3d(perspectiveOrigin.x(), perspectiveOrigin.y(), 0);
     }
 }
 
-FloatQuad RenderObject::localToContainerQuad(const FloatQuad& localQuad, const RenderLayerModelObject* repaintContainer, MapCoordinatesFlags mode, bool* wasFixed) const
+FloatQuad RenderObject::localToContainerQuad(const FloatQuad& localQuad, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags mode, bool* wasFixed) const
 {
     // Track the point at the center of the quad's bounding box. As mapLocalToContainer() calls offsetFromContainer(),
     // it will use that point as the reference point to decide which column's transform to apply in multiple-column blocks.
     TransformState transformState(TransformState::ApplyTransformDirection, localQuad.boundingBox().center(), localQuad);
-    mapLocalToContainer(repaintContainer, transformState, mode | ApplyContainerFlip | UseTransforms, wasFixed);
+    mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip | UseTransforms, wasFixed);
     transformState.flatten();
 
     return transformState.lastPlanarQuad();
 }
 
-FloatPoint RenderObject::localToContainerPoint(const FloatPoint& localPoint, const RenderLayerModelObject* repaintContainer, MapCoordinatesFlags mode, bool* wasFixed) const
+FloatPoint RenderObject::localToContainerPoint(const FloatPoint& localPoint, const RenderLayerModelObject* paintInvalidationContainer, MapCoordinatesFlags mode, bool* wasFixed) const
 {
     TransformState transformState(TransformState::ApplyTransformDirection, localPoint);
-    mapLocalToContainer(repaintContainer, transformState, mode | ApplyContainerFlip | UseTransforms, wasFixed);
+    mapLocalToContainer(paintInvalidationContainer, transformState, mode | ApplyContainerFlip | UseTransforms, wasFixed);
     transformState.flatten();
 
     return transformState.lastPlanarPoint();
 }
 
 LayoutSize RenderObject::offsetFromContainer(const RenderObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
     ASSERT(o == container());
 
     LayoutSize offset = o->columnOffset(point);
@@ skipping 151 matching lines @@
 bool RenderObject::hasOutlineAnnotation() const
 {
     return node() && node()->isLink() && document().printing();
 }
 
 bool RenderObject::hasEntirelyFixedBackground() const
 {
     return m_style->hasEntirelyFixedBackground();
 }
 
-RenderObject* RenderObject::container(const RenderLayerModelObject* repaintContainer, bool* repaintContainerSkipped) const
+RenderObject* RenderObject::container(const RenderLayerModelObject* paintInvalidationContainer, bool* paintInvalidationContainerSkipped) const
 {
-    if (repaintContainerSkipped)
-        *repaintContainerSkipped = false;
+    if (paintInvalidationContainerSkipped)
+        *paintInvalidationContainerSkipped = false;
 
     // This method is extremely similar to containingBlock(), but with a few notable
     // exceptions.
     // (1) It can be used on orphaned subtrees, i.e., it can be called safely even when
     // the object is not part of the primary document subtree yet.
     // (2) For normal flow elements, it just returns the parent.
     // (3) For absolute positioned elements, it will return a relative positioned inline.
     // containingBlock() simply skips relpositioned inlines and lets an enclosing block handle
     // the layout of the positioned object.  This does mean that computePositionedLogicalWidth and
     // computePositionedLogicalHeight have to use container().
     RenderObject* o = parent();
 
     if (isText())
         return o;
 
     EPosition pos = m_style->position();
     if (pos == FixedPosition) {
-        return containerForFixedPosition(repaintContainer, repaintContainerSkipped);
+        return containerForFixedPosition(paintInvalidationContainer, paintInvalidationContainerSkipped);
     } else if (pos == AbsolutePosition) {
         // We technically just want our containing block, but
         // we may not have one if we're part of an uninstalled
         // subtree. We'll climb as high as we can though.
         while (o) {
             if (o->style()->position() != StaticPosition)
                 break;
 
             if (o->canContainFixedPositionObjects())
                 break;
 
-            if (repaintContainerSkipped && o == repaintContainer)
-                *repaintContainerSkipped = true;
+            if (paintInvalidationContainerSkipped && o == paintInvalidationContainer)
+                *paintInvalidationContainerSkipped = true;
 
             o = o->parent();
         }
     }
 
     return o;
 }
 
 bool RenderObject::isSelectionBorder() const
 {
@@ skipping 725 matching lines @@
 }
 
 FloatRect RenderObject::strokeBoundingBox() const
 {
     ASSERT_NOT_REACHED();
     return FloatRect();
 }
 
 // Returns the smallest rectangle enclosing all of the painted content
 // respecting clipping, masking, filters, opacity, stroke-width and markers
-FloatRect RenderObject::repaintRectInLocalCoordinates() const
+FloatRect RenderObject::paintInvalidationRectInLocalCoordinates() const
 {
     ASSERT_NOT_REACHED();
     return FloatRect();
 }
 
 AffineTransform RenderObject::localTransform() const
 {
     static const AffineTransform identity;
     return identity;
 }
@@ skipping 66 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif