Suppress layer creation for descendants of GPU-rasterized layers

Source/core/rendering/compositing/CompositingRequirementsUpdater.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google 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
@@ skipping 145 matching lines @@
 };
 
 class CompositingRequirementsUpdater::RecursionData {
 public:
     RecursionData(RenderLayer* compAncestor, RenderLayer* mostRecentCompositedLayer, bool testOverlap)
         : m_compositingAncestor(compAncestor)
         , m_mostRecentCompositedLayer(mostRecentCompositedLayer)
         , m_subtreeIsCompositing(false)
         , m_hasUnisolatedCompositedBlendingDescendant(false)
         , m_testingOverlap(testOverlap)
+        , m_suppressLayerCreation(false)
 #ifndef NDEBUG
         , m_depth(0)
 #endif
     {
     }
 
     RecursionData(const RecursionData& other)
         : m_compositingAncestor(other.m_compositingAncestor)
         , m_mostRecentCompositedLayer(other.m_mostRecentCompositedLayer)
         , m_subtreeIsCompositing(other.m_subtreeIsCompositing)
         , m_hasUnisolatedCompositedBlendingDescendant(other.m_hasUnisolatedCompositedBlendingDescendant)
         , m_testingOverlap(other.m_testingOverlap)
+        , m_suppressLayerCreation(other.m_suppressLayerCreation)
 #ifndef NDEBUG
         , m_depth(other.m_depth + 1)
 #endif
     {
     }
 
     RenderLayer* m_compositingAncestor;
     RenderLayer* m_mostRecentCompositedLayer; // in paint order regardless of hierarchy.
     bool m_subtreeIsCompositing;
     bool m_hasUnisolatedCompositedBlendingDescendant;
     bool m_testingOverlap;
+    bool m_suppressLayerCreation;
 #ifndef NDEBUG
     int m_depth;
 #endif
 };
 
 static bool requiresCompositingOrSquashing(CompositingReasons reasons)
 {
 #ifndef NDEBUG
     bool fastAnswer = reasons != CompositingReasonNone;
     bool slowAnswer = requiresCompositing(reasons) || requiresSquashing(reasons);
     ASSERT(fastAnswer == slowAnswer);
 #endif
     return reasons != CompositingReasonNone;
 }
 
