Fix Compositing of Opaque Scrolling Layers and Add Tests

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 2316 matching lines @@
     switch (compositingState()) {
     case NotComposited:
         return 0;
     case PaintsIntoGroupedBacking:
         return groupedMapping()->squashingLayer();
     default:
         return compositedLayerMapping()->scrollingContentsLayer() ? compositedLayerMapping()->scrollingContentsLayer() : compositedLayerMapping()->mainGraphicsLayer();
     }
 }
 
+bool PaintLayer::shouldPaintBackgroundOntoScrollingContentsLayer() const
+{
+    return !isRootLayer()
+        && scrollsOverflow()
+        && layoutObject()->style()->hasEntirelyLocalBackground()
+        && !stackingNode()->hasNegativeZOrderList();
+}
+
 void PaintLayer::ensureCompositedLayerMapping()
 {
     if (m_rareData && m_rareData->compositedLayerMapping)
         return;
 
     ensureRareData().compositedLayerMapping = wrapUnique(new CompositedLayerMapping(*this));
     m_rareData->compositedLayerMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
 
     updateOrRemoveFilterEffectBuilder();
 }
@@ skipping 43 matching lines @@
     return m_rareData && m_rareData->compositedLayerMapping && m_rareData->compositedLayerMapping->hasChildClippingMaskLayer();
 }
 
 bool PaintLayer::paintsWithTransform(GlobalPaintFlags globalPaintFlags) const
 {
     return (transform() || layoutObject()->style()->position() == FixedPosition) && ((globalPaintFlags & GlobalPaintFlattenCompositingLayers) || compositingState() != PaintsIntoOwnBacking);
 }
 
 bool PaintLayer::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
-    if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
-        return false;

[Stephen Chennney, 2016/08/29 20:49:52]

This check is redundant in all pre-existing callers except the one below in
childBackgroundIsKnownToBeOpaqueInRect. All the other cases are GraphicsLayers
calling it on their m_owningLayer, so it must be self painting. I verified that
with CHECKs.

-
     if (paintsWithTransparency(GlobalPaintNormalPhase))
         return false;
 
     // We can't use hasVisibleContent(), because that will be true if our layoutObject is hidden, but some child
     // is visible and that child doesn't cover the entire rect.
     if (layoutObject()->style()->visibility() != EVisibility::Visible)
         return false;
 
     if (paintsWithFilters() && layoutObject()->style()->filter().hasFilterThatAffectsOpacity())
         return false;
 
     // FIXME: Handle simple transforms.
     if (paintsWithTransform(GlobalPaintNormalPhase))
         return false;
 
     // FIXME: Remove this check.
     // This function should not be called when layer-lists are dirty.
     // It is somehow getting triggered during style update.
     if (m_stackingNode->zOrderListsDirty())
         return false;
 
-    // FIXME: We currently only check the immediate layoutObject,
-    // which will miss many cases.
     if (layoutObject()->backgroundIsKnownToBeOpaqueInRect(localRect))
         return true;
 
     // We can't consult child layers if we clip, since they might cover
     // parts of the rect that are clipped out.
     if (layoutObject()->hasClipRelatedProperty())
         return false;
 
+    // TODO(schenney): This could be improved by unioning the opaque regions of all the children.
+    // That would require a refactoring because currently children just check they at least
+    // cover the given rect, but a unioning method would require children to compute and report
+    // their rects.
     return childBackgroundIsKnownToBeOpaqueInRect(localRect);
 }
 
 bool PaintLayer::childBackgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
-    PaintLayerStackingNodeReverseIterator revertseIterator(*m_stackingNode, PositiveZOrderChildren | NormalFlowChildren | NegativeZOrderChildren);
-    while (PaintLayerStackingNode* child = revertseIterator.next()) {
+    PaintLayerStackingNodeReverseIterator reverseIterator(*m_stackingNode, PositiveZOrderChildren | NormalFlowChildren | NegativeZOrderChildren);
+    while (PaintLayerStackingNode* child = reverseIterator.next()) {
         const PaintLayer* childLayer = child->layer();
         // Stop at composited paint boundaries.
         if (childLayer->isPaintInvalidationContainer())

[Stephen Chennney, 2016/08/29 20:49:52]

I think this means we do not need to check that the child is a
selfPaintingLayer, per the previous logic. Regardless, that logic seems wrong.
As far as I can tell, we should return false here is the child IS a self
painting layer because it will not then contribute to the opacity of it's
parent's layer.

The code hasn't changed wince it was originally added in 2013, back in WebKit.
So it doesn't surprise me if it's out of data.

             continue;
 
         if (!childLayer->canUseConvertToLayerCoords())
             continue;
 
         LayoutPoint childOffset;
         LayoutRect childLocalRect(localRect);
         childLayer->convertToLayerCoords(this, childOffset);
         childLocalRect.moveBy(-childOffset);
 
@@ skipping 494 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif