Don't invalidate rect if it's covered by fully invalidated parent's 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/LayoutView.h"
 #include "core/layout/api/LayoutPartItem.h"
@@ skipping 437 matching lines @@
 }
 
 void ObjectPaintInvalidatorWithContext::fullyInvalidatePaint(
     PaintInvalidationReason reason,
     const LayoutRect& oldVisualRect,
     const LayoutRect& newVisualRect) {
   // The following logic avoids invalidating twice if one set of bounds contains
   // the other.
   if (!newVisualRect.contains(oldVisualRect)) {
     LayoutRect invalidationRect = oldVisualRect;
-    invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
-                                  invalidationRect, reason);
+    invalidatePaintRectangleWithContext(invalidationRect, reason);
 
     if (invalidationRect.contains(newVisualRect))
       return;
   }
 
-  invalidatePaintUsingContainer(*m_context.paintInvalidationContainer,
-                                newVisualRect, reason);
+  invalidatePaintRectangleWithContext(newVisualRect, reason);
+}
+
+bool ObjectPaintInvalidatorWithContext::parentFullyInvalidatedOnSameBacking() {
+  if (!m_object.parent() || !m_context.parentContext)
+    return false;
+
+  if (!isImmediateFullPaintInvalidationReason(
+          m_object.parent()->fullPaintInvalidationReason()))
+    return false;
+
+  // Parent and child should have the same paint invalidation container.
+  if (m_context.parentContext->paintInvalidationContainer !=
+      m_context.paintInvalidationContainer)
+    return false;
+
+  // Both parent and child are contents of the paint invalidation container,
+  // so they are on the same backing.
+  if (m_object.parent() != m_context.paintInvalidationContainer)
+    return true;
+
+  // If the paint invalidation container (i.e. parent) uses composited
+  // scrolling, parent and child might be on different backing (scrolling
+  // container vs scrolling contents).
+  return !m_context.paintInvalidationContainer->usesCompositedScrolling();
+}
+
+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)))
+    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()) {
@@ skipping 134 matching lines @@
 
   m_context.paintingLayer->setNeedsRepaint();
   m_object.invalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(&gDisablePaintInvalidationStateAsserts, true) {}
 
 }  // namespace blink