Suppress layer creation for descendants of GPU-rasterized layers

Source/core/rendering/compositing/CompositingReasonFinder.cpp

 // Copyright 2014 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 "config.h"
 #include "core/rendering/compositing/CompositingReasonFinder.h"
 
 #include "CSSPropertyNames.h"
 #include "HTMLNames.h"
 #include "core/frame/FrameView.h"
@@ skipping 71 matching lines @@
 {
     return m_compositingTriggers & LegacyOverflowScrollTrigger;
 }
 
 bool CompositingReasonFinder::isMainFrame() const
 {
     // FIXME: LocalFrame::isMainFrame() is probably better.
     return !m_renderView.document().ownerElement();
 }
 
+CompositingReasons CompositingReasonFinder::suppressStyleDeterminedReasonsIfPossible(const RenderLayer* layer, CompositingReasons styleReasons) const
+{
+    CompositingReasons adjustedReasons = styleReasons;
+    adjustedReasons &= ~(CompositingReasonWillChangeCompositingHint | CompositingReasonWillChangeGpuRasterizationHint);
+
+    // We can suppress layer creation for animations before animations start, but not
+    // once they're already running on the compositor.
+    if (!layer->renderer()->style()->isRunningAnimationOnCompositor())
+        adjustedReasons &= ~CompositingReasonActiveAnimation;
+
+    return adjustedReasons;
+}
+
+
 CompositingReasons CompositingReasonFinder::directReasons(const RenderLayer* layer, bool* needToRecomputeCompositingRequirements) const
 {
     CompositingReasons styleReasons = layer->styleDeterminedCompositingReasons();
-    ASSERT(styleDeterminedReasons(layer->renderer()) == styleReasons);
+    ASSERT(styleDeterminedReasons(layer) == styleReasons);
     return styleReasons | nonStyleDeterminedDirectReasons(layer, needToRecomputeCompositingRequirements);
 }
 
 // This information doesn't appear to be incorporated into CompositingReasons.
 bool CompositingReasonFinder::requiresCompositingForScrollableFrame() const
 {
     // Need this done first to determine overflow.
     ASSERT(!m_renderView.needsLayout());
     if (isMainFrame())
         return false;
 
     if (!(m_compositingTriggers & ScrollableInnerFrameTrigger))
         return false;
 
     FrameView* frameView = m_renderView.frameView();
     return frameView->isScrollable();
 }
 
-CompositingReasons CompositingReasonFinder::styleDeterminedReasons(RenderObject* renderer) const
+CompositingReasons CompositingReasonFinder::styleDeterminedReasons(const RenderLayer* layer) const
 {
     CompositingReasons directReasons = CompositingReasonNone;
+    RenderObject* renderer = layer->renderer();
 
     if (requiresCompositingForTransform(renderer))
         directReasons |= CompositingReason3DTransform;
 
     if (requiresCompositingForBackfaceVisibilityHidden(renderer))
         directReasons |= CompositingReasonBackfaceVisibilityHidden;
 
     if (requiresCompositingForAnimation(renderer))
         directReasons |= CompositingReasonActiveAnimation;
 
     if (requiresCompositingForFilters(renderer))
         directReasons |= CompositingReasonFilters;
 
-    if (requiresCompositingForWillChange(renderer))
-        directReasons |= CompositingReasonWillChange;
+    if (requiresCompositingForWillChangeCompositingHint(renderer))
+        directReasons |= CompositingReasonWillChangeCompositingHint;
+
+    if (requiresCompositingForWillChangeGpuRasterizationHint(renderer))
+        directReasons |= CompositingReasonWillChangeGpuRasterizationHint;
+
+    if (layer->suppressingCompositedLayerCreation())
+        directReasons = suppressStyleDeterminedReasonsIfPossible(layer, directReasons);
 
     ASSERT(!(directReasons & ~CompositingReasonComboAllStyleDeterminedReasons));
     return directReasons;
 }
 
 bool CompositingReasonFinder::requiresCompositingForTransform(RenderObject* renderer) const
 {
     if (!(m_compositingTriggers & ThreeDTransformTrigger))
         return false;
 
@@ skipping 11 matching lines @@
 }
 
 bool CompositingReasonFinder::requiresCompositingForFilters(RenderObject* renderer) const
 {
     if (!(m_compositingTriggers & FilterTrigger))
         return false;
 
     return renderer->hasFilter();
 }
 
-bool CompositingReasonFinder::requiresCompositingForWillChange(const RenderObject* renderer) const
+bool CompositingReasonFinder::requiresCompositingForWillChangeCompositingHint(const RenderObject* renderer) const
 {
-    if (renderer->style()->hasWillChangeCompositingHint())
-        return true;
+    return renderer->style()->hasWillChangeCompositingHint();
+}
 
+bool CompositingReasonFinder::requiresCompositingForWillChangeGpuRasterizationHint(const RenderObject* renderer) const
+{
     if (!(m_compositingTriggers & GPURasterizationTrigger))
         return false;
 
     return renderer->style()->hasWillChangeGpuRasterizationHint();
 }
 
 CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(const RenderLayer* layer, bool* needToRecomputeCompositingRequirements) const
 {
     CompositingReasons directReasons = CompositingReasonNone;
     RenderObject* renderer = layer->renderer();
@@ skipping 152 matching lines @@
                 *needToRecomputeCompositingRequirements = true;
             }
             return false;
         }
     }
 
     return true;
 }
 
 }