Remove PaintInvalidatorContext::newVisualRect

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/LayoutView.h"
 #include "core/layout/api/LayoutPartItem.h"
@@ skipping 478 matching lines @@
 void ObjectPaintInvalidatorWithContext::invalidatePaintRectangleWithContext(
     const LayoutRect& rect,
     PaintInvalidationReason reason) {
   if (rect.isEmpty())
     return;
 
   // If the parent has fully invalidated and its visual rect covers this object
   // on the same backing, skip the invalidation.
   if (parentFullyInvalidatedOnSameBacking() &&
       (m_context.parentContext->oldVisualRect.contains(rect) ||
-       m_context.parentContext->newVisualRect.contains(rect)))
+       m_object.parent()->visualRect().contains(rect)))
     return;
 
   invalidatePaintUsingContainer(*m_context.paintInvalidationContainer, rect,
                                 reason);
 }
 
 DISABLE_CFI_PERF
 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.oldVisualRect.isEmpty() && m_context.newVisualRect.isEmpty())
+  if (m_context.oldVisualRect.isEmpty() && m_object.visualRect().isEmpty())
     return PaintInvalidationNone;
 
   if (backgroundObscurationChanged)
     return PaintInvalidationBackgroundObscurationChange;
 
   if (m_object.paintedOutputOfObjectHasNoEffectRegardlessOfSize())
     return PaintInvalidationNone;
 
   // Force full paint invalidation if the outline may be affected by descendants
   // and this object is marked for checking paint invalidation for any reason.
   if (m_object.outlineMayBeAffectedByDescendants() ||
       m_object.previousOutlineMayBeAffectedByDescendants()) {
     m_object.getMutableForPainting()
         .updatePreviousOutlineMayBeAffectedByDescendants();
     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.oldVisualRect.isEmpty())
     return PaintInvalidationBecameVisible;
-  if (m_context.newVisualRect.isEmpty())
+  if (m_object.visualRect().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.newVisualRect.location() != m_context.oldVisualRect.location())
+  if (m_object.visualRect().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 oldVisualRect and newVisualRect
   // are equal because a LayoutBox may need paint invalidation if its border box
   // changes. BoxPaintInvalidator may also override this reason with a full
   // paint invalidation reason if needed.
   if (m_object.isBox())
     return PaintInvalidationIncremental;
 
-  if (m_context.oldVisualRect != m_context.newVisualRect)
+  if (m_context.oldVisualRect != m_object.visualRect())
     return PaintInvalidationBoundsChange;
 
   return PaintInvalidationNone;
 }
 
 DISABLE_CFI_PERF
 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
@@ skipping 56 matching lines @@
            PaintInvalidatorContext::ForcedSubtreeSVGResourceChange)) {
         reason = PaintInvalidationSVGResourceChange;
         break;
       }
       return PaintInvalidationNone;
     case PaintInvalidationDelayedFull:
       return PaintInvalidationDelayedFull;
     default:
       DCHECK(isImmediateFullPaintInvalidationReason(reason));
       fullyInvalidatePaint(reason, m_context.oldVisualRect,
-                           m_context.newVisualRect);
+                           m_object.visualRect());
   }
 
   m_context.paintingLayer->setNeedsRepaint();
   m_object.invalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(&gDisablePaintInvalidationStateAsserts, true) {}
 
 }  // namespace blink