Rename "paint invalidation rect" etc. to "visual rect".

third_party/WebKit/Source/core/layout/LayoutObject.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/)
@@ skipping 108 matching lines @@
 
 struct SameSizeAsLayoutObject : DisplayItemClient {
   virtual ~SameSizeAsLayoutObject() {}  // Allocate vtable pointer.
   void* pointers[5];
   Member<void*> members[1];
 #if ENABLE(ASSERT)
   unsigned m_debugBitfields : 2;
 #endif
   unsigned m_bitfields;
   unsigned m_bitfields2;
-  LayoutRect rect;       // Stores the previous paint invalidation rect.
-  LayoutPoint position;  // Stores the previous position from the paint
-                         // invalidation container.
+  LayoutRect m_previousVisualRect;
+  LayoutPoint m_previousPosition;
 };
 
 static_assert(sizeof(LayoutObject) == sizeof(SameSizeAsLayoutObject),
               "LayoutObject should stay small");
 
 bool LayoutObject::s_affectsParentBlock = false;
 
 // The pointer to paint properties is implemented as a global hash map
 // temporarily, to avoid memory regression during the transition towards SPv2.
 typedef HashMap<const LayoutObject*, std::unique_ptr<ObjectPaintProperties>>
@@ skipping 946 matching lines @@
   name.append(decoratedName());
 
   if (const Node* node = this->node()) {
     name.append(' ');
     name.append(node->debugName());
   }
   return name.toString();
 }
 
 LayoutRect LayoutObject::visualRect() const {
-  return previousPaintInvalidationRect();
+  return previousVisualRect();
 }
 
 bool LayoutObject::isPaintInvalidationContainer() const {
   return hasLayer() &&
          toLayoutBoxModelObject(this)->layer()->isPaintInvalidationContainer();
 }
 
 void LayoutObject::invalidateDisplayItemClients(
     PaintInvalidationReason reason) const {
   // This default implementation invalidates only the object itself as a
@@ skipping 89 matching lines @@
   LayoutView* v = view();
   if (v->document().printing())
     return PaintInvalidationNone;  // Don't invalidate paints if we're printing.
 
   PaintInvalidatorContextAdapter context(paintInvalidationState);
 
   const LayoutBoxModelObject& paintInvalidationContainer =
       paintInvalidationState.paintInvalidationContainer();
   DCHECK(paintInvalidationContainer == containerForPaintInvalidation());
 
-  context.oldBounds = previousPaintInvalidationRect();
+  context.oldVisualRect = previousVisualRect();
   context.oldLocation = previousPositionFromPaintInvalidationBacking();
-  context.newBounds =
-      paintInvalidationState.computePaintInvalidationRectInBacking();
+  context.newVisualRect = paintInvalidationState.computeVisualRectInBacking();
   context.newLocation =
       paintInvalidationState.computePositionFromPaintInvalidationBacking();
 
   IntSize adjustment =
       scrollAdjustmentForPaintInvalidation(paintInvalidationContainer);
   context.newLocation.move(adjustment);
-  context.newBounds.move(adjustment);
+  context.newVisualRect.move(adjustment);
 
-  adjustVisualRectForRasterEffects(context.newBounds);
+  adjustVisualRectForRasterEffects(context.newVisualRect);
 
-  setPreviousPaintInvalidationRect(context.newBounds);
+  setPreviousVisualRect(context.newVisualRect);
   setPreviousPositionFromPaintInvalidationBacking(context.newLocation);
 
   if (!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() &&
       paintInvalidationState
           .forcedSubtreeInvalidationRectUpdateWithinContainerOnly()) {
-    // We are done updating the paint invalidation rect. No other paint
-    // invalidation work to do for this object.
+    // We are done updating the visual rect. No other paint invalidation work
+    // to do for this object.
     return PaintInvalidationNone;
   }
 
   return invalidatePaintIfNeeded(context);
 }
 
 DISABLE_CFI_PERF
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(
     const PaintInvalidatorContext& context) const {
   return ObjectPaintInvalidatorWithContext(*this, context)
       .invalidatePaintIfNeeded();
 }
 
