| // 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 "core/layout/compositing/CompositingReasonFinder.h" |
| |
| #include "core/CSSPropertyNames.h" |
| #include "core/dom/Document.h" |
| #include "core/frame/FrameView.h" |
| #include "core/frame/Settings.h" |
| #include "core/layout/LayoutView.h" |
| #include "core/page/Page.h" |
| #include "core/paint/PaintLayer.h" |
| |
| namespace blink { |
| |
| CompositingReasonFinder::CompositingReasonFinder(LayoutView& layoutView) |
| : m_layoutView(layoutView), |
| m_compositingTriggers( |
| static_cast<CompositingTriggerFlags>(AllCompositingTriggers)) { |
| updateTriggers(); |
| } |
| |
| void CompositingReasonFinder::updateTriggers() { |
| m_compositingTriggers = 0; |
| |
| Settings& settings = m_layoutView.document().page()->settings(); |
| if (settings.preferCompositingToLCDTextEnabled()) { |
| m_compositingTriggers |= ScrollableInnerFrameTrigger; |
| m_compositingTriggers |= OverflowScrollTrigger; |
| m_compositingTriggers |= ViewportConstrainedPositionedTrigger; |
| } |
| } |
| |
| bool CompositingReasonFinder::isMainFrame() const { |
| return m_layoutView.document().isInMainFrame(); |
| } |
| |
| CompositingReasons CompositingReasonFinder::directReasons( |
| const PaintLayer* layer) const { |
| if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) |
| return CompositingReasonNone; |
| |
| ASSERT(potentialCompositingReasonsFromStyle(layer->layoutObject()) == |
| layer->potentialCompositingReasonsFromStyle()); |
| CompositingReasons styleDeterminedDirectCompositingReasons = |
| layer->potentialCompositingReasonsFromStyle() & |
| CompositingReasonComboAllDirectStyleDeterminedReasons; |
| |
| 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_layoutView.needsLayout()); |
| if (isMainFrame()) |
| return false; |
| |
| if (!(m_compositingTriggers & ScrollableInnerFrameTrigger)) |
| return false; |
| |
| return m_layoutView.frameView()->isScrollable(); |
| } |
| |
| CompositingReasons |
| CompositingReasonFinder::potentialCompositingReasonsFromStyle( |
| LayoutObject* layoutObject) const { |
| if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) |
| return CompositingReasonNone; |
| |
| CompositingReasons reasons = CompositingReasonNone; |
| |
| const ComputedStyle& style = layoutObject->styleRef(); |
| |
| if (requiresCompositingForTransform(layoutObject)) |
| reasons |= CompositingReason3DTransform; |
| |
| if (style.backfaceVisibility() == BackfaceVisibilityHidden) |
| reasons |= CompositingReasonBackfaceVisibilityHidden; |
| |
| if (requiresCompositingForAnimation(style)) |
| reasons |= CompositingReasonActiveAnimation; |
| |
| if (style.hasWillChangeCompositingHint() && |
| !style.subtreeWillChangeContents()) |
| reasons |= CompositingReasonWillChangeCompositingHint; |
| |
| if (style.hasInlineTransform()) |
| reasons |= CompositingReasonInlineTransform; |
| |
| if (style.usedTransformStyle3D() == TransformStyle3DPreserve3D) |
| reasons |= CompositingReasonPreserve3DWith3DDescendants; |
| |
| if (style.hasPerspective()) |
| reasons |= CompositingReasonPerspectiveWith3DDescendants; |
| |
| if (style.hasCompositorProxy()) |
| reasons |= CompositingReasonCompositorProxy; |
| |
| // If the implementation of createsGroup changes, we need to be aware of that |
| // in this part of code. |
| ASSERT((layoutObject->isTransparent() || layoutObject->hasMask() || |
| layoutObject->hasFilterInducingProperty() || style.hasBlendMode()) == |
| layoutObject->createsGroup()); |
| |
| if (style.hasMask()) |
| reasons |= CompositingReasonMaskWithCompositedDescendants; |
| |
| if (style.hasFilterInducingProperty()) |
| reasons |= CompositingReasonFilterWithCompositedDescendants; |
| |
| if (style.hasBackdropFilter()) |
| reasons |= CompositingReasonBackdropFilter; |
| |
| // See Layer::updateTransform for an explanation of why we check both. |
| if (layoutObject->hasTransformRelatedProperty() && style.hasTransform()) |
| reasons |= CompositingReasonTransformWithCompositedDescendants; |
| |
| if (layoutObject->isTransparent()) |
| reasons |= CompositingReasonOpacityWithCompositedDescendants; |
| |
| if (style.hasBlendMode()) |
| reasons |= CompositingReasonBlendingWithCompositedDescendants; |
| |
| if (layoutObject->hasReflection()) |
| reasons |= CompositingReasonReflectionWithCompositedDescendants; |
| |
| ASSERT(!(reasons & ~CompositingReasonComboAllStyleDeterminedReasons)); |
| return reasons; |
| } |
| |
| bool CompositingReasonFinder::requiresCompositingForTransform( |
| LayoutObject* layoutObject) const { |
| // Note that we ask the layoutObject if it has a transform, because the style |
| // may have transforms, but the layoutObject may be an inline that doesn't |
| // support them. |
| return layoutObject->hasTransformRelatedProperty() && |
| layoutObject->style()->has3DTransform(); |
| } |
| |
| CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons( |
| const PaintLayer* layer) const { |
| CompositingReasons directReasons = CompositingReasonNone; |
| LayoutObject* layoutObject = layer->layoutObject(); |
| |
| if (layer->needsCompositedScrolling()) |
| directReasons |= CompositingReasonOverflowScrollingTouch; |
| |
| // Composite |layer| if it is inside of an ancestor scrolling layer, but that |
| // scrolling layer is not on the stacking context ancestor chain of |layer|. |
| // See the definition of the scrollParent property in Layer for more detail. |
| if (const PaintLayer* scrollingAncestor = layer->ancestorScrollingLayer()) { |
| if (scrollingAncestor->needsCompositedScrolling() && layer->scrollParent()) |
| directReasons |= CompositingReasonOverflowScrollingParent; |
| } |
| |
| // TODO(flackr): Rename functions and variables to include sticky position |
| // (i.e. ScrollDependentPosition rather than PositionFixed). |
| if (requiresCompositingForScrollDependentPosition(layer)) |
| directReasons |= CompositingReasonScrollDependentPosition; |
| |
| directReasons |= layoutObject->additionalCompositingReasons(); |
| |
| ASSERT(!(directReasons & CompositingReasonComboAllStyleDeterminedReasons)); |
| return directReasons; |
| } |
| |
| bool CompositingReasonFinder::requiresCompositingForAnimation( |
| const ComputedStyle& style) const { |
| if (style.subtreeWillChangeContents()) |
| return style.isRunningAnimationOnCompositor(); |
| |
| return style.shouldCompositeForCurrentAnimations(); |
| } |
| |
| bool CompositingReasonFinder::requiresCompositingForScrollDependentPosition( |
| const PaintLayer* layer) const { |
| if (layer->layoutObject()->style()->position() != FixedPosition && |
| layer->layoutObject()->style()->position() != StickyPosition) |
| return false; |
| |
| if (!(m_compositingTriggers & ViewportConstrainedPositionedTrigger) && |
| (!RuntimeEnabledFeatures::compositeOpaqueFixedPositionEnabled() || |
| !layer->backgroundIsKnownToBeOpaqueInRect( |
| LayoutRect(layer->boundingBoxForCompositing())))) { |
| 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. |
| if (layer->scrollsWithViewport()) |
| return m_layoutView.frameView()->isScrollable(); |
| return layer->layoutObject()->style()->position() == StickyPosition && |
| layer->ancestorOverflowLayer()->scrollsOverflow(); |
| } |
| |
| } // namespace blink |