Paint invalidation of local attachment backgrounds

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 268 matching lines @@
       // Note: the subpixel accumulation of layer() does not need to be added
       // here. It is already taken into account.
       squashingLayer->setNeedsDisplayInRect(enclosingIntRect(rect), reason,
                                             m_object);
     }
   } else if (m_object.compositedScrollsWithRespectTo(
                  paintInvalidationContainer)) {
     layer.compositedLayerMapping()->setScrollingContentsNeedDisplayInRect(
         rect, reason, m_object);
   } else if (paintInvalidationContainer.usesCompositedScrolling()) {
-    if (layer.compositedLayerMapping()
-            ->backgroundPaintsOntoScrollingContentsLayer()) {
-      // TODO(flackr): Get a correct rect in the context of the scrolling
-      // contents layer to update rather than updating the entire rect.
-      const LayoutRect& scrollingContentsRect =
-          toLayoutBox(m_object).layoutOverflowRect();
+    DCHECK(m_object == paintInvalidationContainer);
+    if (reason == PaintInvalidationBackgroundOnScrollingContentsLayer) {
       layer.compositedLayerMapping()->setScrollingContentsNeedDisplayInRect(
-          scrollingContentsRect, reason, m_object);
-      layer.setNeedsRepaint();
-      invalidateDisplayItemClient(
-          *layer.compositedLayerMapping()->scrollingContentsLayer(), reason);
+          rect, reason, m_object);
+    } else {
+      layer.compositedLayerMapping()->setNonScrollingContentsNeedDisplayInRect(
+          rect, reason, m_object);
     }
-    layer.compositedLayerMapping()->setNonScrollingContentsNeedDisplayInRect(
-        rect, reason, m_object);
   } else {
     // Otherwise invalidate everything.
     layer.compositedLayerMapping()->setContentsNeedDisplayInRect(rect, reason,
                                                                  m_object);
   }
 }
 
 void ObjectPaintInvalidator::invalidatePaintUsingContainer(
     const LayoutBoxModelObject& paintInvalidationContainer,
     const LayoutRect& dirtyRect,
@@ skipping 25 matching lines @@
           &m_object, paintInvalidationContainer));
   TRACE_EVENT2(
       TRACE_DISABLED_BY_DEFAULT("blink.invalidation"),
       "LayoutObject::invalidatePaintUsingContainer()", "object",
       m_object.debugName().ascii(), "info",
       jsonObjectForPaintInvalidationInfo(
           dirtyRect, paintInvalidationReasonToString(invalidationReason)));
 
   // This conditional handles situations where non-rooted (and hence
   // non-composited) frames are painted, such as SVG images.
-  if (!paintInvalidationContainer.isPaintInvalidationContainer())
+  if (!paintInvalidationContainer.isPaintInvalidationContainer()) {
     invalidatePaintRectangleOnWindow(paintInvalidationContainer,
                                      enclosingIntRect(dirtyRect));
+  }
 
   if (paintInvalidationContainer.view()->usesCompositing() &&
-      paintInvalidationContainer.isPaintInvalidationContainer())
+      paintInvalidationContainer.isPaintInvalidationContainer()) {
     setBackingNeedsPaintInvalidationInRect(paintInvalidationContainer,
                                            dirtyRect, invalidationReason);
+  }
 }
 
 LayoutRect ObjectPaintInvalidator::invalidatePaintRectangle(
     const LayoutRect& dirtyRect,
     DisplayItemClient* displayItemClient) {
   CHECK(m_object.isRooted());
 
   if (dirtyRect.isEmpty())
     return LayoutRect();
 
@@ skipping 115 matching lines @@
   // property (left / top) or some in-flow layoutObject inserted / removed
   // before us in the tree.
   if (m_context.newVisualRect.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.
+  // 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)
     return PaintInvalidationBoundsChange;
 
   return PaintInvalidationNone;
 }
 
 void ObjectPaintInvalidatorWithContext::invalidateSelectionIfNeeded(
@@ skipping 77 matching lines @@
 
   m_context.paintingLayer->setNeedsRepaint();
   m_object.invalidateDisplayItemClients(reason);
   return reason;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(&gDisablePaintInvalidationStateAsserts, true) {}
 
 }  // namespace blink