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);
+}
+
+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 (m_object.parent() && m_context.parentContext &&
+      m_context.parentContext->paintInvalidationContainer ==
+          m_context.paintInvalidationContainer &&
+      // This is a quick test to exclude the case that parent and child are not
+      // on the same backing of the paint invalidation container.
+      m_object.parent() != m_context.paintInvalidationContainer &&

[wkorman, 2017/02/23 01:26:25]

I wanted to better understand how checking whether parent !=
paint-invalidation-container relates to whether they're on the same backing?

I figure this is correct and I just need to hear you explain it a bit more to
me, but perhaps we should also make it clearer in the comment since I wondered.
It is hard for me to quickly understand "exclude the case that they are not",
when in fact if we pass this conditional test, what it means is that we will
proceed in considering application of the optimization.

[Xianzhu, 2017/02/23 04:38:49]

The idea was that the paint invalidation container itself may paint into
multiple backings. The parent may have been fully invalidated on the scrolling
container layer, while the current object may be invalidating on the scrolling
contents layer.

I have extracted the conditions into
ObjectPaintInvalidator::parentFullyInvalidatedOnSameBacking() and added
comments.

+      isImmediateFullPaintInvalidationReason(
+          m_object.parent()->fullPaintInvalidationReason()) &&
+      (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