Repaint when background switches painting from/to scrolling contents layer.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 155 matching lines @@
     return (!page) ? nullptr : page->scrollingCoordinator();
 }
 
 CompositedLayerMapping::CompositedLayerMapping(PaintLayer& layer)
     : m_owningLayer(layer)
     , m_contentOffsetInCompositingLayerDirty(false)
     , m_pendingUpdateScope(GraphicsLayerUpdateNone)
     , m_isMainFrameLayoutViewLayer(false)
     , m_backgroundLayerPaintsFixedRootBackground(false)
     , m_scrollingContentsAreEmpty(false)
+    , m_backgroundPaintsOntoScrollingContentsLayer(false)
 {
     if (layer.isRootLayer() && layoutObject()->frame()->isMainFrame())
         m_isMainFrameLayoutViewLayer = true;
 
     createPrimaryGraphicsLayer();
 }
 
 CompositedLayerMapping::~CompositedLayerMapping()
 {
     // Hits in compositing/squashing/squash-onto-nephew.html.
@@ skipping 100 matching lines @@
 void CompositedLayerMapping::updateIsRootForIsolatedGroup()
 {
     bool isolate = m_owningLayer.shouldIsolateCompositedDescendants();
 
     // non stacking context layers should never isolate
     ASSERT(m_owningLayer.stackingNode()->isStackingContext() || !isolate);
 
     m_graphicsLayer->setIsRootForIsolatedGroup(isolate);
 }
 
+void CompositedLayerMapping::updateBackgroundPaintingLayer()
+{
+    bool backgroundLayerPaintsOntoScrollingContentsLayer = shouldPaintBackgroundOntoScrollingContentsLayer();
+    if (backgroundLayerPaintsOntoScrollingContentsLayer != m_backgroundPaintsOntoScrollingContentsLayer) {

[chrishtr, 2016/08/24 20:50:35]

What if backgroundLayerPaintsOntoScrollingContentsLayer starts to become true?
Doesn't m_owningLayer
need to be cleared out then?

[flackr, 2016/08/24 21:01:10]

It does, but in that case it's handled by
LayoutBoxModelObject::setBackingNeedsPaintInvalidationInRect because when we
know we're painting the background into the scrolling contents layer we
invalidate both layers.

+        m_backgroundPaintsOntoScrollingContentsLayer = backgroundLayerPaintsOntoScrollingContentsLayer;
+        // If the background is no longer painted onto the scrolling contents
+        // layer the scrolling contents layer needs to be updated. If it is
+        // going to be painted onto the scrolling contents layer this update
+        // will be triggered by LayoutBoxModelObject::setBackingNeedsPaintInvalidationInRect
+        if (hasScrollingLayer() && !backgroundLayerPaintsOntoScrollingContentsLayer) {

[chrishtr, 2016/08/24 00:33:26]

This is not the right place for this invalidation. Instead it should be done via
a style update on the PaintLayer, and use
the usual mechanisms. Does that not work?

[flackr, 2016/08/24 01:34:51]

Hmm, PaintLayer::styleDidChange could detect most of the reasons for not being
able to paint onto the scrolling contents layer but would it be able to tell
when hasNegativeZOrderList had changed? I'm not sure I understand why
invalidating here when the background moves between the background layer and
scrolling contents layer is different than the setNeedsDisplay calls that happen
in CompositedLayerMapping::updateScrollingLayerGeometry. Does the composited
layer mapping update happen too late to invalidate? 

+            m_scrollingContentsLayer->setNeedsDisplay();
+            m_owningLayer.setNeedsRepaint();
+        }
+    }
+}
+
 void CompositedLayerMapping::updateContentsOpaque()
 {
-    ASSERT(m_isMainFrameLayoutViewLayer || !m_backgroundLayer);
     if (isAcceleratedCanvas(layoutObject())) {
         // Determine whether the rendering context's external texture layer is opaque.
         CanvasRenderingContext* context = toHTMLCanvasElement(layoutObject()->node())->renderingContext();
         if (!context->hasAlpha())
             m_graphicsLayer->setContentsOpaque(true);
         else if (WebLayer* layer = context->platformLayer())
             m_graphicsLayer->setContentsOpaque(!Color(layer->backgroundColor()).hasAlpha());
         else
             m_graphicsLayer->setContentsOpaque(false);
     } else if (m_backgroundLayer) {
         m_graphicsLayer->setContentsOpaque(false);
         m_backgroundLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     } else {
         // For non-root layers, background is painted by the scrolling contents layer if all backgrounds
         // are background attachment local, otherwise background is painted by the primary graphics layer.
-        if (hasScrollingLayer() && shouldPaintBackgroundOntoScrollingContentsLayer()) {
+        if (hasScrollingLayer() && m_backgroundPaintsOntoScrollingContentsLayer) {
             // Backgrounds painted onto the foreground are clipped by the padding box rect.
             // TODO(flackr): This should actually check the entire overflow rect within the
             // scrolling contents layer but since we currently only trigger this for solid
             // color backgrounds the answer will be the same.
             m_scrollingContentsLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(toLayoutBox(layoutObject())->paddingBoxRect()));
 
             // When we paint the background onto the scrolling contents layer we are going
             // to leave a hole in the m_graphicsLayer where the background is so it is
             // not opaque.
             m_graphicsLayer->setContentsOpaque(false);
         } else {
+            if (hasScrollingLayer())
+                m_scrollingContentsLayer->setContentsOpaque(false);
             m_graphicsLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
         }
     }
 }
 
 void CompositedLayerMapping::updateCompositedBounds()
 {
     ASSERT(m_owningLayer.compositor()->lifecycle().state() == DocumentLifecycle::InCompositingUpdate);
     // FIXME: if this is really needed for performance, it would be better to store it on Layer.
     m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
@@ skipping 425 matching lines @@
 
     if (m_owningLayer.getScrollableArea() && m_owningLayer.getScrollableArea()->scrollsOverflow())
         m_owningLayer.getScrollableArea()->positionOverflowControls();
 
     updateLayerBlendMode(layoutObject()->styleRef());
     updateIsRootForIsolatedGroup();
     updateContentsRect();
     updateBackgroundColor();
     updateDrawsContent();
     updateElementIdAndCompositorMutableProperties();
+    updateBackgroundPaintingLayer();
     updateContentsOpaque();
     updateAfterPartResize();
     updateRenderingContext();
     updateShouldFlattenTransform();
     updateChildrenTransform();
     updateScrollParent(scrollParent());
     registerScrollingLayers();
 
     updateCompositingReasons();
 }
@@ skipping 1672 matching lines @@
     else if (compositor()->fixedRootBackgroundLayer() && m_owningLayer.isRootLayer())
         paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
 
     if (graphicsLayer == m_graphicsLayer.get()
         || graphicsLayer == m_foregroundLayer.get()
         || graphicsLayer == m_backgroundLayer.get()
         || graphicsLayer == m_maskLayer.get()
         || graphicsLayer == m_childClippingMaskLayer.get()
         || graphicsLayer == m_scrollingContentsLayer.get()) {
 
-        bool paintRootBackgroundOntoScrollingContentsLayer = shouldPaintBackgroundOntoScrollingContentsLayer();
+        bool paintRootBackgroundOntoScrollingContentsLayer = m_backgroundPaintsOntoScrollingContentsLayer;
         DCHECK(!paintRootBackgroundOntoScrollingContentsLayer || (!m_backgroundLayer && !m_foregroundLayer));
         if (paintRootBackgroundOntoScrollingContentsLayer) {
             if (graphicsLayer == m_scrollingContentsLayer.get())
                 paintLayerFlags &= ~PaintLayerPaintingSkipRootBackground;
             else
                 paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
         }
         GraphicsLayerPaintInfo paintInfo;
         paintInfo.paintLayer = &m_owningLayer;
         paintInfo.compositedBounds = compositedBounds();
@@ skipping 219 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink