Move rendering/RenderLayer* to layout/

Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 19 matching lines @@
 #include "core/HTMLNames.h"
 #include "core/fetch/ImageResource.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorNodeIds.h"
-#include "core/layout/compositing/RenderLayerCompositor.h"
+#include "core/layout/LayerStackingNodeIterator.h"
+#include "core/layout/compositing/LayerCompositor.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/paint/LayerPainter.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "core/paint/TransformRecorder.h"
 #include "core/plugins/PluginView.h"
 #include "core/rendering/FilterEffectRenderer.h"
 #include "core/rendering/RenderEmbeddedObject.h"
 #include "core/rendering/RenderImage.h"
-#include "core/rendering/RenderLayerStackingNodeIterator.h"
 #include "core/rendering/RenderPart.h"
 #include "core/rendering/RenderVideo.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/style/KeyframeList.h"
 #include "platform/LengthFunctions.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/ClipDisplayItem.h"
@@ skipping 85 matching lines @@
 }
 
 static inline bool isAcceleratedContents(RenderObject* renderer)
 {
     return isAcceleratedCanvas(renderer)
         || (renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->requiresAcceleratedCompositing())
         || renderer->isVideo();
 }
 
 // Get the scrolling coordinator in a way that works inside CompositedLayerMapping's destructor.
-static ScrollingCoordinator* scrollingCoordinatorFromLayer(RenderLayer& layer)
+static ScrollingCoordinator* scrollingCoordinatorFromLayer(Layer& layer)
 {
     Page* page = layer.renderer()->frame()->page();
     if (!page)
         return 0;
 
     return page->scrollingCoordinator();
 }
 
-CompositedLayerMapping::CompositedLayerMapping(RenderLayer& layer)
+CompositedLayerMapping::CompositedLayerMapping(Layer& layer)
     : m_owningLayer(layer)
     , m_contentOffsetInCompositingLayerDirty(false)
     , m_pendingUpdateScope(GraphicsLayerUpdateNone)
     , m_isMainFrameRenderViewLayer(false)
     , m_backgroundLayerPaintsFixedRootBackground(false)
     , m_scrollingContentsAreEmpty(false)
 {
     if (layer.isRootLayer() && renderer()->frame()->isMainFrame())
         m_isMainFrameRenderViewLayer = true;
 
     createPrimaryGraphicsLayer();
 }
 
 CompositedLayerMapping::~CompositedLayerMapping()
 {
     // Hits in compositing/squashing/squash-onto-nephew.html.
     DisableCompositingQueryAsserts disabler;
 
-    // Do not leave the destroyed pointer dangling on any RenderLayers that painted to this mapping's squashing layer.
+    // Do not leave the destroyed pointer dangling on any Layers that painted to this mapping's squashing layer.
     for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
-        RenderLayer* oldSquashedLayer = m_squashedLayers[i].renderLayer;
+        Layer* oldSquashedLayer = m_squashedLayers[i].renderLayer;
         if (oldSquashedLayer->groupedMapping() == this) {
             oldSquashedLayer->setGroupedMapping(0, true);
             oldSquashedLayer->setLostGroupedMapping(true);
         }
     }
 
     updateClippingLayers(false, false);
     updateOverflowControlsLayers(false, false, false, false);
     updateChildTransformLayer(false);
     updateForegroundLayer(false);
@@ skipping 127 matching lines @@
         m_backgroundLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     } else {
         // For non-root layers, background is always painted by the primary graphics layer.
         m_graphicsLayer->setContentsOpaque(m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     }
 }
 
 void CompositedLayerMapping::updateCompositedBounds()
 {
     ASSERT(m_owningLayer.compositor()->lifecycle().state() == DocumentLifecycle::InCompositingUpdate);
-    // FIXME: if this is really needed for performance, it would be better to store it on RenderLayer.
+    // FIXME: if this is really needed for performance, it would be better to store it on Layer.
     m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
     m_contentOffsetInCompositingLayerDirty = true;
 }
 
 void CompositedLayerMapping::updateAfterPartResize()
 {
     if (renderer()->isRenderPart()) {
-        if (RenderLayerCompositor* innerCompositor = RenderLayerCompositor::frameContentsCompositor(toRenderPart(renderer()))) {
+        if (LayerCompositor* innerCompositor = LayerCompositor::frameContentsCompositor(toRenderPart(renderer()))) {
             innerCompositor->frameViewDidChangeSize();
             // We can floor this point because our frameviews are always aligned to pixel boundaries.
             ASSERT(m_compositedBounds.location() == flooredIntPoint(m_compositedBounds.location()));
             innerCompositor->frameViewDidChangeLocation(flooredIntPoint(contentsBox().location()));
         }
     }
 }
 
 void CompositedLayerMapping::updateCompositingReasons()
 {
     // All other layers owned by this mapping will have the same compositing reason
     // for their lifetime, so they are initialized only when created.
     m_graphicsLayer->setCompositingReasons(m_owningLayer.compositingReasons());
 }
 
 bool CompositedLayerMapping::owningLayerClippedByLayerNotAboveCompositedAncestor()
 {
     if (!m_owningLayer.parent())
         return false;
 
-    const RenderLayer* compositingAncestor = m_owningLayer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf);
+    const Layer* compositingAncestor = m_owningLayer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf);
     if (!compositingAncestor)
         return false;
 
     const RenderObject* clippingContainer = m_owningLayer.clippingContainer();
     if (!clippingContainer)
         return false;
 
     if (compositingAncestor->renderer()->isDescendantOf(clippingContainer))
         return false;
 
     // We ignore overflow clip here; we want composited overflow content to
     // behave as if it lives in an unclipped universe so it can prepaint, etc.
     // This means that we need to check if we are actually clipped before
     // setting up m_ancestorClippingLayer otherwise
     // updateAncestorClippingLayerGeometry will fail as the clip rect will be
     // infinite.
     // FIXME: this should use cached clip rects, but this sometimes give
-    // inaccurate results (and trips the ASSERTS in RenderLayerClipper).
+    // inaccurate results (and trips the ASSERTS in LayerClipper).
     ClipRectsContext clipRectsContext(compositingAncestor, UncachedClipRects, IgnoreOverlayScrollbarSize);
     clipRectsContext.setIgnoreOverflowClip();
     IntRect parentClipRect = pixelSnappedIntRect(m_owningLayer.clipper().backgroundClipRect(clipRectsContext).rect());
     return parentClipRect != LayoutRect::infiniteIntRect();
 }
 
 bool CompositedLayerMapping::updateGraphicsLayerConfiguration()
 {
     ASSERT(m_owningLayer.compositor()->lifecycle().state() == DocumentLifecycle::InCompositingUpdate);
 
     // Note carefully: here we assume that the compositing state of all descendants have been updated already,
     // so it is legitimate to compute and cache the composited bounds for this layer.
     updateCompositedBounds();
 
-    if (RenderLayerReflectionInfo* reflection = m_owningLayer.reflectionInfo()) {
+    if (LayerReflectionInfo* reflection = m_owningLayer.reflectionInfo()) {
         if (reflection->reflectionLayer()->hasCompositedLayerMapping())
             reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds();
     }
 
-    RenderLayerCompositor* compositor = this->compositor();
+    LayerCompositor* compositor = this->compositor();
     RenderObject* renderer = this->renderer();
 
     bool layerConfigChanged = false;
     setBackgroundLayerPaintsFixedRootBackground(compositor->needsFixedRootBackgroundLayer(&m_owningLayer));
 
     // The background layer is currently only used for fixed root backgrounds.
     if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground))
         layerConfigChanged = true;
 
     if (updateForegroundLayer(compositor->needsContentsCompositingLayer(&m_owningLayer)))
         layerConfigChanged = true;
 
     bool needsDescendantsClippingLayer = compositor->clipsCompositingDescendants(&m_owningLayer);
 
     // Our scrolling layer will clip.
     if (m_owningLayer.needsCompositedScrolling())
         needsDescendantsClippingLayer = false;
 
-    RenderLayer* scrollParent = compositor->preferCompositingToLCDTextEnabled() ? m_owningLayer.scrollParent() : 0;
+    Layer* scrollParent = compositor->preferCompositingToLCDTextEnabled() ? m_owningLayer.scrollParent() : 0;
 
     // This is required because compositing layers are parented
     // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy.
-    // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy,
+    // Thus, a Layer can be clipped by a Layer that is an ancestor in the renderer hierarchy,
     // but a sibling in the z-order hierarchy. Further, that sibling need not be composited at all.
     // In such scenarios, an ancestor clipping layer is necessary to apply the composited clip for this layer.
     bool needsAncestorClip = owningLayerClippedByLayerNotAboveCompositedAncestor();
 
     if (scrollParent) {
         // If our containing block is our ancestor scrolling layer, then we'll already be clipped
         // to it via our scroll parent and we don't need an ancestor clipping layer.
         if (m_owningLayer.renderer()->containingBlock()->enclosingLayer() == m_owningLayer.ancestorScrollingLayer())
             needsAncestorClip = false;
     }
@@ skipping 87 matching lines @@
     } else if (renderer->isVideo()) {
         HTMLMediaElement* mediaElement = toHTMLMediaElement(renderer->node());
         m_graphicsLayer->setContentsToPlatformLayer(mediaElement->platformLayer());
     } else if (isAcceleratedCanvas(renderer)) {
         HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer->node());
         if (CanvasRenderingContext* context = canvas->renderingContext())
             m_graphicsLayer->setContentsToPlatformLayer(context->platformLayer());
         layerConfigChanged = true;
     }
     if (renderer->isRenderPart())
-        layerConfigChanged = RenderLayerCompositor::parentFrameContentLayers(toRenderPart(renderer));
+        layerConfigChanged = LayerCompositor::parentFrameContentLayers(toRenderPart(renderer));
 
     // Changes to either the internal hierarchy or the mask layer have an impact
     // on painting phases, so we need to update when either are updated.
     if (layerConfigChanged || maskLayerChanged)
         updatePaintingPhases();
 
     return layerConfigChanged;
 }
 
 static IntRect clipBox(RenderBox* renderer)
 {
     LayoutRect result = LayoutRect::infiniteIntRect();
     if (renderer->hasOverflowClip())
         result = renderer->overflowClipRect(LayoutPoint());
 
     if (renderer->hasClip())
         result.intersect(renderer->clipRect(LayoutPoint()));
 
     return pixelSnappedIntRect(result);
 }
 
-static LayoutPoint computeOffsetFromCompositedAncestor(const RenderLayer* layer, const RenderLayer* compositedAncestor)
+static LayoutPoint computeOffsetFromCompositedAncestor(const Layer* layer, const Layer* compositedAncestor)
 {
     LayoutPoint offset = layer->visualOffsetFromAncestor(compositedAncestor);
     if (compositedAncestor)
         offset.move(compositedAncestor->compositedLayerMapping()->owningLayer().subpixelAccumulation());
     return offset;
 }
 
-void CompositedLayerMapping::computeBoundsOfOwningLayer(const RenderLayer* compositedAncestor, IntRect& localBounds, IntRect& compositingBoundsRelativeToCompositedAncestor, LayoutPoint& offsetFromCompositedAncestor,
+void CompositedLayerMapping::computeBoundsOfOwningLayer(const Layer* compositedAncestor, IntRect& localBounds, IntRect& compositingBoundsRelativeToCompositedAncestor, LayoutPoint& offsetFromCompositedAncestor,
     IntPoint& snappedOffsetFromCompositedAncestor)
 {
     LayoutRect localRawCompositingBounds = compositedBounds();
     offsetFromCompositedAncestor = computeOffsetFromCompositedAncestor(&m_owningLayer, compositedAncestor);
     snappedOffsetFromCompositedAncestor = IntPoint(offsetFromCompositedAncestor.x().round(), offsetFromCompositedAncestor.y().round());
 
     LayoutSize subpixelAccumulation = offsetFromCompositedAncestor - snappedOffsetFromCompositedAncestor;
     m_owningLayer.setSubpixelAccumulation(subpixelAccumulation);
 
     // Move the bounds by the subpixel accumulation so that it pixel-snaps relative to absolute pixels instead of local coordinates.
     localRawCompositingBounds.move(subpixelAccumulation);
     localBounds = pixelSnappedIntRect(localRawCompositingBounds);
 
     compositingBoundsRelativeToCompositedAncestor = localBounds;
     compositingBoundsRelativeToCompositedAncestor.moveBy(snappedOffsetFromCompositedAncestor);
 }
 
-void CompositedLayerMapping::updateSquashingLayerGeometry(const LayoutPoint& offsetFromCompositedAncestor, const IntPoint& graphicsLayerParentLocation, const RenderLayer& referenceLayer,
-    Vector<GraphicsLayerPaintInfo>& layers, GraphicsLayer* squashingLayer, LayoutPoint* offsetFromTransformedAncestor, Vector<RenderLayer*>& layersNeedingPaintInvalidation)
+void CompositedLayerMapping::updateSquashingLayerGeometry(const LayoutPoint& offsetFromCompositedAncestor, const IntPoint& graphicsLayerParentLocation, const Layer& referenceLayer,
+    Vector<GraphicsLayerPaintInfo>& layers, GraphicsLayer* squashingLayer, LayoutPoint* offsetFromTransformedAncestor, Vector<Layer*>& layersNeedingPaintInvalidation)
 {
     if (!squashingLayer)
         return;
 
     LayoutPoint offsetFromReferenceLayerToParentGraphicsLayer(offsetFromCompositedAncestor);
     offsetFromReferenceLayerToParentGraphicsLayer.moveBy(-graphicsLayerParentLocation);
 
     // FIXME: Cache these offsets.
     LayoutPoint referenceOffsetFromTransformedAncestor = referenceLayer.computeOffsetFromTransformedAncestor();
 
     LayoutRect totalSquashBounds;
     for (size_t i = 0; i < layers.size(); ++i) {
         LayoutRect squashedBounds = layers[i].renderLayer->boundingBoxForCompositing();
 
-        // Store the local bounds of the RenderLayer subtree before applying the offset.
+        // Store the local bounds of the Layer subtree before applying the offset.
         layers[i].compositedBounds = squashedBounds;
 
         LayoutPoint offsetFromTransformedAncestorForSquashedLayer = layers[i].renderLayer->computeOffsetFromTransformedAncestor();
         LayoutSize offsetFromSquashingLayer = offsetFromTransformedAncestorForSquashedLayer - referenceOffsetFromTransformedAncestor;
 
         squashedBounds.move(offsetFromSquashingLayer);
         totalSquashBounds.unite(squashedBounds);
     }
 
     // The totalSquashBounds is positioned with respect to referenceLayer of this CompositedLayerMapping.
     // But the squashingLayer needs to be positioned with respect to the ancestor CompositedLayerMapping.
     // The conversion between referenceLayer and the ancestor CLM is already computed as
     // offsetFromReferenceLayerToParentGraphicsLayer.
     totalSquashBounds.moveBy(offsetFromReferenceLayerToParentGraphicsLayer);
     const IntRect squashLayerBounds = enclosingIntRect(totalSquashBounds);
     const IntPoint squashLayerOrigin = squashLayerBounds.location();
     const LayoutSize squashLayerOriginInOwningLayerSpace = squashLayerOrigin - offsetFromReferenceLayerToParentGraphicsLayer;
 
-    // Now that the squashing bounds are known, we can convert the RenderLayer painting offsets
+    // Now that the squashing bounds are known, we can convert the Layer painting offsets
     // from CLM owning layer space to the squashing layer space.
     //
-    // The painting offset we want to compute for each squashed RenderLayer is essentially the position of
-    // the squashed RenderLayer described w.r.t. referenceLayer's origin.
+    // The painting offset we want to compute for each squashed Layer is essentially the position of
+    // the squashed Layer described w.r.t. referenceLayer's origin.
     // So we just need to convert that point from referenceLayer space to the squashing layer's
     // space. This is simply done by subtracing squashLayerOriginInOwningLayerSpace, but then the offset
     // overall needs to be negated because that's the direction that the painting code expects the
     // offset to be.
     for (size_t i = 0; i < layers.size(); ++i) {
         const LayoutPoint offsetFromTransformedAncestorForSquashedLayer = layers[i].renderLayer->computeOffsetFromTransformedAncestor();
         const LayoutSize offsetFromSquashLayerOrigin = (offsetFromTransformedAncestorForSquashedLayer - referenceOffsetFromTransformedAncestor) - squashLayerOriginInOwningLayerSpace;
 
         IntSize newOffsetFromRenderer = -IntSize(offsetFromSquashLayerOrigin.width().round(), offsetFromSquashLayerOrigin.height().round());
         LayoutSize subpixelAccumulation = offsetFromSquashLayerOrigin + newOffsetFromRenderer;
@@ skipping 13 matching lines @@
     squashingLayer->setPosition(squashLayerBounds.location());
     squashingLayer->setSize(squashLayerBounds.size());
 
     *offsetFromTransformedAncestor = referenceOffsetFromTransformedAncestor;
     offsetFromTransformedAncestor->move(squashLayerOriginInOwningLayerSpace);
 
     for (size_t i = 0; i < layers.size(); ++i)
         layers[i].localClipRectForSquashedLayer = localClipRectForSquashedLayer(referenceLayer, layers[i], layers);
 }
 
-void CompositedLayerMapping::updateGraphicsLayerGeometry(const RenderLayer* compositingContainer, const RenderLayer* compositingStackingContext, Vector<RenderLayer*>& layersNeedingPaintInvalidation)
+void CompositedLayerMapping::updateGraphicsLayerGeometry(const Layer* compositingContainer, const Layer* compositingStackingContext, Vector<Layer*>& layersNeedingPaintInvalidation)
 {
     ASSERT(m_owningLayer.compositor()->lifecycle().state() == DocumentLifecycle::InCompositingUpdate);
 
     // Set transform property, if it is not animating. We have to do this here because the transform
     // is affected by the layer dimensions.
     if (!renderer()->style()->isRunningTransformAnimationOnCompositor())
         updateTransform(renderer()->style());
 
     // Set opacity, if it is not animating.
     if (!renderer()->style()->isRunningOpacityAnimationOnCompositor())
@@ skipping 71 matching lines @@
 void CompositedLayerMapping::updateMainGraphicsLayerGeometry(const IntRect& relativeCompositingBounds, const IntRect& localCompositingBounds, const IntPoint& graphicsLayerParentLocation)
 {
     m_graphicsLayer->setPosition(FloatPoint(relativeCompositingBounds.location() - graphicsLayerParentLocation));
     m_graphicsLayer->setOffsetFromRenderer(toIntSize(localCompositingBounds.location()));
 
     FloatSize oldSize = m_graphicsLayer->size();
     const IntSize& contentsSize = relativeCompositingBounds.size();
     if (oldSize != contentsSize)
         m_graphicsLayer->setSize(contentsSize);
 
-    // m_graphicsLayer is the corresponding GraphicsLayer for this RenderLayer and its non-compositing
+    // m_graphicsLayer is the corresponding GraphicsLayer for this Layer and its non-compositing
     // descendants. So, the visibility flag for m_graphicsLayer should be true if there are any
     // non-compositing visible layers.
     bool contentsVisible = m_owningLayer.hasVisibleContent() || hasVisibleNonCompositingDescendant(&m_owningLayer);
     if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && renderer()->isVideo()) {
         HTMLVideoElement* videoElement = toHTMLVideoElement(renderer()->node());
         if (videoElement->isFullscreen() && !HTMLMediaElement::isMediaStreamURL(videoElement->sourceURL().string()))
             contentsVisible = false;
     }
     m_graphicsLayer->setContentsVisible(contentsVisible);
 
     m_graphicsLayer->setBackfaceVisibility(renderer()->style()->backfaceVisibility() == BackfaceVisibilityVisible);
 }
 
-void CompositedLayerMapping::computeGraphicsLayerParentLocation(const RenderLayer* compositingContainer, const IntRect& ancestorCompositingBounds, IntPoint& graphicsLayerParentLocation)
+void CompositedLayerMapping::computeGraphicsLayerParentLocation(const Layer* compositingContainer, const IntRect& ancestorCompositingBounds, IntPoint& graphicsLayerParentLocation)
 {
     if (compositingContainer && compositingContainer->compositedLayerMapping()->hasClippingLayer()) {
         // If the compositing ancestor has a layer to clip children, we parent in that, and therefore
         // position relative to it.
         IntRect clippingBox = clipBox(toRenderBox(compositingContainer->renderer()));
         graphicsLayerParentLocation = clippingBox.location() + roundedIntSize(compositingContainer->subpixelAccumulation());
     } else if (compositingContainer && compositingContainer->compositedLayerMapping()->childTransformLayer()) {
         // Similarly, if the compositing ancestor has a child transform layer, we parent in that, and therefore
         // position relative to it. It's already taken into account the contents offset, so we do not need to here.
         graphicsLayerParentLocation = roundedIntPoint(compositingContainer->subpixelAccumulation());
     } else if (compositingContainer) {
         graphicsLayerParentLocation = ancestorCompositingBounds.location();
     } else {
         graphicsLayerParentLocation = renderer()->view()->documentRect().location();
     }
 
     if (compositingContainer && compositingContainer->needsCompositedScrolling()) {
         RenderBox* renderBox = toRenderBox(compositingContainer->renderer());
         IntSize scrollOffset = renderBox->scrolledContentOffset();
         IntPoint scrollOrigin(renderBox->borderLeft(), renderBox->borderTop());
         graphicsLayerParentLocation = scrollOrigin - scrollOffset;
     }
 }
 
-void CompositedLayerMapping::updateAncestorClippingLayerGeometry(const RenderLayer* compositingContainer, const IntPoint& snappedOffsetFromCompositedAncestor, IntPoint& graphicsLayerParentLocation)
+void CompositedLayerMapping::updateAncestorClippingLayerGeometry(const Layer* compositingContainer, const IntPoint& snappedOffsetFromCompositedAncestor, IntPoint& graphicsLayerParentLocation)
 {
     if (!compositingContainer || !m_ancestorClippingLayer)
         return;
 
     ClipRectsContext clipRectsContext(compositingContainer, PaintingClipRectsIgnoringOverflowClip, IgnoreOverlayScrollbarSize);
     IntRect parentClipRect = pixelSnappedIntRect(m_owningLayer.clipper().backgroundClipRect(clipRectsContext).rect());
     ASSERT(parentClipRect != LayoutRect::infiniteIntRect());
     m_ancestorClippingLayer->setPosition(FloatPoint(parentClipRect.location() - graphicsLayerParentLocation));
     m_ancestorClippingLayer->setSize(parentClipRect.size());
 
     // backgroundRect is relative to compositingContainer, so subtract snappedOffsetFromCompositedAncestor.X/snappedOffsetFromCompositedAncestor.Y to get back to local coords.
     m_ancestorClippingLayer->setOffsetFromRenderer(parentClipRect.location() - snappedOffsetFromCompositedAncestor);
 
     // The primary layer is then parented in, and positioned relative to this clipping layer.
     graphicsLayerParentLocation = parentClipRect.location();
 }
 
-void CompositedLayerMapping::updateOverflowControlsHostLayerGeometry(const RenderLayer* compositingStackingContext)
+void CompositedLayerMapping::updateOverflowControlsHostLayerGeometry(const Layer* compositingStackingContext)
 {
     if (!m_overflowControlsHostLayer)
         return;
 
     if (needsToReparentOverflowControls()) {
         if (m_overflowControlsClippingLayer) {
             m_overflowControlsClippingLayer->setPosition(m_ancestorClippingLayer->position());
             m_overflowControlsClippingLayer->setSize(m_ancestorClippingLayer->size());
             m_overflowControlsClippingLayer->setOffsetFromRenderer(m_ancestorClippingLayer->offsetFromRenderer());
             m_overflowControlsClippingLayer->setMasksToBounds(true);
 
             m_overflowControlsHostLayer->setPosition(IntPoint(-m_overflowControlsClippingLayer->offsetFromRenderer()));
         } else {
             // The controls are in the same 2D space as the compositing container, so we can map them into the space of the container.
             TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
             m_owningLayer.renderer()->mapLocalToContainer(compositingStackingContext->renderer(), transformState, ApplyContainerFlip);
             transformState.flatten();
             LayoutPoint offsetFromStackingContainer = LayoutPoint(transformState.lastPlanarPoint());
-            if (RenderLayerScrollableArea* scrollableArea = compositingStackingContext->scrollableArea())
+            if (LayerScrollableArea* scrollableArea = compositingStackingContext->scrollableArea())
                 offsetFromStackingContainer.move(LayoutSize(scrollableArea->adjustedScrollOffset()));
             m_overflowControlsHostLayer->setPosition(FloatPoint(offsetFromStackingContainer));
         }
     } else {
         m_overflowControlsHostLayer->setPosition(FloatPoint());
     }
 }
 
 void CompositedLayerMapping::updateChildContainmentLayerGeometry(const IntRect& clippingBox, const IntRect& localCompositingBounds)
 {
@@ skipping 53 matching lines @@
         m_graphicsLayer->setTransformOrigin(compositedTransformOrigin);
     } else {
         FloatPoint3D compositedTransformOrigin(
             relativeCompositingBounds.width() * 0.5f,
             relativeCompositingBounds.height() * 0.5f,
             0.f);
         m_graphicsLayer->setTransformOrigin(compositedTransformOrigin);
     }
 }
 
-void CompositedLayerMapping::updateReflectionLayerGeometry(Vector<RenderLayer*>& layersNeedingPaintInvalidation)
+void CompositedLayerMapping::updateReflectionLayerGeometry(Vector<Layer*>& layersNeedingPaintInvalidation)
 {
     if (!m_owningLayer.reflectionInfo() || !m_owningLayer.reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping())
         return;
 
     CompositedLayerMapping* reflectionCompositedLayerMapping = m_owningLayer.reflectionInfo()->reflectionLayer()->compositedLayerMapping();
     reflectionCompositedLayerMapping->updateGraphicsLayerGeometry(&m_owningLayer, &m_owningLayer, layersNeedingPaintInvalidation);
 }
 
 void CompositedLayerMapping::updateScrollingLayerGeometry(const IntRect& localCompositingBounds)
 {
@@ skipping 202 matching lines @@
 }
 
 void CompositedLayerMapping::updateContentsRect()
 {
     m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsBox()));
 }
 
 void CompositedLayerMapping::updateContentsOffsetInCompositingLayer(const IntPoint& snappedOffsetFromCompositedAncestor, const IntPoint& graphicsLayerParentLocation)
 {
     // m_graphicsLayer is positioned relative to our compositing ancestor
-    // RenderLayer, but it's not positioned at the origin of m_owningLayer, it's
+    // Layer, but it's not positioned at the origin of m_owningLayer, it's
     // offset by m_contentBounds.location(). This is what
     // contentOffsetInCompositingLayer is meant to capture, roughly speaking
     // (ignoring rounding and subpixel accumulation).
     //
     // Our ancestor graphics layers in this CLM (m_graphicsLayer and potentially
     // m_ancestorClippingLayer) have pixel snapped, so if we don't adjust this
     // offset, we'll see accumulated rounding errors due to that snapping.
     //
     // In order to ensure that we account for this rounding, we compute
     // contentsOffsetInCompositingLayer in a somewhat roundabout way.
@@ skipping 301 matching lines @@
     int id = 0;
 
     // NB, it is illegal at this point to query an ancestor's compositing state. Some compositing
     // reasons depend on the compositing state of ancestors. So if we want a rendering context id
     // for the context root, we cannot ask for the id of its associated WebLayer now; it may not have
     // one yet. We could do a second past after doing the compositing updates to get these ids,
     // but this would actually be harmful. We do not want to attach any semantic meaning to
     // the context id other than the fact that they group a number of layers together for the
     // sake of 3d sorting. So instead we will ask the compositor to vend us an arbitrary, but
     // consistent id.
-    if (RenderLayer* root = m_owningLayer.renderingContextRoot()) {
+    if (Layer* root = m_owningLayer.renderingContextRoot()) {
         if (Node* node = root->renderer()->node())
             id = static_cast<int>(WTF::PtrHash<Node*>::hash(node));
     }
 
     UpdateRenderingContextFunctor functor = { id };
     ApplyToGraphicsLayersMode mode = ApplyToAllGraphicsLayers & ~ApplyToSquashingLayer;
     ApplyToGraphicsLayers<UpdateRenderingContextFunctor>(this, functor, mode);
 }
 
 struct UpdateShouldFlattenTransformFunctor {
@@ skipping 141 matching lines @@
         m_scrollingContentsLayer = nullptr;
         m_scrollingBlockSelectionLayer = nullptr;
         layerChanged = true;
         if (scrollingCoordinator)
             scrollingCoordinator->scrollableAreaScrollLayerDidChange(m_owningLayer.scrollableArea());
     }
 
     return layerChanged;
 }
 
-static void updateScrollParentForGraphicsLayer(GraphicsLayer* layer, GraphicsLayer* topmostLayer, RenderLayer* scrollParent, ScrollingCoordinator* scrollingCoordinator)
+static void updateScrollParentForGraphicsLayer(GraphicsLayer* layer, GraphicsLayer* topmostLayer, Layer* scrollParent, ScrollingCoordinator* scrollingCoordinator)
 {
     if (!layer)
         return;
 
     // Only the topmost layer has a scroll parent. All other layers have a null scroll parent.
     if (layer != topmostLayer)
         scrollParent = 0;
 
     scrollingCoordinator->updateScrollParentForGraphicsLayer(layer, scrollParent);
 }
 
-void CompositedLayerMapping::updateScrollParent(RenderLayer* scrollParent)
+void CompositedLayerMapping::updateScrollParent(Layer* scrollParent)
 {
     if (ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer)) {
         GraphicsLayer* topmostLayer = childForSuperlayers();
         updateScrollParentForGraphicsLayer(m_squashingContainmentLayer.get(), topmostLayer, scrollParent, scrollingCoordinator);
         updateScrollParentForGraphicsLayer(m_ancestorClippingLayer.get(), topmostLayer, scrollParent, scrollingCoordinator);
         updateScrollParentForGraphicsLayer(m_graphicsLayer.get(), topmostLayer, scrollParent, scrollingCoordinator);
     }
 }
 
 void CompositedLayerMapping::updateClipParent()
 {
     if (owningLayerClippedByLayerNotAboveCompositedAncestor())
         return;
 
-    RenderLayer* clipParent = m_owningLayer.clipParent();
+    Layer* clipParent = m_owningLayer.clipParent();
     if (clipParent)
         clipParent = clipParent->enclosingLayerWithCompositedLayerMapping(IncludeSelf);
 
     if (ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer))
         scrollingCoordinator->updateClipParentForGraphicsLayer(m_graphicsLayer.get(), clipParent);
 }
 
 bool CompositedLayerMapping::updateSquashingLayers(bool needsSquashingLayers)
 {
     bool layersChanged = false;
@@ skipping 53 matching lines @@
         phase |= GraphicsLayerPaintCompositedScroll;
     }
 
     return static_cast<GraphicsLayerPaintingPhase>(phase);
 }
 
 float CompositedLayerMapping::compositingOpacity(float rendererOpacity) const
 {
     float finalOpacity = rendererOpacity;
 
-    for (RenderLayer* curr = m_owningLayer.parent(); curr; curr = curr->parent()) {
+    for (Layer* curr = m_owningLayer.parent(); curr; curr = curr->parent()) {
         // We only care about parents that are stacking contexts.
         // Recall that opacity creates stacking context.
         if (!curr->stackingNode()->isStackingContext())
             continue;
 
         // If we found a composited layer, regardless of whether it actually
         // paints into it, we want to compute opacity relative to it. So we can
         // break here.
         //
         // FIXME: with grouped backings, a composited descendant will have to
@@ skipping 33 matching lines @@
         return true;
 
     return false;
 }
 
 static bool isCompositedPlugin(RenderObject* renderer)
 {
     return renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->requiresAcceleratedCompositing();
 }
 
-bool CompositedLayerMapping::hasVisibleNonCompositingDescendant(RenderLayer* parent)
+bool CompositedLayerMapping::hasVisibleNonCompositingDescendant(Layer* parent)
 {
     if (!parent->hasVisibleDescendant())
         return false;
 
     // FIXME: We shouldn't be called with a stale z-order lists. See bug 85512.
     parent->stackingNode()->updateLayerListsIfNeeded();
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(parent->stackingNode());
 #endif
 
-    RenderLayerStackingNodeIterator normalFlowIterator(*parent->stackingNode(), AllChildren);
-    while (RenderLayerStackingNode* curNode = normalFlowIterator.next()) {
-        RenderLayer* curLayer = curNode->layer();
+    LayerStackingNodeIterator normalFlowIterator(*parent->stackingNode(), AllChildren);
+    while (LayerStackingNode* curNode = normalFlowIterator.next()) {
+        Layer* curLayer = curNode->layer();
         if (curLayer->hasCompositedLayerMapping())
             continue;
         if (curLayer->hasVisibleContent() || hasVisibleNonCompositingDescendant(curLayer))
             return true;
     }
 
     return false;
 }
 
 bool CompositedLayerMapping::containsPaintedContent() const
@@ skipping 134 matching lines @@
     return contentsBox;
 }
 
 bool CompositedLayerMapping::needsToReparentOverflowControls() const
 {
     return m_owningLayer.scrollableArea()
         && m_owningLayer.scrollableArea()->hasOverlayScrollbars()
         && m_owningLayer.scrollableArea()->topmostScrollChild();
 }
 
-GraphicsLayer* CompositedLayerMapping::detachLayerForOverflowControls(const RenderLayer& enclosingLayer)
+GraphicsLayer* CompositedLayerMapping::detachLayerForOverflowControls(const Layer& enclosingLayer)
 {
     GraphicsLayer* host = m_overflowControlsClippingLayer.get();
     if (!host)
         host = m_overflowControlsHostLayer.get();
     host->removeFromParent();
     return host;
 }
 
 GraphicsLayer* CompositedLayerMapping::parentForSublayers() const
 {
@@ skipping 100 matching lines @@
             return &layers[i];
     }
     return 0;
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const RenderObject* renderObject, unsigned maxSquashedLayerIndex)
 {
     return CompositedLayerMapping::containingSquashedLayer(renderObject, m_squashedLayers, maxSquashedLayerIndex);
 }
 
-IntRect CompositedLayerMapping::localClipRectForSquashedLayer(const RenderLayer& referenceLayer, const GraphicsLayerPaintInfo& paintInfo, const Vector<GraphicsLayerPaintInfo>& layers)
+IntRect CompositedLayerMapping::localClipRectForSquashedLayer(const Layer& referenceLayer, const GraphicsLayerPaintInfo& paintInfo, const Vector<GraphicsLayerPaintInfo>& layers)
 {
     const RenderObject* clippingContainer = paintInfo.renderLayer->clippingContainer();
     if (clippingContainer == referenceLayer.clippingContainer())
         return LayoutRect::infiniteIntRect();
 
     ASSERT(clippingContainer);
 
     const GraphicsLayerPaintInfo* ancestorPaintInfo = containingSquashedLayer(clippingContainer, layers, layers.size());
     // Must be there, otherwise CompositingLayerAssigner::canSquashIntoCurrentSquashingOwner would have disallowed squashing.
     ASSERT(ancestorPaintInfo);
@@ skipping 41 matching lines @@
     if (paintInfo.renderLayer->compositingState() != PaintsIntoGroupedBacking) {
         // FIXME: GraphicsLayers need a way to split for RenderRegions.
         LayerPaintingInfo paintingInfo(paintInfo.renderLayer, dirtyRect, PaintBehaviorNormal, paintInfo.renderLayer->subpixelAccumulation());
         LayerPainter(*paintInfo.renderLayer).paintLayerContents(context, paintingInfo, paintLayerFlags);
 
         if (paintInfo.renderLayer->containsDirtyOverlayScrollbars())
             LayerPainter(*paintInfo.renderLayer).paintLayerContents(context, paintingInfo, paintLayerFlags | PaintLayerPaintingOverlayScrollbars);
     } else {
         LayerPaintingInfo paintingInfo(paintInfo.renderLayer, dirtyRect, PaintBehaviorNormal, paintInfo.renderLayer->subpixelAccumulation());
 
-        // RenderLayer::paintLayer assumes that the caller clips to the passed rect. Squashed layers need to do this clipping in software,
+        // Layer::paintLayer assumes that the caller clips to the passed rect. Squashed layers need to do this clipping in software,
         // since there is no graphics layer to clip them precisely. Furthermore, in some cases we squash layers that need clipping in software
         // from clipping ancestors (see CompositedLayerMapping::localClipRectForSquashedLayer()).
         // FIXME: Is it correct to clip to dirtyRect in slimming paint mode?
         // FIXME: Combine similar code here and LayerClipRecorder.
         dirtyRect.intersect(paintInfo.localClipRectForSquashedLayer);
         {
             OwnPtr<DisplayItem> clipDisplayItem = ClipDisplayItem::create(displayItemClient(), DisplayItem::ClipLayerOverflowControls, dirtyRect);
             if (context->displayItemList()) {
                 ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
                 context->displayItemList()->add(clipDisplayItem.release());
@@ skipping 118 matching lines @@
     renderer()->node()->document().compositorPendingAnimations().notifyCompositorAnimationStarted(monotonicTime, group);
 }
 
 IntRect CompositedLayerMapping::pixelSnappedCompositedBounds() const
 {
     LayoutRect bounds = m_compositedBounds;
     bounds.move(m_owningLayer.subpixelAccumulation());
     return pixelSnappedIntRect(bounds);
 }
 
-bool CompositedLayerMapping::updateSquashingLayerAssignment(RenderLayer* squashedLayer, const RenderLayer& owningLayer, size_t nextSquashedLayerIndex)
+bool CompositedLayerMapping::updateSquashingLayerAssignment(Layer* squashedLayer, const Layer& owningLayer, size_t nextSquashedLayerIndex)
 {
     GraphicsLayerPaintInfo paintInfo;
     paintInfo.renderLayer = squashedLayer;
     // NOTE: composited bounds are updated elsewhere
     // NOTE: offsetFromRenderer is updated elsewhere
 
     // Change tracking on squashing layers: at the first sign of something changed, just invalidate the layer.
     // FIXME: Perhaps we can find a tighter more clever mechanism later.
     bool updatedAssignment = false;
     if (nextSquashedLayerIndex < m_squashedLayers.size()) {
         if (paintInfo.renderLayer != m_squashedLayers[nextSquashedLayerIndex].renderLayer) {
             compositor()->paintInvalidationOnCompositingChange(squashedLayer);
             updatedAssignment = true;
             m_squashedLayers[nextSquashedLayerIndex] = paintInfo;
         }
     } else {
         compositor()->paintInvalidationOnCompositingChange(squashedLayer);
         m_squashedLayers.append(paintInfo);
         updatedAssignment = true;
     }
     squashedLayer->setGroupedMapping(this);
     return updatedAssignment;
 }
 
-void CompositedLayerMapping::removeRenderLayerFromSquashingGraphicsLayer(const RenderLayer* layer)
+void CompositedLayerMapping::removeLayerFromSquashingGraphicsLayer(const Layer* layer)
 {
     size_t layerIndex = kNotFound;
 
     for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
         if (m_squashedLayers[i].renderLayer == layer) {
             layerIndex = i;
             break;
         }
     }
 
     if (layerIndex == kNotFound)
         return;
 
     m_squashedLayers.remove(layerIndex);
 }
 
 void CompositedLayerMapping::finishAccumulatingSquashingLayers(size_t nextSquashedLayerIndex)
 {
-    // Any additional squashed RenderLayers in the array no longer exist, and removing invalidates the squashingLayer contents.
+    // Any additional squashed Layers in the array no longer exist, and removing invalidates the squashingLayer contents.
     if (nextSquashedLayerIndex < m_squashedLayers.size())
         m_squashedLayers.remove(nextSquashedLayerIndex, m_squashedLayers.size() - nextSquashedLayerIndex);
 }
 
 String CompositedLayerMapping::debugName(const GraphicsLayer* graphicsLayer)
 {
     String name;
     if (graphicsLayer == m_graphicsLayer.get()) {
         name = m_owningLayer.debugName();
     } else if (graphicsLayer == m_squashingContainmentLayer.get()) {
@@ skipping 31 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink