Hoist compositorDrivenAcceleratedScrollingEnabled check out of scrollParent

This CL moves the compositorDrivenAcceleratedScrollingEnabled check out of
scrollParent so that it's clearer in the callers that this code only does
something when this setting is enabled.

In compositorDrivenAcceleratedScrollingEnabled, this lets us call
compositorDrivenAcceleratedScrollingEnabled once instead of twice, which is
faster. In a future CL, I'll cache compositorDrivenAcceleratedScrollingEnabled
as a compositing trigger, which will make this code actually go fast.

This CL also reorders a bunch of methods in CompositingReasonFinder.cpp to make
it clearer which of these functions are called during style recalc and which
are call unconditionally on all RenderLayers.

Review URL: https://codereview.chromium.org/205343009

git-svn-id: svn://svn.chromium.org/blink/trunk@169992 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/core/rendering/RenderLayer.cpp

@@ -1724,8 +1724,7 @@ void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutR
 
 RenderLayer* RenderLayer::scrollParent() const
 {
-    if (!renderer()->compositorDrivenAcceleratedScrollingEnabled())
-        return 0;
+    ASSERT(renderer()->compositorDrivenAcceleratedScrollingEnabled());
 
     // Normal flow elements will be parented under the main scrolling layer, so
     // we don't need a scroll parent/child relationship to get them to scroll.

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

@@ -479,7 +479,7 @@ bool CompositedLayerMapping::updateGraphicsLayerConfiguration()
     if (m_owningLayer.needsCompositedScrolling())
         needsDescendentsClippingLayer = false;
 
-    RenderLayer* scrollParent = m_owningLayer.scrollParent();
+    RenderLayer* scrollParent = renderer->compositorDrivenAcceleratedScrollingEnabled() ? m_owningLayer.scrollParent() : 0;
     bool needsAncestorClip = compositor->clippedByAncestor(&m_owningLayer);
     if (scrollParent) {
         // If our containing block is our ancestor scrolling layer, then we'll already be clipped
@@ -901,7 +901,7 @@ GraphicsLayerUpdater::UpdateType CompositedLayerMapping::updateGraphicsLayerGeom
     updateRenderingContext();
     updateShouldFlattenTransform();
     updateChildrenTransform();
-    updateScrollParent(m_owningLayer.scrollParent());
+    updateScrollParent(renderer()->compositorDrivenAcceleratedScrollingEnabled() ? m_owningLayer.scrollParent() : 0);
     registerScrollingLayers();
 
     updateCompositingReasons();
@@ -1428,7 +1428,7 @@ static void updateScrollParentForGraphicsLayer(GraphicsLayer* layer, GraphicsLay
 
 void CompositedLayerMapping::updateScrollParent(RenderLayer* scrollParent)
 {
-    if (!scrollParent && m_squashedLayers.size())
+    if (!scrollParent && m_squashedLayers.size() && renderer()->compositorDrivenAcceleratedScrollingEnabled())
         scrollParent = m_squashedLayers[0].renderLayer->scrollParent();
 
     if (ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer)) {

third_party/WebKit/Source/core/rendering/compositing/CompositingReasonFinder.cpp

@@ -59,6 +59,28 @@ bool CompositingReasonFinder::isMainFrame() const
     return !m_renderView.document().ownerElement();
 }
 
+CompositingReasons CompositingReasonFinder::directReasons(const RenderLayer* layer, bool* needToRecomputeCompositingRequirements) const
+{
+    CompositingReasons styleReasons = layer->styleDeterminedCompositingReasons();
+    ASSERT(styleDeterminedReasons(layer->renderer()) == 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 directReasons = CompositingReasonNone;
@@ -79,6 +101,43 @@ CompositingReasons CompositingReasonFinder::styleDeterminedReasons(RenderObject*
     return directReasons;
 }
 
+bool CompositingReasonFinder::requiresCompositingForTransform(RenderObject* renderer) const
+{
+    if (!(m_compositingTriggers & ThreeDTransformTrigger))
+        return false;
+
+    // Note that we ask the renderer if it has a transform, because the style may have transforms,
+    // but the renderer may be an inline that doesn't suppport them.
+    return renderer->hasTransform() && renderer->style()->transform().has3DOperation();
+}
+
+bool CompositingReasonFinder::requiresCompositingForBackfaceVisibilityHidden(RenderObject* renderer) const
+{
+    if (!(m_compositingTriggers & ThreeDTransformTrigger))
+        return false;
+
+    return renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden;
+}
+
+bool CompositingReasonFinder::requiresCompositingForFilters(RenderObject* renderer) const
+{
+    if (!(m_compositingTriggers & FilterTrigger))
+        return false;
+
+    return renderer->hasFilter();
+}
+
+bool CompositingReasonFinder::requiresCompositingForWillChange(const RenderObject* renderer) const
+{
+    if (renderer->style()->hasWillChangeCompositingHint())
+        return true;
+
+    if (!(m_compositingTriggers & GPURasterizationTrigger))
+        return false;
+
+    return renderer->style()->hasWillChangeGpuRasterizationHint();
+}
+
 CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(const RenderLayer* layer, bool* needToRecomputeCompositingRequirements) const
 {
     CompositingReasons directReasons = CompositingReasonNone;
@@ -87,14 +146,16 @@ CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(cons
     if (requiresCompositingForAnimation(renderer))
         directReasons |= CompositingReasonActiveAnimation;
 
+    if (m_renderView.compositorDrivenAcceleratedScrollingEnabled()) {
         if (requiresCompositingForOutOfFlowClipping(layer))
             directReasons |= CompositingReasonOutOfFlowClipping;
 
-    if (requiresCompositingForOverflowScrolling(layer))
-        directReasons |= CompositingReasonOverflowScrollingTouch;
-
         if (requiresCompositingForOverflowScrollingParent(layer))
             directReasons |= CompositingReasonOverflowScrollingParent;
+    }
+
+    if (requiresCompositingForOverflowScrolling(layer))
+        directReasons |= CompositingReasonOverflowScrollingTouch;
 
     if (requiresCompositingForPosition(renderer, layer, 0, needToRecomputeCompositingRequirements))
         directReasons |= renderer->style()->position() == FixedPosition ? CompositingReasonPositionFixed : CompositingReasonPositionSticky;
@@ -105,46 +166,6 @@ CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(cons
     return directReasons;
 }
 
-CompositingReasons CompositingReasonFinder::directReasons(const RenderLayer* layer, bool* needToRecomputeCompositingRequirements) const
-{
-    CompositingReasons styleReasons = layer->styleDeterminedCompositingReasons();
-    ASSERT(styleDeterminedReasons(layer->renderer()) == styleReasons);
-    return styleReasons | nonStyleDeterminedDirectReasons(layer, needToRecomputeCompositingRequirements);
-}
-
-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();
-}
-
-bool CompositingReasonFinder::requiresCompositingForTransform(RenderObject* renderer) const
-{
-    if (!(m_compositingTriggers & ThreeDTransformTrigger))
-        return false;
-
-    RenderStyle* style = renderer->style();
-    // Note that we ask the renderer if it has a transform, because the style may have transforms,
-    // but the renderer may be an inline that doesn't suppport them.
-    return renderer->hasTransform() && style->transform().has3DOperation();
-}
-
-bool CompositingReasonFinder::requiresCompositingForBackfaceVisibilityHidden(RenderObject* renderer) const
-{
-    if (!(m_compositingTriggers & ThreeDTransformTrigger))
-        return false;
-
-    return renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden;
-}
-
 bool CompositingReasonFinder::requiresCompositingForAnimation(RenderObject* renderer) const
 {
     if (!(m_compositingTriggers & AnimationTrigger))
@@ -153,33 +174,19 @@ bool CompositingReasonFinder::requiresCompositingForAnimation(RenderObject* rend
     return shouldCompositeForActiveAnimations(*renderer);
 }
 
-bool CompositingReasonFinder::requiresCompositingForFilters(RenderObject* renderer) const
+bool CompositingReasonFinder::requiresCompositingForOutOfFlowClipping(const RenderLayer* layer) const
 {
-    if (!(m_compositingTriggers & FilterTrigger))
-        return false;
-
-    return renderer->hasFilter();
+    return layer->isUnclippedDescendant();
 }
 
 bool CompositingReasonFinder::requiresCompositingForOverflowScrollingParent(const RenderLayer* layer) const
 {
-    return !!layer->scrollParent();
-}
-
-bool CompositingReasonFinder::requiresCompositingForOutOfFlowClipping(const RenderLayer* layer) const
-{
-    return m_renderView.compositorDrivenAcceleratedScrollingEnabled() && layer->isUnclippedDescendant();
+    return layer->scrollParent();
 }
 
-bool CompositingReasonFinder::requiresCompositingForWillChange(const RenderObject* renderer) const
+bool CompositingReasonFinder::requiresCompositingForOverflowScrolling(const RenderLayer* layer) const
 {
-    if (renderer->style()->hasWillChangeCompositingHint())
-        return true;
-
-    if (!(m_compositingTriggers & GPURasterizationTrigger))
-        return false;
-
-    return renderer->style()->hasWillChangeGpuRasterizationHint();
+    return layer->needsCompositedScrolling();
 }
 
 bool CompositingReasonFinder::isViewportConstrainedFixedOrStickyLayer(const RenderLayer* layer)
@@ -302,9 +309,4 @@ bool CompositingReasonFinder::requiresCompositingForPosition(RenderObject* rende
     return true;
 }
 
-bool CompositingReasonFinder::requiresCompositingForOverflowScrolling(const RenderLayer* layer) const
-{
-    return layer->needsCompositedScrolling();
-}
-
 }