Move rendering/RenderLayer* to layout/

Source/core/layout/Layer.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 24 matching lines @@
  * applicable instead of those above.  If you wish to allow use of your
  * version of this file only under the terms of one of those two
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
  * deletingthe provisions above and replace them with the notice and
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
-#ifndef RenderLayer_h
-#define RenderLayer_h
+#ifndef Layer_h
+#define Layer_h
 
-#include "core/rendering/LayerFragment.h"
+#include "core/layout/LayerClipper.h"
+#include "core/layout/LayerFilterInfo.h"
+#include "core/layout/LayerFragment.h"
+#include "core/layout/LayerReflectionInfo.h"
+#include "core/layout/LayerScrollableArea.h"
+#include "core/layout/LayerStackingNode.h"
+#include "core/layout/LayerStackingNodeIterator.h"
 #include "core/rendering/RenderBox.h"
-#include "core/rendering/RenderLayerClipper.h"
-#include "core/rendering/RenderLayerFilterInfo.h"
-#include "core/rendering/RenderLayerReflectionInfo.h"
-#include "core/rendering/RenderLayerScrollableArea.h"
-#include "core/rendering/RenderLayerStackingNode.h"
-#include "core/rendering/RenderLayerStackingNodeIterator.h"
 #include "platform/graphics/CompositingReasons.h"
 #include "public/platform/WebBlendMode.h"
 #include "wtf/OwnPtr.h"
 
 namespace blink {
 
 class FilterEffectRenderer;
 class FilterOperations;
 class HitTestRequest;
 class HitTestResult;
 class HitTestingTransformState;
+class LayerCompositor;
 class CompositedLayerMapping;
-class RenderLayerCompositor;
 class RenderStyle;
 class TransformationMatrix;
 
 enum IncludeSelfOrNot { IncludeSelf, ExcludeSelf };
 
 enum CompositingQueryMode {
     CompositingQueriesAreAllowed,
     CompositingQueriesAreOnlyAllowedInCertainDocumentLifecyclePhases
 };
 
 // FIXME: remove this once the compositing query ASSERTS are no longer hit.
 class DisableCompositingQueryAsserts {
     WTF_MAKE_NONCOPYABLE(DisableCompositingQueryAsserts);
 public:
     DisableCompositingQueryAsserts();
 private:
     TemporaryChange<CompositingQueryMode> m_disabler;
 };
 
-class RenderLayer {
-    WTF_MAKE_NONCOPYABLE(RenderLayer);
+class Layer {
+    WTF_MAKE_NONCOPYABLE(Layer);
 public:
-    RenderLayer(RenderLayerModelObject*, LayerType);
-    ~RenderLayer();
+    Layer(LayoutLayerModelObject*, LayerType);
+    ~Layer();
 
     String debugName() const;
 
-    RenderLayerModelObject* renderer() const { return m_renderer; }
+    LayoutLayerModelObject* renderer() const { return m_renderer; }
     RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; }
-    RenderLayer* parent() const { return m_parent; }
-    RenderLayer* previousSibling() const { return m_previous; }
-    RenderLayer* nextSibling() const { return m_next; }
-    RenderLayer* firstChild() const { return m_first; }
-    RenderLayer* lastChild() const { return m_last; }
+    Layer* parent() const { return m_parent; }
+    Layer* previousSibling() const { return m_previous; }
+    Layer* nextSibling() const { return m_next; }
+    Layer* firstChild() const { return m_first; }
+    Layer* lastChild() const { return m_last; }
 
-    const RenderLayer* compositingContainer() const;
+    const Layer* compositingContainer() const;
 
-    void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0);
-    RenderLayer* removeChild(RenderLayer*);
+    void addChild(Layer* newChild, Layer* beforeChild = 0);
+    Layer* removeChild(Layer*);
 
     void removeOnlyThisLayer();
     void insertOnlyThisLayer();
 
     void styleChanged(StyleDifference, const RenderStyle* oldStyle);
 
     // FIXME: Many people call this function while it has out-of-date information.
     bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
 
     void setLayerType(LayerType layerType) { m_layerType = layerType; }
 
     bool isTransparent() const { return renderer()->isTransparent() || renderer()->style()->hasBlendMode() || renderer()->hasMask(); }
 
     bool isReflection() const { return renderer()->isReplica(); }
-    RenderLayerReflectionInfo* reflectionInfo() { return m_reflectionInfo.get(); }
-    const RenderLayerReflectionInfo* reflectionInfo() const { return m_reflectionInfo.get(); }
+    LayerReflectionInfo* reflectionInfo() { return m_reflectionInfo.get(); }
+    const LayerReflectionInfo* reflectionInfo() const { return m_reflectionInfo.get(); }
 
-    const RenderLayer* root() const
+    const Layer* root() const
     {
-        const RenderLayer* curr = this;
+        const Layer* curr = this;
         while (curr->parent())
             curr = curr->parent();
         return curr;
     }
 
     const LayoutPoint& location() const { ASSERT(!m_needsPositionUpdate); return m_location; }
     // FIXME: size() should ASSERT(!m_needsPositionUpdate) as well, but that fails in some tests,
     // for example, fast/repaint/clipped-relative.html.
     const IntSize& size() const { return m_size; }
     void setSizeHackForLayoutTreeAsText(const IntSize& size) { m_size = size; }
 
     LayoutRect rect() const { return LayoutRect(location(), LayoutSize(size())); }
 
     bool isRootLayer() const { return m_isRootLayer; }
 
-    RenderLayerCompositor* compositor() const;
+    LayerCompositor* compositor() const;
 
     // Notification from the renderer that its content changed (e.g. current frame of image changed).
     // Allows updates of layer content without invalidating paint.
     void contentChanged(ContentChangeType);
 
     void updateLayerPositionsAfterLayout();
     void updateLayerPositionsAfterOverflowScroll();
 
     bool isPaginated() const { return m_isPaginated; }
-    RenderLayer* enclosingPaginationLayer() const { return m_enclosingPaginationLayer; }
+    Layer* enclosingPaginationLayer() const { return m_enclosingPaginationLayer; }
 
     void updateTransformationMatrix();
-    RenderLayer* renderingContextRoot();
+    Layer* renderingContextRoot();
 
     const LayoutSize& offsetForInFlowPosition() const { return m_offsetForInFlowPosition; }
 
     void blockSelectionGapsBoundsChanged();
     void addBlockSelectionGapsBounds(const LayoutRect&);
     void clearBlockSelectionGapsBounds();
     void invalidatePaintForBlockSelectionGaps();
     IntRect blockSelectionGapsBounds() const;
     bool hasBlockSelectionGapBounds() const;
 
-    RenderLayerStackingNode* stackingNode() { return m_stackingNode.get(); }
-    const RenderLayerStackingNode* stackingNode() const { return m_stackingNode.get(); }
+    LayerStackingNode* stackingNode() { return m_stackingNode.get(); }
+    const LayerStackingNode* stackingNode() const { return m_stackingNode.get(); }
 
     bool subtreeIsInvisible() const { return !hasVisibleContent() && !hasVisibleDescendant(); }
 
     // FIXME: hasVisibleContent() should call updateDescendantDependentFlags() if m_visibleContentStatusDirty.
     bool hasVisibleContent() const { ASSERT(!m_visibleContentStatusDirty); return m_hasVisibleContent; }
 
     // FIXME: hasVisibleDescendant() should call updateDescendantDependentFlags() if m_visibleDescendantStatusDirty.
     bool hasVisibleDescendant() const { ASSERT(!m_visibleDescendantStatusDirty); return m_hasVisibleDescendant; }
 
     void dirtyVisibleContentStatus();
     void potentiallyDirtyVisibleContentStatus(EVisibility);
 
     bool hasBoxDecorationsOrBackground() const;
     bool hasVisibleBoxDecorations() const;
     // True if this layer container renderers that paint.
     bool hasNonEmptyChildRenderers() const;
 
     // Will ensure that hasNonCompositiedChild are up to date.
     void updateScrollingStateAfterCompositingChange();
     bool hasVisibleNonLayerContent() const { return m_hasVisibleNonLayerContent; }
     bool hasNonCompositedChild() const { ASSERT(isAllowedToQueryCompositingState()); return m_hasNonCompositedChild; }
 
     // Gets the nearest enclosing positioned ancestor layer (also includes
     // the <html> layer and the root layer).
-    RenderLayer* enclosingPositionedAncestor() const;
+    Layer* enclosingPositionedAncestor() const;
 
     bool isPaintInvalidationContainer() const;
 
     // Do *not* call this method unless you know what you are dooing. You probably want to call enclosingCompositingLayerForPaintInvalidation() instead.
     // If includeSelf is true, may return this.
-    RenderLayer* enclosingLayerWithCompositedLayerMapping(IncludeSelfOrNot) const;
+    Layer* enclosingLayerWithCompositedLayerMapping(IncludeSelfOrNot) const;
 
     // Returns the enclosing layer root into which this layer paints, inclusive of this one. Note that the enclosing layer may or may not have its own
-    // GraphicsLayer backing, but is nevertheless the root for a call to the RenderLayer::paint*() methods.
-    RenderLayer* enclosingLayerForPaintInvalidation() const;
+    // GraphicsLayer backing, but is nevertheless the root for a call to the Layer::paint*() methods.
+    Layer* enclosingLayerForPaintInvalidation() const;
 
-    RenderLayer* enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const;
+    Layer* enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const;
 
     bool hasAncestorWithFilterOutsets() const;
 
     bool canUseConvertToLayerCoords() const
     {
         // These RenderObjects have an impact on their layers without the renderers knowing about it.
         return !renderer()->hasColumns() && !renderer()->hasTransformRelatedProperty() && !renderer()->isSVGRoot();
     }
 
-    void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutPoint&) const;
-    void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect&) const;
+    void convertToLayerCoords(const Layer* ancestorLayer, LayoutPoint&) const;
+    void convertToLayerCoords(const Layer* ancestorLayer, LayoutRect&) const;
 
     // Does the same as convertToLayerCoords() when not in multicol. For multicol, however,
     // convertToLayerCoords() calculates the offset in flow-thread coordinates (what the layout
     // engine uses internally), while this method calculates the visual coordinates; i.e. it figures
     // out which column the layer starts in and adds in the offset. See
     // http://www.chromium.org/developers/design-documents/multi-column-layout for more info.
-    LayoutPoint visualOffsetFromAncestor(const RenderLayer* ancestorLayer) const;
+    LayoutPoint visualOffsetFromAncestor(const Layer* ancestorLayer) const;
 
     // The hitTest() method looks for mouse events by walking layers that intersect the point from front to back.
     bool hitTest(const HitTestRequest&, HitTestResult&);
     bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
 
     // Pass offsetFromRoot if known.
-    bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutPoint* offsetFromRoot = 0) const;
+    bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const Layer* rootLayer, const LayoutPoint* offsetFromRoot = 0) const;
 
     // Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
-    LayoutRect physicalBoundingBox(const RenderLayer* ancestorLayer, const LayoutPoint* offsetFromRoot = 0) const;
-    LayoutRect physicalBoundingBoxIncludingReflectionAndStackingChildren(const RenderLayer* ancestorLayer, const LayoutPoint& offsetFromRoot) const;
-    LayoutRect fragmentsBoundingBox(const RenderLayer* ancestorLayer) const;
+    LayoutRect physicalBoundingBox(const Layer* ancestorLayer, const LayoutPoint* offsetFromRoot = 0) const;
+    LayoutRect physicalBoundingBoxIncludingReflectionAndStackingChildren(const Layer* ancestorLayer, const LayoutPoint& offsetFromRoot) const;
+    LayoutRect fragmentsBoundingBox(const Layer* ancestorLayer) const;
 
     LayoutRect boundingBoxForCompositingOverlapTest() const;
 
     // If true, this layer's children are included in its bounds for overlap testing.
     // We can't rely on the children's positions if this layer has a filter that could have moved the children's pixels around.
     bool overlapBoundsIncludeChildren() const { return hasFilter() && renderer()->style()->filter().hasFilterThatMovesPixels(); }
 
     enum CalculateBoundsOptions {
         ApplyBoundsChickenEggHacks,
         DoNotApplyBoundsChickenEggHacks,
     };
-    LayoutRect boundingBoxForCompositing(const RenderLayer* ancestorLayer = 0, CalculateBoundsOptions = DoNotApplyBoundsChickenEggHacks) const;
+    LayoutRect boundingBoxForCompositing(const Layer* ancestorLayer = 0, CalculateBoundsOptions = DoNotApplyBoundsChickenEggHacks) const;
 
     LayoutUnit staticInlinePosition() const { return m_staticInlinePosition; }
     LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
 
     void setStaticInlinePosition(LayoutUnit position) { m_staticInlinePosition = position; }
     void setStaticBlockPosition(LayoutUnit position) { m_staticBlockPosition = position; }
 
     LayoutSize subpixelAccumulation() const;
     void setSubpixelAccumulation(const LayoutSize&);
 
@@ skipping 17 matching lines @@
     bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
     bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
 
     // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
     bool shouldPreserve3D() const { return !renderer()->hasReflection() && renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
 
     void filterNeedsPaintInvalidation();
     bool hasFilter() const { return renderer()->hasFilter(); }
 
     void* operator new(size_t);
-    // Only safe to call from RenderLayerModelObject::destroyLayer()
+    // Only safe to call from LayoutLayerModelObject::destroyLayer()
     void operator delete(void*);
 
     CompositingState compositingState() const;
 
     // This returns true if our document is in a phase of its lifestyle during which
     // compositing state may legally be read.
     bool isAllowedToQueryCompositingState() const;
 
     // Don't null check this.
     CompositedLayerMapping* compositedLayerMapping() const;
     GraphicsLayer* graphicsLayerBacking() const;
     GraphicsLayer* graphicsLayerBackingForScrolling() const;
     // NOTE: If you are using hasCompositedLayerMapping to determine the state of compositing for this layer,
     // (and not just to do bookkeeping related to the mapping like, say, allocating or deallocating a mapping),
     // then you may have incorrect logic. Use compositingState() instead.
     // FIXME: This is identical to null checking compositedLayerMapping(), why not just call that?
     bool hasCompositedLayerMapping() const { return m_compositedLayerMapping.get(); }
     void ensureCompositedLayerMapping();
     void clearCompositedLayerMapping(bool layerBeingDestroyed = false);
     CompositedLayerMapping* groupedMapping() const { return m_groupedMapping; }
     void setGroupedMapping(CompositedLayerMapping* groupedMapping, bool layerBeingDestroyed = false);
 
     bool hasCompositedMask() const;
     bool hasCompositedClippingMask() const;
     bool needsCompositedScrolling() const { return m_scrollableArea && m_scrollableArea->needsCompositedScrolling(); }
 
     // Computes the position of the given render object in the space of |paintInvalidationContainer|.
     // FIXME: invert the logic to have paint invalidation containers take care of painting objects into them, rather than the reverse.
     // This will allow us to clean up this static method messiness.
-    static LayoutPoint positionFromPaintInvalidationBacking(const RenderObject*, const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* = 0);
+    static LayoutPoint positionFromPaintInvalidationBacking(const RenderObject*, const LayoutLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* = 0);
 
-    static void mapPointToPaintBackingCoordinates(const RenderLayerModelObject* paintInvalidationContainer, FloatPoint&);
-    static void mapRectToPaintBackingCoordinates(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect&);
+    static void mapPointToPaintBackingCoordinates(const LayoutLayerModelObject* paintInvalidationContainer, FloatPoint&);
+    static void mapRectToPaintBackingCoordinates(const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect&);
 
     // Adjusts the given rect (in the coordinate space of the RenderObject) to the coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
-    static void mapRectToPaintInvalidationBacking(const RenderObject*, const RenderLayerModelObject* paintInvalidationContainer, LayoutRect&, const PaintInvalidationState* = 0);
+    static void mapRectToPaintInvalidationBacking(const RenderObject*, const LayoutLayerModelObject* paintInvalidationContainer, LayoutRect&, const PaintInvalidationState* = 0);
 
     // Computes the bounding paint invalidation rect for |renderObject|, in the coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
-    static LayoutRect computePaintInvalidationRect(const RenderObject*, const RenderLayer* paintInvalidationContainer, const PaintInvalidationState* = 0);
+    static LayoutRect computePaintInvalidationRect(const RenderObject*, const Layer* paintInvalidationContainer, const PaintInvalidationState* = 0);
 
     bool paintsWithTransparency(PaintBehavior paintBehavior) const
     {
         return isTransparent() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || compositingState() != PaintsIntoOwnBacking);
     }
 
     bool paintsWithTransform(PaintBehavior) const;
 
     // Returns true if background phase is painted opaque in the given rect.
     // The query rect is given in local coordinates.
     bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const;
 
     bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; }
     void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; }
 
     FilterOperations computeFilterOperations(const RenderStyle*);
     bool paintsWithFilters() const;
     FilterEffectRenderer* filterRenderer() const
     {
-        RenderLayerFilterInfo* filterInfo = this->filterInfo();
+        LayerFilterInfo* filterInfo = this->filterInfo();
         return filterInfo ? filterInfo->renderer() : 0;
     }
 
-    RenderLayerFilterInfo* filterInfo() const { return hasFilterInfo() ? RenderLayerFilterInfo::filterInfoForRenderLayer(this) : 0; }
-    RenderLayerFilterInfo* ensureFilterInfo() { return RenderLayerFilterInfo::createFilterInfoForRenderLayerIfNeeded(this); }
+    LayerFilterInfo* filterInfo() const { return hasFilterInfo() ? LayerFilterInfo::filterInfoForLayer(this) : 0; }
+    LayerFilterInfo* ensureFilterInfo() { return LayerFilterInfo::createFilterInfoForLayerIfNeeded(this); }
     void removeFilterInfoIfNeeded()
     {
         if (hasFilterInfo())
-            RenderLayerFilterInfo::removeFilterInfoForRenderLayer(this);
+            LayerFilterInfo::removeFilterInfoForLayer(this);
     }
 
     bool hasFilterInfo() const { return m_hasFilterInfo; }
     void setHasFilterInfo(bool hasFilterInfo) { m_hasFilterInfo = hasFilterInfo; }
 
     void updateFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle);
 
     Node* enclosingElement() const;
 
     bool isInTopLayer() const;
 
     bool scrollsWithViewport() const;
-    bool scrollsWithRespectTo(const RenderLayer*) const;
+    bool scrollsWithRespectTo(const Layer*) const;
 
     void addLayerHitTestRects(LayerHitTestRects&) const;
 
     // Compute rects only for this layer
     void computeSelfHitTestRects(LayerHitTestRects&) const;
 
     // FIXME: This should probably return a ScrollableArea but a lot of internal methods are mistakenly exposed.
