Move rendering/RenderLayer* to layout/

Source/core/layout/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/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/compositing/RenderLayerCompositor.h"
+#include "core/layout/compositing/LayerCompositor.h"
 #include "core/page/Page.h"
 #include "core/rendering/RenderView.h"
 
 namespace blink {
 
 CompositingReasonFinder::CompositingReasonFinder(RenderView& renderView)
     : m_renderView(renderView)
     , m_compositingTriggers(static_cast<CompositingTriggerFlags>(AllCompositingTriggers))
 {
     updateTriggers();
@@ skipping 15 matching lines @@
 {
     return m_compositingTriggers & OverflowScrollTrigger;
 }
 
 bool CompositingReasonFinder::isMainFrame() const
 {
     // FIXME: LocalFrame::isMainFrame() is probably better.
     return !m_renderView.document().ownerElement();
 }
 
-CompositingReasons CompositingReasonFinder::directReasons(const RenderLayer* layer) const
+CompositingReasons CompositingReasonFinder::directReasons(const Layer* layer) const
 {
     if (RuntimeEnabledFeatures::slimmingPaintCompositorLayerizationEnabled())
         return CompositingReasonNone;
 
     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;
@@ skipping 53 matching lines @@
 
     // 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.
+    // See Layer::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 support them.
     return renderer->hasTransformRelatedProperty() && renderer->style()->transform().has3DOperation();
 }
 
-CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(const RenderLayer* layer) const
+CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(const Layer* layer) const
 {
     CompositingReasons directReasons = CompositingReasonNone;
     RenderObject* renderer = layer->renderer();
 
     if (hasOverflowScrollTrigger()) {
         if (layer->clipParent())
             directReasons |= CompositingReasonOutOfFlowClipping;
 
-        if (const RenderLayer* scrollingAncestor = layer->ancestorScrollingLayer()) {
+        if (const Layer* scrollingAncestor = layer->ancestorScrollingLayer()) {
             if (scrollingAncestor->needsCompositedScrolling() && layer->scrollParent())
                 directReasons |= CompositingReasonOverflowScrollingParent;
         }
 
         if (layer->needsCompositedScrolling())
             directReasons |= CompositingReasonOverflowScrollingTouch;
     }
 
     if (requiresCompositingForPositionFixed(layer))
         directReasons |= CompositingReasonPositionFixed;
 
     directReasons |= renderer->additionalCompositingReasons();
 
     ASSERT(!(directReasons & CompositingReasonComboAllStyleDeterminedReasons));
     return directReasons;
 }
 
 bool CompositingReasonFinder::requiresCompositingForAnimation(RenderStyle* style) const
 {
     if (style->subtreeWillChangeContents())
         return style->isRunningAnimationOnCompositor();
 
     return style->shouldCompositeForCurrentAnimations();
 }
 
-bool CompositingReasonFinder::requiresCompositingForPositionFixed(const RenderLayer* layer) const
+bool CompositingReasonFinder::requiresCompositingForPositionFixed(const Layer* 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
 {
@@ skipping 32 matching lines @@
             // Either way, we don't need to require compositing for scroll blocks on.  This avoids
             // enabling compositing by default, and avoids cluttering the root layers compositing reasons.
             return false;
         }
     }
 
     return true;
 }
 
 }