Initial scroll-blocks-on compositor integration

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 "core/CSSPropertyNames.h"
 #include "core/dom/Document.h"
 #include "core/frame/FrameView.h"
@@ skipping 31 matching lines @@
 bool CompositingReasonFinder::isMainFrame() const
 {
     // FIXME: LocalFrame::isMainFrame() is probably better.
     return !m_renderView.document().ownerElement();
 }
 
 CompositingReasons CompositingReasonFinder::directReasons(const RenderLayer* layer) const
 {
     ASSERT(potentialCompositingReasonsFromStyle(layer->renderer()) == layer->potentialCompositingReasonsFromStyle());
     CompositingReasons styleDeterminedDirectCompositingReasons = layer->potentialCompositingReasonsFromStyle() & CompositingReasonComboAllDirectStyleDeterminedReasons;
+
+    // Apply optimizations for scroll-blocks-on which require comparing style between objects.
+    if ((styleDeterminedDirectCompositingReasons & CompositingReasonScrollBlocksOn) && !requiresCompositingForScrollBlocksOn(layer->renderer()))
+        styleDeterminedDirectCompositingReasons &= ~CompositingReasonScrollBlocksOn;
+
     return styleDeterminedDirectCompositingReasons | nonStyleDeterminedDirectReasons(layer);
 }
 
 // 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;
@@ skipping 24 matching lines @@
 
     if (style->hasInlineTransform())
         reasons |= CompositingReasonInlineTransform;
 
     if (style->transformStyle3D() == TransformStyle3DPreserve3D)
         reasons |= CompositingReasonPreserve3DWith3DDescendants;
 
     if (style->hasPerspective())
         reasons |= CompositingReasonPerspectiveWith3DDescendants;
 
+    // Ignore scroll-blocks-on on the document element, because it will get propagated to
+    // the RenderView (by Document::inheritHtmlAndBodyElementStyles) and we don't want to
+    // create two composited layers.
+    if (style->hasScrollBlocksOn() && !renderer->isDocumentElement())
+        reasons |= CompositingReasonScrollBlocksOn;
+
     // If the implementation of createsGroup changes, we need to be aware of that in this part of code.
     ASSERT((renderer->isTransparent() || renderer->hasMask() || renderer->hasFilter() || style->hasBlendMode()) == renderer->createsGroup());
 
     if (style->hasMask())
         reasons |= CompositingReasonMaskWithCompositedDescendants;
 
     if (style->hasFilter())
         reasons |= CompositingReasonFilterWithCompositedDescendants;
 
     // See RenderLayer::updateTransform for an explanation of why we check both.
     if (renderer->hasTransformRelatedProperty() && style->hasTransform())
         reasons |= CompositingReasonTransformWithCompositedDescendants;
 
     if (renderer->isTransparent())
         reasons |= CompositingReasonOpacityWithCompositedDescendants;
 
     if (style->hasBlendMode())
         reasons |= CompositingReasonBlendingWithCompositedDescendants;
 
     if (renderer->hasReflection())
         reasons |= CompositingReasonReflectionWithCompositedDescendants;
 
     ASSERT(!(reasons & ~CompositingReasonComboAllStyleDeterminedReasons));
     return reasons;
 }
 
 bool CompositingReasonFinder::requiresCompositingForTransform(RenderObject* renderer) const
 {
     // 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.
+    // but the renderer may be an inline that doesn't support them.
     return renderer->hasTransformRelatedProperty() && renderer->style()->transform().has3DOperation();
 }
 
 CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(const RenderLayer* layer) const
 {
     CompositingReasons directReasons = CompositingReasonNone;
     RenderObject* renderer = layer->renderer();
 
     if (hasOverflowScrollTrigger()) {
         if (layer->clipParent())
@@ skipping 27 matching lines @@
 
 bool CompositingReasonFinder::requiresCompositingForPositionFixed(const RenderLayer* layer) const
 {
     if (!(m_compositingTriggers & ViewportConstrainedPositionedTrigger))
         return false;
     // Don't promote fixed position elements that are descendants of a non-view container, e.g. transformed elements.
     // They will stay fixed wrt the container rather than the enclosing frame.
     return layer->scrollsWithViewport() && m_renderView.frameView()->isScrollable();
 }
 
+bool CompositingReasonFinder::requiresCompositingForScrollBlocksOn(const RenderObject* renderer) const
+{
+    // Note that the other requires* functions run at RenderObject::styleDidChange time and so can rely
+    // only on the style of their object.  This function runs at CompositingRequirementsUpdater::update
+    // time, and so can consider the style of other objects.
+    RenderStyle* style = renderer->style();
+
+    // We should only get here by CompositingReasonScrollBlocksOn being a potential compositing reason.
+    ASSERT(style->hasScrollBlocksOn() && !renderer->isDocumentElement());
+
+    // scroll-blocks-on style is propagated from the document element to the document.
+    ASSERT(!renderer->isRenderView()
+        || !renderer->document().documentElement()
+        || !renderer->document().documentElement()->renderer()
+        || renderer->document().documentElement()->renderer()->style()->scrollBlocksOn() == style->scrollBlocksOn());
+
+    // When a scroll occurs, it's the union of all bits set on the target element's containing block
+    // chain that determines the behavior.  Thus we really only need a new layer if this object contains
+    // additional bits from those set by all objects in it's containing block chain.  But determining
+    // this fully is probably more expensive than it's worth.  Instead we just have fast-paths here for
+    // the most common cases of unnecessary layer creation.
+    // Optimizing this fully would avoid layer explosion in pathological cases like '*' rules.
+    // We could consider tracking the current state in CompositingRequirementsUpdater::update.
+
+    // Ensure iframes don't get composited when they require no more blocking than the root.
+    if (renderer->isRenderView()) {
+        if (const FrameView* parentFrame = toRenderView(renderer)->frameView()->parentFrameView()) {
+            if (const RenderView* parentRenderer = parentFrame->renderView()) {
+                // Does this frame contain only blocks-on bits already present in the parent frame?
+                if (!(style->scrollBlocksOn() & ~parentRenderer->style()->scrollBlocksOn()))
+                    return false;
+            }
+        }
+    }
+
+    return true;
 }
+
+}