-    RenderLayerScrollableArea* scrollableArea() const { return m_scrollableArea.get(); }
-    RenderLayerClipper& clipper() { return m_clipper; }
-    const RenderLayerClipper& clipper() const { return m_clipper; }
+    LayerScrollableArea* scrollableArea() const { return m_scrollableArea.get(); }
+    LayerClipper& clipper() { return m_clipper; }
+    const LayerClipper& clipper() const { return m_clipper; }
 
     inline bool isPositionedContainer() const
     {
         // FIXME: This is not in sync with containingBlock.
         // RenderObject::canContainFixedPositionedObject() should probably be used
         // instead.
-        RenderLayerModelObject* layerRenderer = renderer();
+        LayoutLayerModelObject* layerRenderer = renderer();
         return isRootLayer() || layerRenderer->isPositioned() || hasTransformRelatedProperty();
     }
 
     bool scrollsOverflow() const;
 
     CompositingReasons potentialCompositingReasonsFromStyle() const { return m_potentialCompositingReasonsFromStyle; }
     void setPotentialCompositingReasonsFromStyle(CompositingReasons reasons) { ASSERT(reasons == (reasons & CompositingReasonComboAllStyleDeterminedReasons)); m_potentialCompositingReasonsFromStyle = reasons; }
 
     bool hasStyleDeterminedDirectCompositingReasons() const { return m_potentialCompositingReasonsFromStyle & CompositingReasonComboAllDirectStyleDeterminedReasons; }
 
     class AncestorDependentCompositingInputs {
     public:
         AncestorDependentCompositingInputs()
             : opacityAncestor(0)
             , transformAncestor(0)
             , filterAncestor(0)
             , clippingContainer(0)
             , ancestorScrollingLayer(0)
             , scrollParent(0)
             , clipParent(0)
             , hasAncestorWithClipPath(false)
         { }
 
         IntRect clippedAbsoluteBoundingBox;
-        const RenderLayer* opacityAncestor;
-        const RenderLayer* transformAncestor;
-        const RenderLayer* filterAncestor;
+        const Layer* opacityAncestor;
+        const Layer* transformAncestor;
+        const Layer* filterAncestor;
         const RenderObject* clippingContainer;
-        const RenderLayer* ancestorScrollingLayer;
+        const Layer* ancestorScrollingLayer;
 
         // A scroll parent is a compositor concept. It's only needed in blink
         // because we need to use it as a promotion trigger. A layer has a
         // scroll parent if neither its compositor scrolling ancestor, nor any
         // other layer scrolled by this ancestor, is a stacking ancestor of this
         // layer. Layers with scroll parents must be scrolled with the main
         // scrolling layer by the compositor.
-        const RenderLayer* scrollParent;
+        const Layer* scrollParent;
 
         // A clip parent is another compositor concept that has leaked into
         // blink so that it may be used as a promotion trigger. Layers with clip
         // parents escape the clip of a stacking tree ancestor. The compositor
         // needs to know about clip parents in order to circumvent its normal
         // clipping logic.
-        const RenderLayer* clipParent;
+        const Layer* clipParent;
 
         unsigned hasAncestorWithClipPath : 1;
     };
 
     class DescendantDependentCompositingInputs {
     public:
         DescendantDependentCompositingInputs()
             : hasDescendantWithClipPath(false)
             , hasNonIsolatedDescendantWithBlendMode(false)
         { }
@@ skipping 13 matching lines @@
     }
 
     void updateAncestorDependentCompositingInputs(const AncestorDependentCompositingInputs&);
     void updateDescendantDependentCompositingInputs(const DescendantDependentCompositingInputs&);
     void didUpdateCompositingInputs();
 
     const AncestorDependentCompositingInputs& ancestorDependentCompositingInputs() const { ASSERT(!m_needsAncestorDependentCompositingInputsUpdate); return m_ancestorDependentCompositingInputs; }
     const DescendantDependentCompositingInputs& descendantDependentCompositingInputs() const { ASSERT(!m_needsDescendantDependentCompositingInputsUpdate); return m_descendantDependentCompositingInputs; }
 
     IntRect clippedAbsoluteBoundingBox() const { return ancestorDependentCompositingInputs().clippedAbsoluteBoundingBox; }
-    const RenderLayer* opacityAncestor() const { return ancestorDependentCompositingInputs().opacityAncestor; }
-    const RenderLayer* transformAncestor() const { return ancestorDependentCompositingInputs().transformAncestor; }
-    const RenderLayer* filterAncestor() const { return ancestorDependentCompositingInputs().filterAncestor; }
+    const Layer* opacityAncestor() const { return ancestorDependentCompositingInputs().opacityAncestor; }
+    const Layer* transformAncestor() const { return ancestorDependentCompositingInputs().transformAncestor; }
+    const Layer* filterAncestor() const { return ancestorDependentCompositingInputs().filterAncestor; }
     const RenderObject* clippingContainer() const { return ancestorDependentCompositingInputs().clippingContainer; }
