CompositingReasonFinder should use a virtual function instead of a nest of branches

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/animation/ActiveAnimations.h"
@@ skipping 16 matching lines @@
 #include "core/rendering/RenderLayerStackingNodeIterator.h"
 #include "core/rendering/RenderReplica.h"
 #include "core/rendering/RenderVideo.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 
 namespace WebCore {
 
 CompositingReasonFinder::CompositingReasonFinder(RenderView& renderView)
     : m_renderView(renderView)
-    , m_compositingTriggers(static_cast<ChromeClient::CompositingTriggerFlags>(ChromeClient::AllTriggers))
+    , m_compositingTriggers(static_cast<CompositingTriggerFlags>(AllCompositingTriggers))
 {
 }
 
 void CompositingReasonFinder::updateTriggers()
 {
     m_compositingTriggers = m_renderView.document().page()->chrome().client().allowedCompositingTriggers();
 }
 
 bool CompositingReasonFinder::has3DTransformTrigger() const
 {
-    return m_compositingTriggers & ChromeClient::ThreeDTransformTrigger;
+    return m_compositingTriggers & ThreeDTransformTrigger;
 }
 
 bool CompositingReasonFinder::hasAnimationTrigger() const
 {
-    return m_compositingTriggers & ChromeClient::AnimationTrigger;
+    return m_compositingTriggers & AnimationTrigger;
 }
 
 bool CompositingReasonFinder::isMainFrame() const
 {
     // FIXME: LocalFrame::isMainFrame() is probably better.
     return !m_renderView.document().ownerElement();
 }
 
 CompositingReasons CompositingReasonFinder::directReasons(const RenderLayer* layer, bool* needToRecomputeCompositingRequirements) const
 {
     RenderObject* renderer = layer->renderer();
     CompositingReasons directReasons = CompositingReasonNone;
 
     if (requiresCompositingForTransform(renderer))
         directReasons |= CompositingReason3DTransform;
 
     // Only zero or one of the following conditions will be true for a given RenderLayer.
-    if (requiresCompositingForVideo(renderer))
-        directReasons |= CompositingReasonVideo;
-    else if (requiresCompositingForCanvas(renderer))
-        directReasons |= CompositingReasonCanvas;
-    else if (requiresCompositingForPlugin(renderer, needToRecomputeCompositingRequirements))
+    // FIXME: These should be handled by overrides of RenderObject::additionalCompositingReasons.
+    if (requiresCompositingForPlugin(renderer, needToRecomputeCompositingRequirements))
         directReasons |= CompositingReasonPlugin;
     else if (requiresCompositingForFrame(renderer, needToRecomputeCompositingRequirements))
         directReasons |= CompositingReasonIFrame;
 
     if (requiresCompositingForBackfaceVisibilityHidden(renderer))
         directReasons |= CompositingReasonBackfaceVisibilityHidden;
 
     if (requiresCompositingForAnimation(renderer))
         directReasons |= CompositingReasonActiveAnimation;
 
@@ skipping 11 matching lines @@
 
     if (requiresCompositingForOverflowScrollingParent(layer))
         directReasons |= CompositingReasonOverflowScrollingParent;
 
     if (requiresCompositingForOutOfFlowClipping(layer))
         directReasons |= CompositingReasonOutOfFlowClipping;
 
     if (requiresCompositingForWillChange(renderer))
         directReasons |= CompositingReasonWillChange;
 
+    directReasons |= renderer->additionalCompositingReasons(m_compositingTriggers);
+
     return directReasons;
 }
 
 bool CompositingReasonFinder::requiresCompositingForScrollableFrame() const
 {
     // Need this done first to determine overflow.
     ASSERT(!m_renderView.needsLayout());
     if (isMainFrame())
         return false;
 
-    if (!(m_compositingTriggers & ChromeClient::ScrollableInnerFrameTrigger))
+    if (!(m_compositingTriggers & ScrollableInnerFrameTrigger))
         return false;
 
     FrameView* frameView = m_renderView.frameView();
     return frameView->isScrollable();
 }
 
 bool CompositingReasonFinder::requiresCompositingForTransform(RenderObject* renderer) const
 {
-    if (!(m_compositingTriggers & ChromeClient::ThreeDTransformTrigger))
+    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::requiresCompositingForVideo(RenderObject* renderer) const
-{
-    if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && renderer->isVideo()) {
-        HTMLMediaElement* media = toHTMLMediaElement(renderer->node());
-        if (media->isFullscreen())
-            return true;
-    }
-
-    if (!(m_compositingTriggers & ChromeClient::VideoTrigger))
-        return false;
-
-    if (renderer->isVideo()) {
-        RenderVideo* video = toRenderVideo(renderer);
-        return video->shouldDisplayVideo() && video->supportsAcceleratedRendering();
-    }
-    return false;
-}
-
-bool CompositingReasonFinder::requiresCompositingForCanvas(RenderObject* renderer) const
-{
-    if (!(m_compositingTriggers & ChromeClient::CanvasTrigger))
-        return false;
-
-    if (renderer->isCanvas()) {
-        HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer->node());
-        return canvas->renderingContext() && canvas->renderingContext()->isAccelerated();
-    }
-    return false;
-}
-
 bool CompositingReasonFinder::requiresCompositingForPlugin(RenderObject* renderer, bool* needToRecomputeCompositingRequirements) const
 {
-    if (!(m_compositingTriggers & ChromeClient::PluginTrigger))
+    if (!(m_compositingTriggers & PluginTrigger))
         return false;
 
     if (!renderer->isEmbeddedObject() || !toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing())
         return false;
 
     // FIXME: this seems bogus. If we don't know the layout position/size of the plugin yet, would't that be handled elsewhere?
     *needToRecomputeCompositingRequirements = true;
 
     RenderWidget* pluginRenderer = toRenderWidget(renderer);
     // If we can't reliably know the size of the plugin yet, don't change compositing state.
@@ skipping 29 matching lines @@
     if (renderer->needsLayout())
         return frameRenderer->hasLayer() && frameRenderer->layer()->hasCompositedLayerMapping();
 
     // Don't go into compositing mode if height or width are zero.
     IntRect contentBox = pixelSnappedIntRect(frameRenderer->contentBoxRect());
     return contentBox.height() * contentBox.width() > 0;
 }
 
 bool CompositingReasonFinder::requiresCompositingForBackfaceVisibilityHidden(RenderObject* renderer) const
 {
-    if (!(m_compositingTriggers & ChromeClient::ThreeDTransformTrigger))
+    if (!(m_compositingTriggers & ThreeDTransformTrigger))
         return false;
 
     return renderer->style()->backfaceVisibility() == BackfaceVisibilityHidden;
 }
 
 bool CompositingReasonFinder::requiresCompositingForAnimation(RenderObject* renderer) const
 {
-    if (!(m_compositingTriggers & ChromeClient::AnimationTrigger))
+    if (!(m_compositingTriggers & AnimationTrigger))
         return false;
 
     return shouldCompositeForActiveAnimations(*renderer);
 }
 
 bool CompositingReasonFinder::requiresCompositingForTransition(RenderObject* renderer) const
 {
-    if (!(m_compositingTriggers & ChromeClient::AnimationTrigger))
+    if (!(m_compositingTriggers & AnimationTrigger))
         return false;
 
     if (Settings* settings = m_renderView.document().settings()) {
         if (!settings->acceleratedCompositingForTransitionEnabled())
             return false;
     }
 
     return renderer->style()->transitionForProperty(CSSPropertyOpacity)
         || renderer->style()->transitionForProperty(CSSPropertyWebkitFilter)
         || renderer->style()->transitionForProperty(CSSPropertyWebkitTransform);
 }
 
 bool CompositingReasonFinder::requiresCompositingForFilters(RenderObject* renderer) const
 {
-    if (!(m_compositingTriggers & ChromeClient::FilterTrigger))
+    if (!(m_compositingTriggers & FilterTrigger))
         return false;
 
     return renderer->hasFilter();
 }
 
 bool CompositingReasonFinder::requiresCompositingForOverflowScrollingParent(const RenderLayer* layer) const
 {
     return !!layer->scrollParent();
 }
 
@@ skipping 133 matching lines @@
 
     return true;
 }
 
 bool CompositingReasonFinder::requiresCompositingForOverflowScrolling(const RenderLayer* layer) const
 {
     return layer->needsCompositedScrolling();
 }
 
 }