Simplify ObjectPaintInvalidatorW/C::computePaintInvalidationReason()

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"
@@ skipping 411 matching lines @@
 
   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;
 
-  bool locationChanged = m_context.newLocation != m_context.oldLocation;
-
-  // If the bounds are the same then we know that none of the statements below
-  // can match, so we can early out. However, we can't return
-  // PaintInvalidationNone even if !locationChagned, but conservatively return
-  // PaintInvalidationIncremental because we are not sure whether paint
-  // invalidation is actually needed just based on information known to
-  // LayoutObject. For example, a LayoutBox may need paint invalidation if
-  // border box changes.
-  if (m_context.oldBounds == m_context.newBounds)
-    return locationChanged ? PaintInvalidationLocationChange
-                           : PaintInvalidationIncremental;
-
   // 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())
     return PaintInvalidationBecameVisible;
   if (m_context.newBounds.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())
     return PaintInvalidationBoundsChange;
 
-  if (locationChanged)
+  if (m_context.newLocation != m_context.oldLocation)
     return PaintInvalidationLocationChange;
 
-  return PaintInvalidationIncremental;
+  // Incremental invalidation is only applicable to LayoutBoxes. Return
+  // PaintInvalidationIncremental no matter if oldBounds and newBounds 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)
+    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())
@@ skipping 19 matching lines @@
 }
 
 PaintInvalidationReason
 ObjectPaintInvalidatorWithContext::invalidatePaintIfNeededWithComputedReason(
     PaintInvalidationReason reason) {
   // We need to invalidate the selection before checking for whether we are
   // doing a full invalidation.  This is because we need to update the previous
   // selection rect regardless.
   invalidateSelectionIfNeeded(reason);
 
-  if (reason == PaintInvalidationIncremental) {
-    reason = m_context.oldBounds == m_context.newBounds ? PaintInvalidationNone
-                                                        : PaintInvalidationFull;
-  }
-
   switch (reason) {
     case PaintInvalidationNone:
       // TODO(trchen): Currently we don't keep track of paint offset of layout
       // objects.  There are corner cases that the display items need to be
       // invalidated for paint offset mutation, but incurs no pixel difference
       // (i.e. bounds stay the same) so no rect-based invalidation is issued.
       // See crbug.com/508383 and crbug.com/515977.  This is a workaround to
       // force display items to update paint offset.
       if (m_context.forcedSubtreeInvalidationFlags &
           PaintInvalidatorContext::ForcedSubtreeInvalidationChecking) {
@@ skipping 10 matching lines @@
 
   m_context.paintingLayer->setNeedsRepaint();
   m_object.invalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(&gDisablePaintInvalidationStateAsserts, true) {}
 
 }  // namespace blink