-    const RenderLayer* ancestorScrollingLayer() const { return ancestorDependentCompositingInputs().ancestorScrollingLayer; }
-    RenderLayer* scrollParent() const { return const_cast<RenderLayer*>(ancestorDependentCompositingInputs().scrollParent); }
-    RenderLayer* clipParent() const { return const_cast<RenderLayer*>(ancestorDependentCompositingInputs().clipParent); }
+    const Layer* ancestorScrollingLayer() const { return ancestorDependentCompositingInputs().ancestorScrollingLayer; }
+    Layer* scrollParent() const { return const_cast<Layer*>(ancestorDependentCompositingInputs().scrollParent); }
+    Layer* clipParent() const { return const_cast<Layer*>(ancestorDependentCompositingInputs().clipParent); }
     bool hasAncestorWithClipPath() const { return ancestorDependentCompositingInputs().hasAncestorWithClipPath; }
     bool hasDescendantWithClipPath() const { return descendantDependentCompositingInputs().hasDescendantWithClipPath; }
     bool hasNonIsolatedDescendantWithBlendMode() const;
 
     bool lostGroupedMapping() const { ASSERT(isAllowedToQueryCompositingState()); return m_lostGroupedMapping; }
     void setLostGroupedMapping(bool b) { m_lostGroupedMapping = b; }
 
     CompositingReasons compositingReasons() const { ASSERT(isAllowedToQueryCompositingState()); return m_compositingReasons; }
     void setCompositingReasons(CompositingReasons, CompositingReasons mask = CompositingReasonAll);
 
     bool hasCompositingDescendant() const { ASSERT(isAllowedToQueryCompositingState()); return m_hasCompositingDescendant; }
     void setHasCompositingDescendant(bool);
 
     bool shouldIsolateCompositedDescendants() const { ASSERT(isAllowedToQueryCompositingState()); return m_shouldIsolateCompositedDescendants; }
     void setShouldIsolateCompositedDescendants(bool);
 
     void updateDescendantDependentFlags();
     void updateDescendantDependentFlagsForEntireSubtree();
 
     void updateOrRemoveFilterEffectRenderer();
 
     void updateSelfPaintingLayer();
 
-    RenderLayer* enclosingTransformedAncestor() const;
+    Layer* enclosingTransformedAncestor() const;
     LayoutPoint computeOffsetFromTransformedAncestor() const;
 
     void didUpdateNeedsCompositedScrolling();
 
     void setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
     bool hasSelfPaintingLayerDescendant() const
     {
         if (m_hasSelfPaintingLayerDescendantDirty)
             updateHasSelfPaintingLayerDescendant();
         ASSERT(!m_hasSelfPaintingLayerDescendantDirty);
         return m_hasSelfPaintingLayerDescendant;
     }