+static bool shouldMakeDescendantsSuppressCompositedLayerCreation(CompositingReasons reasons)
+{
+    return reasons & CompositingReasonWillChangeGpuRasterizationHint;
+}
+
 static CompositingReasons subtreeReasonsForCompositing(RenderObject* renderer, bool hasCompositedDescendants, bool has3DTransformedDescendants)
 {
     CompositingReasons subtreeReasons = CompositingReasonNone;
 
     // FIXME: this seems to be a potentially different layer than the layer for which this was called. May not be an error, but is very confusing.
     RenderLayer* layer = toRenderBoxModelObject(renderer)->layer();
 
     // When a layer has composited descendants, some effects, like 2d transforms, filters, masks etc must be implemented
     // via compositing so that they also apply to those composited descdendants.
     if (hasCompositedDescendants) {
@@ skipping 65 matching lines @@
     IntRect absoluteDecendantBoundingBox;
     updateRecursive(0, root, overlapTestRequestMap, recursionData, saw3DTransform, unclippedDescendants, absoluteDecendantBoundingBox);
 }
 
 void CompositingRequirementsUpdater::updateRecursive(RenderLayer* ancestorLayer, RenderLayer* layer, OverlapMap& overlapMap, RecursionData& currentRecursionData, bool& descendantHas3DTransform, Vector<RenderLayer*>& unclippedDescendants, IntRect& absoluteDecendantBoundingBox)
 {
     RenderLayerCompositor* compositor = m_renderView.compositor();
 
     layer->stackingNode()->updateLayerListsIfNeeded();
 
+    bool needToRecomputeStyleReasons = layer->suppressingCompositedLayerCreation() != currentRecursionData.m_suppressLayerCreation;
+    layer->setSuppressingCompositedLayerCreation(currentRecursionData.m_suppressLayerCreation);

[abarth-chromium, 2014/04/14 20:29:53]

Why is this a property of the RenderLayer?  It seems more like a temporary
variable used by this algorithm.

[ajuma, 2014/04/15 19:11:34]

As long as we continue to have incremental compositing updates, we need to know
this elsewhere too (in particular, in the latest patch set, this is used in
RenderLayerCompositor::updateDirectCompositingReasons). If we don't take
suppression into account during incremental updates, we'll think (during the
incremental update) that a non-composited layer needs to become composited even
when it doesn't (because its only compositing reasons are being suppressed);
this will cause RenderLayerCompositor::updateLayerCompositingState to make the
wrong decisions.

+
     // Clear the flag
     layer->setHasCompositingDescendant(false);
 
     // Start by assuming this layer will not need to composite.
     CompositingReasons reasonsToComposite = CompositingReasonNone;
 
+    if (needToRecomputeStyleReasons)

[abarth-chromium, 2014/04/14 20:29:53]

There's no such thing as a need to recompute style-determined reasons.  The
style-determined reasons are just that: determined by style.  Maybe it would be
more appropriate to phrase this code in terms of how we interpret those reasons
instead of mutating state that was computed earlier in the pipeline.

[ajuma, 2014/04/15 19:11:34]

Fixed. Instead of mutating style-determined reasons, style reasons are now
stored separately in RenderLayer.

+        compositor->updateStyleDeterminedCompositingReasons(layer);
+
     // First accumulate the straightforward compositing reasons.
     CompositingReasons directReasons = m_compositingReasonFinder.directReasons(layer, m_needsToRecomputeCompositingRequirements);
 
     // Video is special. It's the only RenderLayer type that can both have
     // RenderLayer children and whose children can't use its backing to render
     // into. These children (the controls) always need to be promoted into their
     // own layers to draw on top of the accelerated video.
     if (currentRecursionData.m_compositingAncestor && currentRecursionData.m_compositingAncestor->renderer()->isVideo())
         directReasons |= CompositingReasonVideoOverlay;
 
@@ skipping 36 matching lines @@
     if (currentRecursionData.m_testingOverlap && !requiresCompositingOrSquashing(directReasons))
         overlapCompositingReason = overlapMap.overlapsLayers(absBounds) ? CompositingReasonOverlap : CompositingReasonNone;
 
     reasonsToComposite |= overlapCompositingReason;
 
     // The children of this layer don't need to composite, unless there is
     // a compositing layer among them, so start by inheriting the compositing
     // ancestor with m_subtreeIsCompositing set to false.
     RecursionData childRecursionData(currentRecursionData);
     childRecursionData.m_subtreeIsCompositing = false;
+    childRecursionData.m_suppressLayerCreation = layer->suppressingCompositedLayerCreation() || shouldMakeDescendantsSuppressCompositedLayerCreation(directReasons);
 
     bool willBeCompositedOrSquashed = compositor->canBeComposited(layer) && requiresCompositingOrSquashing(reasonsToComposite);
     if (willBeCompositedOrSquashed) {
         // Tell the parent it has compositing descendants.
         currentRecursionData.m_subtreeIsCompositing = true;
         // This layer now acts as the ancestor for kids.
         childRecursionData.m_compositingAncestor = layer;
 
         // Here we know that all children and the layer's own contents can blindly paint into
         // this layer's backing, until a descendant is composited. So, we don't need to check
@@ skipping 154 matching lines @@
 }
 
 bool CompositingRequirementsUpdater::isRunningAcceleratedTransformAnimation(RenderObject* renderer) const
 {
     if (!m_compositingReasonFinder.hasAnimationTrigger())
         return false;
     return renderer->style()->hasCurrentTransformAnimation();
 }
 
 } // namespace WebCore