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

third_party/WebKit/Source/core/paint/ObjectPaintInvalidator.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/ObjectPaintInvalidator.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutPartItem.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/paint/PaintInvalidator.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/HostWindow.h"
 #include "platform/graphics/GraphicsLayer.h"
 
 namespace blink {
 
 static bool gDisablePaintInvalidationStateAsserts = false;
 
-typedef HashMap<const LayoutObject*, LayoutRect> SelectionPaintInvalidationMap;
-static SelectionPaintInvalidationMap& selectionPaintInvalidationMap() {
-  DEFINE_STATIC_LOCAL(SelectionPaintInvalidationMap, map, ());
+typedef HashMap<const LayoutObject*, LayoutRect> SelectionVisualRectMap;
+static SelectionVisualRectMap& selectionVisualRectMap() {
+  DEFINE_STATIC_LOCAL(SelectionVisualRectMap, map, ());
   return map;
 }
 
-static void setPreviousSelectionPaintInvalidationRect(
-    const LayoutObject& object,
-    const LayoutRect& rect) {
+static void setPreviousSelectionVisualRect(const LayoutObject& object,
+                                           const LayoutRect& rect) {
   if (rect.isEmpty())
-    selectionPaintInvalidationMap().remove(&object);
+    selectionVisualRectMap().remove(&object);
   else
-    selectionPaintInvalidationMap().set(&object, rect);
+    selectionVisualRectMap().set(&object, rect);
 }
 
 void ObjectPaintInvalidator::objectWillBeDestroyed(const LayoutObject& object) {
-  selectionPaintInvalidationMap().remove(&object);
+  selectionVisualRectMap().remove(&object);
 }
 
 // TODO(trchen): Use std::function<void, LayoutObject&> when available.
 template <typename LayoutObjectTraversalFunctor>
 void traverseNonCompositingDescendantsInPaintOrder(
     const LayoutObject&,
     const LayoutObjectTraversalFunctor&);
 
 template <typename LayoutObjectTraversalFunctor>
 void traverseNonCompositingDescendantsBelongingToAncestorPaintInvalidationContainer(
@@ skipping 70 matching lines @@
   traverseNonCompositingDescendantsInPaintOrder(
       m_object, [reason](const LayoutObject& object) {
         if (object.hasLayer() &&
             toLayoutBoxModelObject(object).hasSelfPaintingLayer())
           toLayoutBoxModelObject(object).layer()->setNeedsRepaint();
         object.invalidateDisplayItemClients(reason);
       });
 }
 
 DISABLE_CFI_PERF
-void ObjectPaintInvalidator::invalidatePaintOfPreviousPaintInvalidationRect(
+void ObjectPaintInvalidator::invalidatePaintOfPreviousVisualRect(
     const LayoutBoxModelObject& paintInvalidationContainer,
     PaintInvalidationReason reason) {
   // It's caller's responsibility to ensure enclosingSelfPaintingLayer's
   // needsRepaint is set.  Don't set the flag here because getting
   // enclosingSelfPaintLayer has cost and the caller can use various ways (e.g.
   // PaintInvalidatinState::enclosingSelfPaintingLayer()) to reduce the cost.
   DCHECK(!m_object.paintingLayer() || m_object.paintingLayer()->needsRepaint());
 
   // These disablers are valid because we want to use the current
   // compositing/invalidation status.
   DisablePaintInvalidationStateAsserts invalidationDisabler;
   DisableCompositingQueryAsserts compositingDisabler;
 
-  LayoutRect invalidationRect = m_object.previousPaintInvalidationRect();
+  LayoutRect invalidationRect = m_object.previousVisualRect();
   invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect,
                                 reason);
   m_object.invalidateDisplayItemClients(reason);
 
   // This method may be used to invalidate paint of an object changing paint
-  // invalidation container.  Clear previous paint invalidation rect on the
-  // original paint invalidation container to avoid under-invalidation if the
-  // new paint invalidation rect on the new paint invalidation container happens
-  // to be the same as the old one.
-  m_object.getMutableForPainting().clearPreviousPaintInvalidationRects();
+  // invalidation container.  Clear previous visual rect on the original paint
+  // invalidation container to avoid under-invalidation if the visual rect on
+  // the new paint invalidation container happens to be the same as the old one.
+  m_object.getMutableForPainting().clearPreviousVisualRects();
 }
 
 void ObjectPaintInvalidator::
     invalidatePaintIncludingNonCompositingDescendants() {
   // Since we're only painting non-composited layers, we know that they all
   // share the same paintInvalidationContainer.
   const LayoutBoxModelObject& paintInvalidationContainer =
       m_object.containerForPaintInvalidation();
   traverseNonCompositingDescendantsInPaintOrder(
       m_object, [&paintInvalidationContainer](const LayoutObject& object) {
         if (object.hasLayer())
           toLayoutBoxModelObject(object).layer()->setNeedsRepaint();
-        ObjectPaintInvalidator(object)
-            .invalidatePaintOfPreviousPaintInvalidationRect(
-                paintInvalidationContainer, PaintInvalidationSubtree);
+        ObjectPaintInvalidator(object).invalidatePaintOfPreviousVisualRect(
+            paintInvalidationContainer, PaintInvalidationSubtree);
       });
 }
 
 void ObjectPaintInvalidator::
     invalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(
         const LayoutBoxModelObject& paintInvalidationContainer) {
-  invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer,
-                                                 PaintInvalidationSubtree);
+  invalidatePaintOfPreviousVisualRect(paintInvalidationContainer,
+                                      PaintInvalidationSubtree);
   for (LayoutObject* child = m_object.slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->hasLayer() ||
         !toLayoutBoxModelObject(child)->layer()->isSelfPaintingLayer())
       ObjectPaintInvalidator(*child)
           .invalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(
               paintInvalidationContainer);
   }
 }
 
@@ skipping 181 matching lines @@
   return dirtyRectOnBacking;
 }
 
 void ObjectPaintInvalidator::slowSetPaintingLayerNeedsRepaint() {
   if (PaintLayer* paintingLayer = m_object.paintingLayer())
     paintingLayer->setNeedsRepaint();
 }
 
 void ObjectPaintInvalidatorWithContext::fullyInvalidatePaint(
     PaintInvalidationReason reason,
-    const LayoutRect& oldBounds,
-    const LayoutRect& newBounds) {
+    const LayoutRect& oldVisualRect,
+    const LayoutRect& newVisualRect) {
   // The following logic avoids invalidating twice if one set of bounds contains
   // the other.
-  if (!newBounds.contains(oldBounds)) {
-    LayoutRect invalidationRect = oldBounds;
+  if (!newVisualRect.contains(oldVisualRect)) {
+    LayoutRect invalidationRect = oldVisualRect;
     invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
                                   invalidationRect, reason);
 
-    if (invalidationRect.contains(newBounds))
+    if (invalidationRect.contains(newVisualRect))
       return;
   }
 
   invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
-                                newBounds, reason);
+                                newVisualRect, reason);
 }
 
 PaintInvalidationReason
 ObjectPaintInvalidatorWithContext::computePaintInvalidationReason() {
   // This is before any early return to ensure the background obscuration status
   // is saved.
   bool backgroundObscurationChanged = false;
   bool backgroundObscured = m_object.backgroundIsKnownToBeObscured();
   if (backgroundObscured != m_object.previousBackgroundObscured()) {
     m_object.getMutableForPainting().setPreviousBackgroundObscured(
         backgroundObscured);
     backgroundObscurationChanged = true;
   }
 
   if (m_context.forcedSubtreeInvalidationFlags &
       PaintInvalidatorContext::ForcedSubtreeFullInvalidation)
     return PaintInvalidationSubtree;
 
   if (m_object.shouldDoFullPaintInvalidation())
     return m_object.fullPaintInvalidationReason();
 
-  if (m_context.oldBounds.isEmpty() && m_context.newBounds.isEmpty())
+  if (m_context.oldVisualRect.isEmpty() && m_context.newVisualRect.isEmpty())
     return PaintInvalidationNone;
 
   if (backgroundObscurationChanged)
     return PaintInvalidationBackgroundObscurationChange;
 
   if (m_object.paintedOutputOfObjectHasNoEffectRegardlessOfSize())
     return PaintInvalidationNone;
 
   const ComputedStyle& style = m_object.styleRef();
 
   // The outline may change shape because of position change of descendants. For
   // simplicity, just force full paint invalidation if this object is marked for
   // checking paint invalidation for any reason.
   // TODO(wangxianzhu): Optimize this.
   if (style.hasOutline())
     return PaintInvalidationOutline;
 
   // 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 (m_context.oldBounds.isEmpty())
+  if (m_context.oldVisualRect.isEmpty())
     return PaintInvalidationBecameVisible;
-  if (m_context.newBounds.isEmpty())
+  if (m_context.newVisualRect.isEmpty())
     return PaintInvalidationBecameInvisible;
 
   // 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 layoutObject inserted / removed
   // before us in the tree.
-  if (m_context.newBounds.location() != m_context.oldBounds.location())
+  if (m_context.newVisualRect.location() != m_context.oldVisualRect.location())
     return PaintInvalidationBoundsChange;
 
   if (m_context.newLocation != m_context.oldLocation)
     return PaintInvalidationLocationChange;
 
   // Incremental invalidation is only applicable to LayoutBoxes. Return
-  // PaintInvalidationIncremental no matter if oldBounds and newBounds are equal
+  // PaintInvalidationIncremental no matter if oldVisualRect and newVisualRect
+  // are equal
   // because a LayoutBox may need paint invalidation if its border box changes.
   if (m_object.isBox())
     return PaintInvalidationIncremental;
 
-  if (m_context.oldBounds != m_context.newBounds)
+  if (m_context.oldVisualRect != m_context.newVisualRect)
     return PaintInvalidationBoundsChange;
 
   return PaintInvalidationNone;
 }
 
 void ObjectPaintInvalidatorWithContext::invalidateSelectionIfNeeded(
     PaintInvalidationReason reason) {
   // Update selection rect when we are doing full invalidation (in case that the
   // object is moved, composite status changed, etc.) or
   // shouldInvalidationSelection is set (in case that the selection itself
   // changed).
   bool fullInvalidation = isImmediateFullPaintInvalidationReason(reason);
   if (!fullInvalidation && !m_object.shouldInvalidateSelection())
     return;
 
-  LayoutRect oldSelectionRect = selectionPaintInvalidationMap().get(&m_object);
+  LayoutRect oldSelectionRect = selectionVisualRectMap().get(&m_object);
   LayoutRect newSelectionRect = m_object.localSelectionRect();
   if (!newSelectionRect.isEmpty()) {
     m_context.mapLocalRectToPaintInvalidationBacking(m_object,
                                                      newSelectionRect);
     newSelectionRect.move(m_object.scrollAdjustmentForPaintInvalidation(
         *m_context.paintInvalidationContainer));
   }
 
-  setPreviousSelectionPaintInvalidationRect(m_object, newSelectionRect);
+  setPreviousSelectionVisualRect(m_object, newSelectionRect);
 
   if (!fullInvalidation) {
     fullyInvalidatePaint(PaintInvalidationSelection, oldSelectionRect,
                          newSelectionRect);
     m_context.paintingLayer->setNeedsRepaint();
     m_object.invalidateDisplayItemClients(PaintInvalidationSelection);
   }
 }
 
 PaintInvalidationReason
@@ skipping 15 matching lines @@
       if (m_context.forcedSubtreeInvalidationFlags &
           PaintInvalidatorContext::ForcedSubtreeInvalidationChecking) {
         reason = PaintInvalidationLocationChange;
         break;
       }
       return PaintInvalidationNone;
     case PaintInvalidationDelayedFull:
       return PaintInvalidationDelayedFull;
     default:
       DCHECK(isImmediateFullPaintInvalidationReason(reason));
-      fullyInvalidatePaint(reason, m_context.oldBounds, m_context.newBounds);
+      fullyInvalidatePaint(reason, m_context.oldVisualRect,
+                           m_context.newVisualRect);
   }
 
   m_context.paintingLayer->setNeedsRepaint();
   m_object.invalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(&gDisablePaintInvalidationStateAsserts, true) {}
 
 }  // namespace blink