-    LayoutRect paintingExtent(const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior);
-    void collectFragments(LayerFragments&, const RenderLayer* rootLayer, const LayoutRect& dirtyRect,
+    LayoutRect paintingExtent(const Layer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior);
+    void collectFragments(LayerFragments&, const Layer* rootLayer, const LayoutRect& dirtyRect,
         ClipRectsCacheSlot, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize,
         ShouldRespectOverflowClip = RespectOverflowClip, const LayoutPoint* offsetFromRoot = 0,
         const LayoutSize& subPixelAccumulation = LayoutSize(), const LayoutRect* layerBoundingBox = 0);
 
     LayoutPoint renderBoxLocation() const { return renderer()->isBox() ? toRenderBox(renderer())->location() : LayoutPoint(); }
 
     enum TransparencyClipBoxBehavior {
         PaintingTransparencyClipBox,
         HitTestingTransparencyClipBox
     };
 
     enum TransparencyClipBoxMode {
         DescendantsOfTransparencyClipBox,
         RootOfTransparencyClipBox
     };
 
-    static LayoutRect transparencyClipBox(const RenderLayer*, const RenderLayer* rootLayer, TransparencyClipBoxBehavior transparencyBehavior,
+    static LayoutRect transparencyClipBox(const Layer*, const Layer* rootLayer, TransparencyClipBoxBehavior transparencyBehavior,
         TransparencyClipBoxMode transparencyMode, const LayoutSize& subPixelAccumulation, PaintBehavior = 0);
 
 private:
     // Bounding box in the coordinates of this layer.
     LayoutRect logicalBoundingBox() const;
 
     bool hasOverflowControls() const;
 
     void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
     // Returns true if the position changed.
     bool updateLayerPosition();
 
     void updateLayerPositionRecursive();
     void updateLayerPositionsAfterScrollRecursive();
 
-    void setNextSibling(RenderLayer* next) { m_next = next; }
-    void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
-    void setFirstChild(RenderLayer* first) { m_first = first; }
-    void setLastChild(RenderLayer* last) { m_last = last; }
+    void setNextSibling(Layer* next) { m_next = next; }
+    void setPreviousSibling(Layer* prev) { m_previous = prev; }
+    void setFirstChild(Layer* first) { m_first = first; }
+    void setLastChild(Layer* last) { m_last = last; }
 
     void updateHasSelfPaintingLayerDescendant() const;
-    RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
-                              const LayoutRect& hitTestRect, const HitTestLocation&, bool appliedTransform,
-                              const HitTestingTransformState* transformState = 0, double* zOffset = 0);
-    RenderLayer* hitTestLayerByApplyingTransform(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
+    Layer* hitTestLayer(Layer* rootLayer, Layer* containerLayer, const HitTestRequest&, HitTestResult&,
+        const LayoutRect& hitTestRect, const HitTestLocation&, bool appliedTransform,
+        const HitTestingTransformState* = 0, double* zOffset = 0);
+    Layer* hitTestLayerByApplyingTransform(Layer* rootLayer, Layer* containerLayer, const HitTestRequest&, HitTestResult&,
         const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = 0, double* zOffset = 0,
         const LayoutPoint& translationOffset = LayoutPoint());
-    RenderLayer* hitTestChildren(ChildrenIteration, RenderLayer* rootLayer, const HitTestRequest&, HitTestResult&,
-                             const LayoutRect& hitTestRect, const HitTestLocation&,
-                             const HitTestingTransformState* transformState, double* zOffsetForDescendants, double* zOffset,
-                             const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
-    RenderLayer* hitTestPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
-                                            const LayoutRect& hitTestRect, const HitTestLocation&,
-                                            const HitTestingTransformState* transformState, double* zOffset);
-    RenderLayer* hitTestChildLayerColumns(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
-                                          const LayoutRect& hitTestRect, const HitTestLocation&,
-                                          const HitTestingTransformState* transformState, double* zOffset,
-                                          const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
+    Layer* hitTestChildren(ChildrenIteration, Layer* rootLayer, const HitTestRequest&, HitTestResult&,
+        const LayoutRect& hitTestRect, const HitTestLocation&,
+        const HitTestingTransformState*, double* zOffsetForDescendants, double* zOffset,
+        const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
+    Layer* hitTestPaginatedChildLayer(Layer* childLayer, Layer* rootLayer, const HitTestRequest&, HitTestResult&,
+        const LayoutRect& hitTestRect, const HitTestLocation&,
+        const HitTestingTransformState*, double* zOffset);
+    Layer* hitTestChildLayerColumns(Layer* childLayer, Layer* rootLayer, const HitTestRequest&, HitTestResult&,
+        const LayoutRect& hitTestRect, const HitTestLocation&,
+        const HitTestingTransformState*, double* zOffset,
+        const Vector<Layer*>& columnLayers, size_t columnIndex);
 
-    PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
-                            const LayoutRect& hitTestRect, const HitTestLocation&,
-                            const HitTestingTransformState* containerTransformState,
-                            const LayoutPoint& translationOffset = LayoutPoint()) const;
+    PassRefPtr<HitTestingTransformState> createLocalTransformState(Layer* rootLayer, Layer* containerLayer,
+        const LayoutRect& hitTestRect, const HitTestLocation&,
+        const HitTestingTransformState* containerTransformState,
+        const LayoutPoint& translationOffset = LayoutPoint()) const;
 
     bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutRect& layerBounds, const HitTestLocation&, HitTestFilter) const;
     bool hitTestContentsForFragments(const LayerFragments&, const HitTestRequest&, HitTestResult&, const HitTestLocation&, HitTestFilter, bool& insideClipRect) const;
-    RenderLayer* hitTestTransformedLayerInFragments(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
+    Layer* hitTestTransformedLayerInFragments(Layer* rootLayer, Layer* containerLayer, const HitTestRequest&, HitTestResult&,
         const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = 0, double* zOffset = 0);
 
     bool childBackgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const;
 
     bool shouldBeSelfPaintingLayer() const;
 
     // FIXME: We should only create the stacking node if needed.
     bool requiresStackingNode() const { return true; }
     void updateStackingNode();
 
@@ skipping 17 matching lines @@
 
     void updatePaginationRecursive(bool needsPaginationUpdate = false);
     void updatePagination();
     void clearPaginationRecursive();
 
     // FIXME: Temporary. Remove when new columns come online.
     bool useRegionBasedColumns() const;
 
     LayerType m_layerType;
 
-    // Self-painting layer is an optimization where we avoid the heavy RenderLayer painting
-    // machinery for a RenderLayer allocated only to handle the overflow clip case.
+    // Self-painting layer is an optimization where we avoid the heavy Layer painting
+    // machinery for a Layer allocated only to handle the overflow clip case.
     // FIXME(crbug.com/332791): Self-painting layer should be merged into the overflow-only concept.
     unsigned m_isSelfPaintingLayer : 1;
 
     // If have no self-painting descendants, we don't have to walk our children during painting. This can lead to
     // significant savings, especially if the tree has lots of non-self-painting layers grouped together (e.g. table cells).
     mutable unsigned m_hasSelfPaintingLayerDescendant : 1;
     mutable unsigned m_hasSelfPaintingLayerDescendantDirty : 1;
 
     const unsigned m_isRootLayer : 1;
 
@@ skipping 26 matching lines @@
     unsigned m_hasCompositingDescendant : 1;
 
     // Applies to the real render layer tree (i.e., the tree determined by the layer's parent and children and
     // as opposed to the tree formed by the z-order and normal flow lists).
     unsigned m_hasNonCompositedChild : 1;
 
     // Should be for stacking contexts having unisolated blending descendants.
     unsigned m_shouldIsolateCompositedDescendants : 1;
 
     // True if this render layer just lost its grouped mapping due to the CompositedLayerMapping being destroyed,
-    // and we don't yet know to what graphics layer this RenderLayer will be assigned.
+    // and we don't yet know to what graphics layer this Layer will be assigned.
     unsigned m_lostGroupedMapping : 1;
 
-    RenderLayerModelObject* m_renderer;
+    LayoutLayerModelObject* m_renderer;
 
-    RenderLayer* m_parent;
-    RenderLayer* m_previous;
-    RenderLayer* m_next;
-    RenderLayer* m_first;
-    RenderLayer* m_last;
+    Layer* m_parent;
+    Layer* m_previous;
+    Layer* m_next;
+    Layer* m_first;
+    Layer* m_last;
 
     // Our current relative position offset.
     LayoutSize m_offsetForInFlowPosition;
 
     // Our (x,y) coordinates are in our parent layer's coordinate space.
     LayoutPoint m_location;
 
     // The layer's width/height
     IntSize m_size;
 
     // Cached normal flow values for absolute positioned elements with static left/top values.
     LayoutUnit m_staticInlinePosition;
     LayoutUnit m_staticBlockPosition;
 
     OwnPtr<TransformationMatrix> m_transform;
 
-    // Pointer to the enclosing RenderLayer that caused us to be paginated. It is 0 if we are not paginated.
+    // Pointer to the enclosing Layer that caused us to be paginated. It is 0 if we are not paginated.
     //
     // See RenderMultiColumnFlowThread and
     // https://sites.google.com/a/chromium.org/dev/developers/design-documents/multi-column-layout
     // for more information about the multicol implementation. It's important to understand the
     // difference between flow thread coordinates and visual coordinates when working with multicol
-    // in RenderLayer, since RenderLayer is one of the few places where we have to worry about the
+    // in Layer, since Layer is one of the few places where we have to worry about the
     // visual ones. Internally we try to use flow-thread coordinates whenever possible.
-    RenderLayer* m_enclosingPaginationLayer;
+    Layer* m_enclosingPaginationLayer;
 
     // These compositing reasons are updated whenever style changes, not while updating compositing layers.
     // They should not be used to infer the compositing state of this layer.
     CompositingReasons m_potentialCompositingReasonsFromStyle;
 
     // Once computed, indicates all that a layer needs to become composited using the CompositingReasons enum bitfield.
     CompositingReasons m_compositingReasons;
 
     DescendantDependentCompositingInputs m_descendantDependentCompositingInputs;
     AncestorDependentCompositingInputs m_ancestorDependentCompositingInputs;
 
     IntRect m_blockSelectionGapsBounds;
 
     OwnPtr<CompositedLayerMapping> m_compositedLayerMapping;
-    OwnPtr<RenderLayerScrollableArea> m_scrollableArea;
+    OwnPtr<LayerScrollableArea> m_scrollableArea;
 
     CompositedLayerMapping* m_groupedMapping;
 
-    RenderLayerClipper m_clipper; // FIXME: Lazily allocate?
-    OwnPtr<RenderLayerStackingNode> m_stackingNode;
-    OwnPtr<RenderLayerReflectionInfo> m_reflectionInfo;
+    LayerClipper m_clipper; // FIXME: Lazily allocate?
+    OwnPtr<LayerStackingNode> m_stackingNode;
+    OwnPtr<LayerReflectionInfo> m_reflectionInfo;
 
     LayoutSize m_subpixelAccumulation; // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
-void showLayerTree(const blink::RenderLayer*);
+void showLayerTree(const blink::Layer*);
 void showLayerTree(const blink::RenderObject*);
 #endif
 
-#endif // RenderLayer_h
+#endif // Layer_h