Simplify incremental paint invalidation

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 355 matching lines @@
     m_object.invalidateDisplayItemClients(PaintInvalidationRectangle);
 
   return dirtyRectOnBacking;
 }
 
 void ObjectPaintInvalidator::slowSetPaintingLayerNeedsRepaint() {
   if (PaintLayer* paintingLayer = m_object.paintingLayer())
     paintingLayer->setNeedsRepaint();
 }
 
-bool ObjectPaintInvalidatorWithContext::incrementallyInvalidatePaint() {
-  const LayoutRect& oldBounds = m_context.oldBounds;
-  const LayoutRect& newBounds = m_context.newBounds;
-
-  DCHECK(oldBounds.location() == newBounds.location());
-
-  LayoutUnit deltaRight = newBounds.maxX() - oldBounds.maxX();
-  LayoutUnit deltaBottom = newBounds.maxY() - oldBounds.maxY();
-  if (!deltaRight && !deltaBottom)
-    return false;
-
-  if (deltaRight > 0) {
-    LayoutRect invalidationRect(oldBounds.maxX(), newBounds.y(), deltaRight,
-                                newBounds.height());
-    invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
-                                  invalidationRect,
-                                  PaintInvalidationIncremental);
-  } else if (deltaRight < 0) {
-    LayoutRect invalidationRect(newBounds.maxX(), oldBounds.y(), -deltaRight,
-                                oldBounds.height());
-    invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
-                                  invalidationRect,
-                                  PaintInvalidationIncremental);
-  }
-
-  if (deltaBottom > 0) {
-    LayoutRect invalidationRect(newBounds.x(), oldBounds.maxY(),
-                                newBounds.width(), deltaBottom);
-    invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
-                                  invalidationRect,
-                                  PaintInvalidationIncremental);
-  } else if (deltaBottom < 0) {
-    LayoutRect invalidationRect(oldBounds.x(), newBounds.maxY(),
-                                oldBounds.width(), -deltaBottom);
-    invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
-                                  invalidationRect,
-                                  PaintInvalidationIncremental);
-  }
-
-  return true;
-}
-
 void ObjectPaintInvalidatorWithContext::fullyInvalidatePaint(
     PaintInvalidationReason reason,
     const LayoutRect& oldBounds,
     const LayoutRect& newBounds) {
   // The following logic avoids invalidating twice if one set of bounds contains
   // the other.
   if (!newBounds.contains(oldBounds)) {
     LayoutRect invalidationRect = oldBounds;
     invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
                                   invalidationRect, reason);
@@ skipping 106 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 && !incrementallyInvalidatePaint())
-    reason = PaintInvalidationNone;
+  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) {
         reason = PaintInvalidationLocationChange;
         break;
       }
       return PaintInvalidationNone;
-    case PaintInvalidationIncremental:
-      break;
     case PaintInvalidationDelayedFull:
       return PaintInvalidationDelayedFull;
     default:
       DCHECK(isImmediateFullPaintInvalidationReason(reason));
       fullyInvalidatePaint(reason, m_context.oldBounds, m_context.newBounds);
   }
 
   m_context.paintingLayer->setNeedsRepaint();
   m_object.invalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(&gDisablePaintInvalidationStateAsserts, true) {}
 
 }  // namespace blink