-void LayoutObject::adjustInvalidationRectForCompositedScrolling(
+void LayoutObject::adjustVisualRectForCompositedScrolling(
     LayoutRect& rect,
     const LayoutBoxModelObject& paintInvalidationContainer) const {
   if (compositedScrollsWithRespectTo(paintInvalidationContainer)) {
     LayoutSize offset(
         -toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
     rect.move(offset);
   }
 }
 
-LayoutRect
-LayoutObject::previousPaintInvalidationRectIncludingCompositedScrolling(
+LayoutRect LayoutObject::previousVisualRectIncludingCompositedScrolling(
     const LayoutBoxModelObject& paintInvalidationContainer) const {
-  LayoutRect invalidationRect = previousPaintInvalidationRect();
-  adjustInvalidationRectForCompositedScrolling(invalidationRect,
-                                               paintInvalidationContainer);
-  return invalidationRect;
+  LayoutRect rect = previousVisualRect();
+  adjustVisualRectForCompositedScrolling(rect, paintInvalidationContainer);
+  return rect;
 }
 
 void LayoutObject::adjustPreviousPaintInvalidationForScrollIfNeeded(
     const DoubleSize& scrollDelta) {
   if (containerForPaintInvalidation().usesCompositedScrolling())
     return;
-  m_previousPaintInvalidationRect.move(LayoutSize(scrollDelta));
+  m_previousVisualRect.move(LayoutSize(scrollDelta));
 }
 
-void LayoutObject::clearPreviousPaintInvalidationRects() {
-  setPreviousPaintInvalidationRect(LayoutRect());
-  // After clearing ("invalidating" the paint invalidation rects, mark this
-  // object as needing to re-compute them.
+void LayoutObject::clearPreviousVisualRects() {
+  setPreviousVisualRect(LayoutRect());
+  // After clearing ("invalidating" the visual rects, mark this object as
+  // needing to re-compute them.
   setShouldDoFullPaintInvalidation();
 }
 
-LayoutRect LayoutObject::absoluteClippedOverflowRect() const {
-  LayoutRect rect = localOverflowRectForPaintInvalidation();
+LayoutRect LayoutObject::absoluteVisualRect() const {
+  LayoutRect rect = localVisualRect();
   mapToVisualRectInAncestorSpace(view(), rect);
   return rect;
 }
 
-LayoutRect LayoutObject::localOverflowRectForPaintInvalidation() const {
-  ASSERT_NOT_REACHED();
+LayoutRect LayoutObject::localVisualRect() const {
+  NOTREACHED();
   return LayoutRect();
 }
 
 bool LayoutObject::mapToVisualRectInAncestorSpace(
     const LayoutBoxModelObject* ancestor,
     LayoutRect& rect,
     VisualRectFlags visualRectFlags) const {
   // For any layout object that doesn't override this method (the main example
   // is LayoutText), the rect is assumed to be in the parent's coordinate space,
   // except for container flip.
@@ skipping 2039 matching lines @@
   const LayoutBlock* containingBlock = this->containingBlock();
   return containingBlock ? !containingBlock->needsLayout() : false;
 }
 
 void LayoutObject::setNeedsBoundariesUpdate() {
   if (LayoutObject* layoutObject = parent())
     layoutObject->setNeedsBoundariesUpdate();
 }
 
 FloatRect LayoutObject::objectBoundingBox() const {
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FloatRect();
 }
 
 FloatRect LayoutObject::strokeBoundingBox() const {
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
   return FloatRect();
 }
 
-FloatRect LayoutObject::paintInvalidationRectInLocalSVGCoordinates() const {
-  ASSERT_NOT_REACHED();
+FloatRect LayoutObject::visualRectInLocalSVGCoordinates() const {
+  NOTREACHED();
   return FloatRect();
 }
 
 AffineTransform LayoutObject::localSVGTransform() const {
   static const AffineTransform identity;
   return identity;
 }
 
 const AffineTransform& LayoutObject::localToSVGParentTransform() const {
   static const AffineTransform identity;
@@ skipping 191 matching lines @@
     const blink::LayoutObject* root = object1;
     while (root->parent())
       root = root->parent();
     root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
   } else {
     WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
   }
 }
 
 #endif