Rename renderer() to layoutObject().

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 140 matching lines @@
 static inline bool isAcceleratedContents(LayoutObject* renderer)
 {
     return isAcceleratedCanvas(renderer)
         || (renderer->isEmbeddedObject() && toLayoutEmbeddedObject(renderer)->requiresAcceleratedCompositing())
         || renderer->isVideo();
 }
 
 // Get the scrolling coordinator in a way that works inside CompositedLayerMapping's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(Layer& layer)
 {
-    Page* page = layer.renderer()->frame()->page();
+    Page* page = layer.layoutObject()->frame()->page();
     if (!page)
         return 0;
 
     return page->scrollingCoordinator();
 }
 
 CompositedLayerMapping::CompositedLayerMapping(Layer& layer)
     : m_owningLayer(layer)
     , m_contentOffsetInCompositingLayerDirty(false)
     , m_pendingUpdateScope(GraphicsLayerUpdateNone)
     , m_isMainFrameLayoutViewLayer(false)
     , m_backgroundLayerPaintsFixedRootBackground(false)
     , m_scrollingContentsAreEmpty(false)
 {
-    if (layer.isRootLayer() && renderer()->frame()->isMainFrame())
+    if (layer.isRootLayer() && layoutObject()->frame()->isMainFrame())
         m_isMainFrameLayoutViewLayer = true;
 
     createPrimaryGraphicsLayer();
 }
 
 CompositedLayerMapping::~CompositedLayerMapping()
 {
     // Hits in compositing/squashing/squash-onto-nephew.html.
     DisableCompositingQueryAsserts disabler;
 
@@ skipping 14 matching lines @@
     updateMaskLayer(false);
     updateClippingMaskLayers(false);
     updateScrollingLayers(false);
     updateSquashingLayers(false);
     destroyGraphicsLayers();
 }
 
 PassOwnPtr<GraphicsLayer> CompositedLayerMapping::createGraphicsLayer(CompositingReasons reasons)
 {
     GraphicsLayerFactory* graphicsLayerFactory = 0;
-    if (Page* page = renderer()->frame()->page())
+    if (Page* page = layoutObject()->frame()->page())
         graphicsLayerFactory = page->chrome().client().graphicsLayerFactory();
 
     OwnPtr<GraphicsLayer> graphicsLayer = GraphicsLayer::create(graphicsLayerFactory, this);
 
     graphicsLayer->setCompositingReasons(reasons);
-    if (Node* owningNode = m_owningLayer.renderer()->generatingNode())
+    if (Node* owningNode = m_owningLayer.layoutObject()->generatingNode())
         graphicsLayer->setOwnerNodeId(InspectorNodeIds::idForNode(owningNode));
 
     return graphicsLayer.release();
 }
 
 void CompositedLayerMapping::createPrimaryGraphicsLayer()
 {
     m_graphicsLayer = createGraphicsLayer(m_owningLayer.compositingReasons());
 
 #if !OS(ANDROID)
     if (m_isMainFrameLayoutViewLayer)
         m_graphicsLayer->contentLayer()->setDrawCheckerboardForMissingTiles(true);
 #endif
 
-    updateOpacity(renderer()->styleRef());
-    updateTransform(renderer()->styleRef());
-    updateFilters(renderer()->styleRef());
+    updateOpacity(layoutObject()->styleRef());
+    updateTransform(layoutObject()->styleRef());
+    updateFilters(layoutObject()->styleRef());
 
     if (RuntimeEnabledFeatures::cssCompositingEnabled()) {
-        updateLayerBlendMode(renderer()->styleRef());
+        updateLayerBlendMode(layoutObject()->styleRef());
         updateIsRootForIsolatedGroup();
     }
 
-    updateScrollBlocksOn(renderer()->styleRef());
+    updateScrollBlocksOn(layoutObject()->styleRef());
 }
 
 void CompositedLayerMapping::destroyGraphicsLayers()
 {
     if (m_graphicsLayer)
         m_graphicsLayer->removeFromParent();
 
     m_ancestorClippingLayer = nullptr;
     m_graphicsLayer = nullptr;
     m_foregroundLayer = nullptr;
@@ skipping 12 matching lines @@
 {
     m_graphicsLayer->setOpacity(compositingOpacity(style.opacity()));
 }
 
 void CompositedLayerMapping::updateTransform(const LayoutStyle& style)
 {
     // FIXME: This could use m_owningLayer.transform(), but that currently has transform-origin
     // baked into it, and we don't want that.
     TransformationMatrix t;
     if (m_owningLayer.hasTransformRelatedProperty()) {
-        style.applyTransform(t, LayoutSize(toLayoutBox(renderer())->pixelSnappedSize()), LayoutStyle::ExcludeTransformOrigin);
+        style.applyTransform(t, LayoutSize(toLayoutBox(layoutObject())->pixelSnappedSize()), LayoutStyle::ExcludeTransformOrigin);
         makeMatrixRenderable(t, compositor()->hasAcceleratedCompositing());
     }
 
     m_graphicsLayer->setTransform(t);
 }
 
 void CompositedLayerMapping::updateFilters(const LayoutStyle& style)
 {
     m_graphicsLayer->setFilters(owningLayer().computeFilterOperations(style));
 }
@@ skipping 21 matching lines @@
 
     if (RuntimeEnabledFeatures::cssScrollBlocksOnEnabled())
         blockingMode = style.scrollBlocksOn();
 
     m_graphicsLayer->setScrollBlocksOn(blockingMode);
 }
 
 void CompositedLayerMapping::updateContentsOpaque()
 {
     ASSERT(m_isMainFrameLayoutViewLayer || !m_backgroundLayer);
-    if (isAcceleratedCanvas(renderer())) {
+    if (isAcceleratedCanvas(layoutObject())) {
         // Determine whether the rendering context's external texture layer is opaque.
-        CanvasRenderingContext* context = toHTMLCanvasElement(renderer()->node())->renderingContext();
+        CanvasRenderingContext* context = toHTMLCanvasElement(layoutObject()->node())->renderingContext();
         if (!context->hasAlpha())
             m_graphicsLayer->setContentsOpaque(true);
         else if (WebLayer* layer = context->platformLayer())
             m_graphicsLayer->setContentsOpaque(!Color(layer->backgroundColor()).hasAlpha());
         else
             m_graphicsLayer->setContentsOpaque(false);
     } else if (m_backgroundLayer) {
         m_graphicsLayer->setContentsOpaque(false);
         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 Layer.
     m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
     m_contentOffsetInCompositingLayerDirty = true;
 }
 
 void CompositedLayerMapping::updateAfterPartResize()
 {
-    if (renderer()->isLayoutPart()) {
-        if (LayerCompositor* innerCompositor = LayerCompositor::frameContentsCompositor(toLayoutPart(renderer()))) {
+    if (layoutObject()->isLayoutPart()) {
+        if (LayerCompositor* innerCompositor = LayerCompositor::frameContentsCompositor(toLayoutPart(layoutObject()))) {
             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 Layer* compositingAncestor = m_owningLayer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf);
     if (!compositingAncestor)
         return false;
 
     const LayoutObject* clippingContainer = m_owningLayer.clippingContainer();
     if (!clippingContainer)
         return false;
 
-    if (compositingAncestor->renderer()->isDescendantOf(clippingContainer))
+    if (compositingAncestor->layoutObject()->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 LayerClipper).
@@ skipping 10 matching lines @@
     // 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 (LayerReflectionInfo* reflection = m_owningLayer.reflectionInfo()) {
         if (reflection->reflectionLayer()->hasCompositedLayerMapping())
             reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds();
     }
 
     LayerCompositor* compositor = this->compositor();
-    LayoutObject* renderer = this->renderer();
+    LayoutObject* renderer = this->layoutObject();
 
     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;
 
     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 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())
+        if (m_owningLayer.layoutObject()->containingBlock()->enclosingLayer() == m_owningLayer.ancestorScrollingLayer())
             needsAncestorClip = false;
     }
 
     if (updateClippingLayers(needsAncestorClip, needsDescendantsClippingLayer))
         layerConfigChanged = true;
 
     bool scrollingConfigChanged = false;
     if (updateScrollingLayers(m_owningLayer.needsCompositedScrolling())) {
         layerConfigChanged = true;
         scrollingConfigChanged = true;
@@ skipping 183 matching lines @@
     // 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;
         if (layers[i].offsetFromRendererSet && layers[i].offsetFromRenderer != newOffsetFromRenderer) {
             // It is ok to issue paint invalidation here, because all of the geometry needed to correctly invalidate paint is computed by this point.
             DisablePaintInvalidationStateAsserts disabler;
-            layers[i].renderLayer->renderer()->invalidatePaintIncludingNonCompositingDescendants();
+            layers[i].renderLayer->layoutObject()->invalidatePaintIncludingNonCompositingDescendants();
 
             TRACE_LAYER_INVALIDATION(layers[i].renderLayer, InspectorLayerInvalidationTrackingEvent::SquashingLayerGeometryWasUpdated);
             layersNeedingPaintInvalidation.append(layers[i].renderLayer);
         }
         layers[i].offsetFromRenderer = newOffsetFromRenderer;
         layers[i].offsetFromRendererSet = true;
 
         layers[i].renderLayer->setSubpixelAccumulation(subpixelAccumulation);
     }
 
     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 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()->styleRef());
+    if (!layoutObject()->style()->isRunningTransformAnimationOnCompositor())
+        updateTransform(layoutObject()->styleRef());
 
     // Set opacity, if it is not animating.
-    if (!renderer()->style()->isRunningOpacityAnimationOnCompositor())
-        updateOpacity(renderer()->styleRef());
+    if (!layoutObject()->style()->isRunningOpacityAnimationOnCompositor())
+        updateOpacity(layoutObject()->styleRef());
 
-    if (!renderer()->style()->isRunningFilterAnimationOnCompositor())
-        updateFilters(renderer()->styleRef());
+    if (!layoutObject()->style()->isRunningFilterAnimationOnCompositor())
+        updateFilters(layoutObject()->styleRef());
 
     // We compute everything relative to the enclosing compositing layer.
     IntRect ancestorCompositingBounds;
     if (compositingContainer) {
         ASSERT(compositingContainer->hasCompositedLayerMapping());
         ancestorCompositingBounds = compositingContainer->compositedLayerMapping()->pixelSnappedCompositedBounds();
     }
 
     IntRect localCompositingBounds;
     IntRect relativeCompositingBounds;
@@ skipping 10 matching lines @@
 
     FloatSize contentsSize = relativeCompositingBounds.size();
 
     updateMainGraphicsLayerGeometry(relativeCompositingBounds, localCompositingBounds, graphicsLayerParentLocation);
     updateContentsOffsetInCompositingLayer(snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
     updateSquashingLayerGeometry(offsetFromCompositedAncestor, graphicsLayerParentLocation, m_owningLayer, m_squashedLayers, m_squashingLayer.get(), &m_squashingLayerOffsetFromTransformedAncestor, layersNeedingPaintInvalidation);
 
     // If we have a layer that clips children, position it.
     IntRect clippingBox;
     if (m_childContainmentLayer)
-        clippingBox = clipBox(toLayoutBox(renderer()));
+        clippingBox = clipBox(toLayoutBox(layoutObject()));
 
     updateChildContainmentLayerGeometry(clippingBox, localCompositingBounds);
     updateChildTransformLayerGeometry();
 
     updateMaskLayerGeometry();
     updateTransformGeometry(snappedOffsetFromCompositedAncestor, relativeCompositingBounds);
     updateForegroundLayerGeometry(contentsSize, clippingBox);
     updateBackgroundLayerGeometry(contentsSize);
     updateReflectionLayerGeometry(layersNeedingPaintInvalidation);
     updateScrollingLayerGeometry(localCompositingBounds);
     updateChildClippingMaskLayerGeometry();
 
     if (m_owningLayer.scrollableArea() && m_owningLayer.scrollableArea()->scrollsOverflow())
         m_owningLayer.scrollableArea()->positionOverflowControls();
 
     if (RuntimeEnabledFeatures::cssCompositingEnabled()) {
-        updateLayerBlendMode(renderer()->styleRef());
+        updateLayerBlendMode(layoutObject()->styleRef());
         updateIsRootForIsolatedGroup();
     }
 
     updateContentsRect();
     updateBackgroundColor();
     updateDrawsContent();
     updateContentsOpaque();
     updateAfterPartResize();
     updateRenderingContext();
     updateShouldFlattenTransform();
     updateChildrenTransform();
     updateScrollParent(compositor()->preferCompositingToLCDTextEnabled() ? m_owningLayer.scrollParent() : 0);
     registerScrollingLayers();
 
-    updateScrollBlocksOn(renderer()->styleRef());
+    updateScrollBlocksOn(layoutObject()->styleRef());
 
     updateCompositingReasons();
 }
 
 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 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 (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && layoutObject()->isVideo()) {
+        HTMLVideoElement* videoElement = toHTMLVideoElement(layoutObject()->node());
         if (videoElement->isFullscreen() && !HTMLMediaElement::isMediaStreamURL(videoElement->sourceURL().string()))
             contentsVisible = false;
     }
     m_graphicsLayer->setContentsVisible(contentsVisible);
 
-    m_graphicsLayer->setBackfaceVisibility(renderer()->style()->backfaceVisibility() == BackfaceVisibilityVisible);
+    m_graphicsLayer->setBackfaceVisibility(layoutObject()->style()->backfaceVisibility() == BackfaceVisibilityVisible);
 }
 
 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(toLayoutBox(compositingContainer->renderer()));
+        IntRect clippingBox = clipBox(toLayoutBox(compositingContainer->layoutObject()));
         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();
+        graphicsLayerParentLocation = layoutObject()->view()->documentRect().location();
     }
 
     if (compositingContainer && compositingContainer->needsCompositedScrolling()) {
-        LayoutBox* layoutBox = toLayoutBox(compositingContainer->renderer());
+        LayoutBox* layoutBox = toLayoutBox(compositingContainer->layoutObject());
         IntSize scrollOffset = layoutBox->scrolledContentOffset();
         IntPoint scrollOrigin(layoutBox->borderLeft(), layoutBox->borderTop());
         graphicsLayerParentLocation = scrollOrigin - scrollOffset;
     }
 }
 
 void CompositedLayerMapping::updateAncestorClippingLayerGeometry(const Layer* compositingContainer, const IntPoint& snappedOffsetFromCompositedAncestor, IntPoint& graphicsLayerParentLocation)
 {
     if (!compositingContainer || !m_ancestorClippingLayer)
         return;
@@ skipping 28 matching lines @@
                 LayoutPoint offset;
                 compositingContainer->convertToLayerCoords(compositingStackingContext, offset);
                 FloatSize offsetFromStackingContainer = toFloatSize(FloatPoint(offset));
                 position += offsetFromStackingContainer;
             }
 
             m_overflowControlsClippingLayer->setPosition(position);
         } 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);
+            m_owningLayer.layoutObject()->mapLocalToContainer(compositingStackingContext->layoutObject(), transformState, ApplyContainerFlip);
             transformState.flatten();
             LayoutPoint offsetFromStackingContainer = LayoutPoint(transformState.lastPlanarPoint());
             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)
 {
     if (!m_childContainmentLayer)
         return;
 
     m_childContainmentLayer->setPosition(FloatPoint(clippingBox.location() - localCompositingBounds.location() + roundedIntSize(m_owningLayer.subpixelAccumulation())));
     m_childContainmentLayer->setSize(clippingBox.size());
     m_childContainmentLayer->setOffsetFromRenderer(toIntSize(clippingBox.location()));
-    if (m_childClippingMaskLayer && !m_scrollingLayer && !renderer()->style()->clipPath()) {
+    if (m_childClippingMaskLayer && !m_scrollingLayer && !layoutObject()->style()->clipPath()) {
         m_childClippingMaskLayer->setPosition(m_childContainmentLayer->position());
         m_childClippingMaskLayer->setSize(m_childContainmentLayer->size());
         m_childClippingMaskLayer->setOffsetFromRenderer(m_childContainmentLayer->offsetFromRenderer());
     }
 }
 
 void CompositedLayerMapping::updateChildTransformLayerGeometry()
 {
     if (!m_childTransformLayer)
         return;
-    const IntRect borderBox = toLayoutBox(m_owningLayer.renderer())->pixelSnappedBorderBoxRect();
+    const IntRect borderBox = toLayoutBox(m_owningLayer.layoutObject())->pixelSnappedBorderBoxRect();
     m_childTransformLayer->setSize(borderBox.size());
     m_childTransformLayer->setPosition(FloatPoint(contentOffsetInCompositingLayer()));
 }
 
 void CompositedLayerMapping::updateMaskLayerGeometry()
 {
     if (!m_maskLayer)
         return;
 
     if (m_maskLayer->size() != m_graphicsLayer->size()) {
         m_maskLayer->setSize(m_graphicsLayer->size());
         m_maskLayer->setNeedsDisplay();
     }
     m_maskLayer->setPosition(FloatPoint());
     m_maskLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
 }
 
 void CompositedLayerMapping::updateTransformGeometry(const IntPoint& snappedOffsetFromCompositedAncestor, const IntRect& relativeCompositingBounds)
 {
     if (m_owningLayer.hasTransformRelatedProperty()) {
-        const LayoutRect borderBox = toLayoutBox(renderer())->borderBoxRect();
+        const LayoutRect borderBox = toLayoutBox(layoutObject())->borderBoxRect();
 
         // Get layout bounds in the coords of compositingContainer to match relativeCompositingBounds.
         IntRect layerBounds = pixelSnappedIntRect(toLayoutPoint(m_owningLayer.subpixelAccumulation()), borderBox.size());
         layerBounds.moveBy(snappedOffsetFromCompositedAncestor);
 
         // Update properties that depend on layer dimensions
         FloatPoint3D transformOrigin = computeTransformOrigin(IntRect(IntPoint(), layerBounds.size()));
 
         // |transformOrigin| is in the local space of this layer. layerBounds - relativeCompositingBounds converts to the space of the
         // compositing bounds relative to the composited ancestor. This does not apply to the z direction, since the page is 2D.
@@ skipping 19 matching lines @@
     CompositedLayerMapping* reflectionCompositedLayerMapping = m_owningLayer.reflectionInfo()->reflectionLayer()->compositedLayerMapping();
     reflectionCompositedLayerMapping->updateGraphicsLayerGeometry(&m_owningLayer, &m_owningLayer, layersNeedingPaintInvalidation);
 }
 
 void CompositedLayerMapping::updateScrollingLayerGeometry(const IntRect& localCompositingBounds)
 {
     if (!m_scrollingLayer)
         return;
 
     ASSERT(m_scrollingContentsLayer);
-    LayoutBox* layoutBox = toLayoutBox(renderer());
+    LayoutBox* layoutBox = toLayoutBox(layoutObject());
     IntRect clientBox = enclosingIntRect(layoutBox->clientBoxRect());
     DoubleSize adjustedScrollOffset = m_owningLayer.scrollableArea()->adjustedScrollOffset();
     m_scrollingLayer->setPosition(FloatPoint(clientBox.location() - localCompositingBounds.location() + roundedIntSize(m_owningLayer.subpixelAccumulation())));
     m_scrollingLayer->setSize(clientBox.size());
 
     IntSize oldScrollingLayerOffset = m_scrollingLayer->offsetFromRenderer();
     m_scrollingLayer->setOffsetFromRenderer(-toIntSize(clientBox.location()));
 
-    if (m_childClippingMaskLayer && !renderer()->style()->clipPath()) {
+    if (m_childClippingMaskLayer && !layoutObject()->style()->clipPath()) {
         m_childClippingMaskLayer->setPosition(m_scrollingLayer->position());
         m_childClippingMaskLayer->setSize(m_scrollingLayer->size());
         m_childClippingMaskLayer->setOffsetFromRenderer(toIntSize(clientBox.location()));
     }
 
     bool clientBoxOffsetChanged = oldScrollingLayerOffset != m_scrollingLayer->offsetFromRenderer();
 
     IntSize scrollSize(layoutBox->scrollWidth(), layoutBox->scrollHeight());
     if (scrollSize != m_scrollingContentsLayer->size() || clientBoxOffsetChanged)
         m_scrollingContentsLayer->setNeedsDisplay();
@@ skipping 15 matching lines @@
             m_foregroundLayer->setSize(m_scrollingContentsLayer->size());
         m_foregroundLayer->setNeedsDisplay();
         m_foregroundLayer->setOffsetFromRenderer(m_scrollingContentsLayer->offsetFromRenderer());
     }
 
     updateScrollingBlockSelection();
 }
 
 void CompositedLayerMapping::updateChildClippingMaskLayerGeometry()
 {
-    if (!m_childClippingMaskLayer || !renderer()->style()->clipPath())
+    if (!m_childClippingMaskLayer || !layoutObject()->style()->clipPath())
         return;
-    LayoutBox* layoutBox = toLayoutBox(renderer());
+    LayoutBox* layoutBox = toLayoutBox(layoutObject());
     IntRect clientBox = enclosingIntRect(layoutBox->clientBoxRect());
 
     m_childClippingMaskLayer->setPosition(m_graphicsLayer->position());
     m_childClippingMaskLayer->setSize(m_graphicsLayer->size());
     m_childClippingMaskLayer->setOffsetFromRenderer(toIntSize(clientBox.location()));
 
     // NOTE: also some stuff happening in updateChildContainmentLayerGeometry().
 }
 
 void CompositedLayerMapping::updateForegroundLayerGeometry(const FloatSize& relativeCompositingBoundsSize, const IntRect& clippingBox)
@@ skipping 30 matching lines @@
     // NOTE: there is some more configuring going on in updateScrollingLayerGeometry().
 }
 
 void CompositedLayerMapping::updateBackgroundLayerGeometry(const FloatSize& relativeCompositingBoundsSize)
 {
     if (!m_backgroundLayer)
         return;
 
     FloatSize backgroundSize = relativeCompositingBoundsSize;
     if (backgroundLayerPaintsFixedRootBackground()) {
-        FrameView* frameView = toLayoutView(renderer())->frameView();
+        FrameView* frameView = toLayoutView(layoutObject())->frameView();
         backgroundSize = frameView->visibleContentRect().size();
     }
     m_backgroundLayer->setPosition(FloatPoint());
     if (backgroundSize != m_backgroundLayer->size()) {
         m_backgroundLayer->setSize(backgroundSize);
         m_backgroundLayer->setNeedsDisplay();
     }
     m_backgroundLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
 }
 
@@ skipping 158 matching lines @@
 }
 
 void CompositedLayerMapping::updateDrawsContent()
 {
     bool hasPaintedContent = containsPaintedContent();
     m_graphicsLayer->setDrawsContent(hasPaintedContent);
 
     if (m_scrollingLayer) {
         // m_scrollingLayer never has backing store.
         // m_scrollingContentsLayer only needs backing store if the scrolled contents need to paint.
-        m_scrollingContentsAreEmpty = !m_owningLayer.hasVisibleContent() || !(renderer()->hasBackground() || paintsChildren());
+        m_scrollingContentsAreEmpty = !m_owningLayer.hasVisibleContent() || !(layoutObject()->hasBackground() || paintsChildren());
         m_scrollingContentsLayer->setDrawsContent(!m_scrollingContentsAreEmpty);
         updateScrollingBlockSelection();
     }
 
-    if (hasPaintedContent && isAcceleratedCanvas(renderer())) {
-        CanvasRenderingContext* context = toHTMLCanvasElement(renderer()->node())->renderingContext();
+    if (hasPaintedContent && isAcceleratedCanvas(layoutObject())) {
+        CanvasRenderingContext* context = toHTMLCanvasElement(layoutObject()->node())->renderingContext();
         // Content layer may be null if context is lost.
         if (WebLayer* contentLayer = context->platformLayer()) {
             Color bgColor(Color::transparent);
-            if (contentLayerSupportsDirectBackgroundComposition(renderer())) {
+            if (contentLayerSupportsDirectBackgroundComposition(layoutObject())) {
                 bgColor = rendererBackgroundColor();
                 hasPaintedContent = false;
             }
             contentLayer->setBackgroundColor(bgColor.rgb());
         }
     }
 
     // FIXME: we could refine this to only allocate backings for one of these layers if possible.
     if (m_foregroundLayer)
         m_foregroundLayer->setDrawsContent(hasPaintedContent);
@@ skipping 223 matching lines @@
 
     // 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 (Layer* root = m_owningLayer.renderingContextRoot()) {
-        if (Node* node = root->renderer()->node())
+        if (Node* node = root->layoutObject()->node())
             id = static_cast<int>(WTF::PtrHash<Node*>::hash(node));
     }
 
     UpdateRenderingContextFunctor functor = { id };
     ApplyToGraphicsLayersMode mode = ApplyToAllGraphicsLayers & ~ApplyToSquashingLayer;
     ApplyToGraphicsLayers<UpdateRenderingContextFunctor>(this, functor, mode);
 }
 
 struct UpdateShouldFlattenTransformFunctor {
     void operator() (GraphicsLayer* layer) const { layer->setShouldFlattenTransform(shouldFlatten); }
     bool shouldFlatten;
 };
 
 void CompositedLayerMapping::updateShouldFlattenTransform()
 {
     // All CLM-managed layers that could affect a descendant layer should update their
     // should-flatten-transform value (the other layers' transforms don't matter here).
     UpdateShouldFlattenTransformFunctor functor = { !m_owningLayer.shouldPreserve3D() };
     ApplyToGraphicsLayersMode mode = ApplyToLayersAffectedByPreserve3D;
     ApplyToGraphicsLayers(this, functor, mode);
 
     // Note, if we apply perspective, we have to set should flatten differently
     // so that the transform propagates to child layers correctly.
     if (GraphicsLayer* childTransformLayer = layerForChildrenTransform()) {
         bool hasPerspective = false;
         // FIXME: Can |style| be really null here?
-        if (const LayoutStyle* style = m_owningLayer.renderer()->style())
+        if (const LayoutStyle* style = m_owningLayer.layoutObject()->style())
             hasPerspective = style->hasPerspective();
         if (hasPerspective)
             childTransformLayer->setShouldFlattenTransform(false);
 
         // Note, if the target is the scrolling layer, we need to ensure that the
         // scrolling content layer doesn't flatten the transform. (It would be nice
         // if we could apply transform to the scrolling content layer, but that's
         // too late, we need the children transform to be applied _before_ the
         // scrolling offset.)
         if (childTransformLayer == m_scrollingLayer.get()) {
@@ skipping 39 matching lines @@
         if (m_backgroundLayer) {
             m_backgroundLayer->removeFromParent();
             m_backgroundLayer = nullptr;
 #if !OS(ANDROID)
             m_graphicsLayer->contentLayer()->setDrawCheckerboardForMissingTiles(true);
 #endif
             layerChanged = true;
         }
     }
 
-    if (layerChanged && !m_owningLayer.renderer()->documentBeingDestroyed())
+    if (layerChanged && !m_owningLayer.layoutObject()->documentBeingDestroyed())
         compositor()->rootFixedBackgroundsChanged();
 
     return layerChanged;
 }
 
 bool CompositedLayerMapping::updateMaskLayer(bool needsMaskLayer)
 {
     bool layerChanged = false;
     if (needsMaskLayer) {
         if (!m_maskLayer) {
@@ skipping 189 matching lines @@
         // break here.
         //
         // FIXME: with grouped backings, a composited descendant will have to
         // continue past the grouped (squashed) layers that its parents may
         // contribute to. This whole confusion can be avoided by specifying
         // explicitly the composited ancestor where we would stop accumulating
         // opacity.
         if (curr->compositingState() == PaintsIntoOwnBacking)
             break;
 
-        finalOpacity *= curr->renderer()->opacity();
+        finalOpacity *= curr->layoutObject()->opacity();
     }
 
     return finalOpacity;
 }
 
 Color CompositedLayerMapping::rendererBackgroundColor() const
 {
-    LayoutObject* backgroundRenderer = renderer();
+    LayoutObject* backgroundRenderer = layoutObject();
     if (backgroundRenderer->isDocumentElement())
         backgroundRenderer = backgroundRenderer->rendererForRootBackground();
 
     return backgroundRenderer->resolveColor(CSSPropertyBackgroundColor);
 }
 
 void CompositedLayerMapping::updateBackgroundColor()
 {
     m_graphicsLayer->setBackgroundColor(rendererBackgroundColor());
 }
@@ skipping 36 matching lines @@
     }
 
     return false;
 }
 
 bool CompositedLayerMapping::containsPaintedContent() const
 {
     if (m_owningLayer.isReflection())
         return false;
 
-    if (renderer()->isImage() && isDirectlyCompositedImage())
+    if (layoutObject()->isImage() && isDirectlyCompositedImage())
         return false;
 
-    LayoutObject* layoutObject = renderer();
+    LayoutObject* layoutObject = this->layoutObject();
     // FIXME: we could optimize cases where the image, video or canvas is known to fill the border box entirely,
     // and set background color on the layer in that case, instead of allocating backing store and painting.
-    if (layoutObject->isVideo() && toLayoutVideo(renderer())->shouldDisplayVideo())
+    if (layoutObject->isVideo() && toLayoutVideo(layoutObject)->shouldDisplayVideo())
         return m_owningLayer.hasBoxDecorationsOrBackground();
 
     if (m_owningLayer.hasVisibleBoxDecorations())
         return true;
 
     if (layoutObject->hasMask()) // masks require special treatment
         return true;
 
     if (layoutObject->isReplaced() && !isCompositedPlugin(layoutObject))
         return true;
 
     if (layoutObject->isLayoutRegion())
         return true;
 
     if (layoutObject->node() && layoutObject->node()->isDocumentNode()) {
         // Look to see if the root object has a non-simple background
-        LayoutObject* rootObject = layoutObject->document().documentElement() ? layoutObject->document().documentElement()->renderer() : 0;
+        LayoutObject* rootObject = layoutObject->document().documentElement() ? layoutObject->document().documentElement()->layoutObject() : 0;
         // Reject anything that has a border, a border-radius or outline,
         // or is not a simple background (no background, or solid color).
         if (rootObject && hasBoxDecorationsOrBackgroundImage(rootObject->styleRef()))
             return true;
 
         // Now look at the body's renderer.
         HTMLElement* body = layoutObject->document().body();
-        LayoutObject* bodyObject = isHTMLBodyElement(body) ? body->renderer() : 0;
+        LayoutObject* bodyObject = isHTMLBodyElement(body) ? body->layoutObject() : 0;
         if (bodyObject && hasBoxDecorationsOrBackgroundImage(bodyObject->styleRef()))
             return true;
     }
 
     // FIXME: it's O(n^2). A better solution is needed.
     return paintsChildren();
 }
 
 // An image can be directly compositing if it's the sole content of the layer, and has no box decorations
 // that require painting. Direct compositing saves backing store.
 bool CompositedLayerMapping::isDirectlyCompositedImage() const
 {
-    ASSERT(renderer()->isImage());
+    ASSERT(layoutObject()->isImage());
 
-    LayoutObject* layoutObject = renderer();
+    LayoutObject* layoutObject = this->layoutObject();
     if (m_owningLayer.hasBoxDecorationsOrBackground() || layoutObject->hasClip() || layoutObject->hasClipPath())
         return false;
 
     LayoutImage* imageRenderer = toLayoutImage(layoutObject);
     if (ImageResource* cachedImage = imageRenderer->cachedImage()) {
         if (!cachedImage->hasImage())
             return false;
 
         Image* image = cachedImage->imageForRenderer(imageRenderer);
         return image->isBitmapImage();
     }
 
     return false;
 }
 
 void CompositedLayerMapping::contentChanged(ContentChangeType changeType)
 {
-    if ((changeType == ImageChanged) && renderer()->isImage() && isDirectlyCompositedImage()) {
+    if ((changeType == ImageChanged) && layoutObject()->isImage() && isDirectlyCompositedImage()) {
         updateImageContents();
         return;
     }
 
-    if (changeType == CanvasChanged && isAcceleratedCanvas(renderer())) {
+    if (changeType == CanvasChanged && isAcceleratedCanvas(layoutObject())) {
         m_graphicsLayer->setContentsNeedsDisplay();
         return;
     }
 }
 
 void CompositedLayerMapping::updateImageContents()
 {
-    ASSERT(renderer()->isImage());
-    LayoutImage* imageRenderer = toLayoutImage(renderer());
+    ASSERT(layoutObject()->isImage());
+    LayoutImage* imageRenderer = toLayoutImage(layoutObject());
 
     ImageResource* cachedImage = imageRenderer->cachedImage();
     if (!cachedImage)
         return;
 
     Image* image = cachedImage->imageForRenderer(imageRenderer);
     if (!image)
         return;
 
     // We have to wait until the image is fully loaded before setting it on the layer.
     if (!cachedImage->isLoaded())
         return;
 
     // This is a no-op if the layer doesn't have an inner layer for the image.
     m_graphicsLayer->setContentsToImage(image);
 
-    m_graphicsLayer->setFilterLevel(renderer()->style()->imageRendering() == ImageRenderingPixelated ? SkPaint::kNone_FilterLevel : SkPaint::kLow_FilterLevel);
+    m_graphicsLayer->setFilterLevel(layoutObject()->style()->imageRendering() == ImageRenderingPixelated ? SkPaint::kNone_FilterLevel : SkPaint::kLow_FilterLevel);
 
     // Prevent double-drawing: https://bugs.webkit.org/show_bug.cgi?id=58632
     updateDrawsContent();
 
     // Image animation is "lazy", in that it automatically stops unless someone is drawing
     // the image. So we have to kick the animation each time; this has the downside that the
     // image will keep animating, even if its layer is not visible.
     image->startAnimation();
 }
 
 FloatPoint3D CompositedLayerMapping::computeTransformOrigin(const IntRect& borderBox) const
 {
-    const LayoutStyle& style = renderer()->styleRef();
+    const LayoutStyle& style = layoutObject()->styleRef();
 
     FloatPoint3D origin;
     origin.setX(floatValueForLength(style.transformOriginX(), borderBox.width()));
     origin.setY(floatValueForLength(style.transformOriginY(), borderBox.height()));
     origin.setZ(style.transformOriginZ());
 
     return origin;
 }
 
 // Return the offset from the top-left of this compositing layer at which the
 // renderer's contents are painted.
 LayoutSize CompositedLayerMapping::contentOffsetInCompositingLayer() const
 {
     ASSERT(!m_contentOffsetInCompositingLayerDirty);
     return m_contentOffsetInCompositingLayer;
 }
 
 LayoutRect CompositedLayerMapping::contentsBox() const
 {
-    LayoutRect contentsBox = LayoutRect(contentsRect(renderer()));
+    LayoutRect contentsBox = LayoutRect(contentsRect(layoutObject()));
     contentsBox.move(contentOffsetInCompositingLayer());
     return contentsBox;
 }
 
 bool CompositedLayerMapping::needsToReparentOverflowControls() const
 {
     return m_owningLayer.scrollableArea()
         && m_owningLayer.scrollableArea()->hasOverlayScrollbars()
         && m_owningLayer.scrollableArea()->topmostScrollChild();
 }
@@ skipping 114 matching lines @@
     // FIXME: need to distinguish invalidations for different layers (e.g. the main layer and scrolling layer). crbug.com/416535.
     ApplyToGraphicsLayers(this, [displayItemClient](GraphicsLayer* layer) {
         if (layer->drawsContent())
             layer->invalidateDisplayItemClient(displayItemClient);
     }, ApplyToContentLayers);
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const LayoutObject* layoutObject, const Vector<GraphicsLayerPaintInfo>& layers, unsigned maxSquashedLayerIndex)
 {
     for (size_t i = 0; i < layers.size() && i < maxSquashedLayerIndex; ++i) {
-        if (layoutObject->isDescendantOf(layers[i].renderLayer->renderer()))
+        if (layoutObject->isDescendantOf(layers[i].renderLayer->layoutObject()))
             return &layers[i];
     }
     return 0;
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const LayoutObject* layoutObject, unsigned maxSquashedLayerIndex)
 {
     return CompositedLayerMapping::containingSquashedLayer(layoutObject, m_squashedLayers, maxSquashedLayerIndex);
 }
 
@@ skipping 36 matching lines @@
 
     if (!(paintLayerFlags & PaintLayerPaintingOverflowContents)) {
         LayoutRect bounds = paintInfo.compositedBounds;
         bounds.move(paintInfo.renderLayer->subpixelAccumulation());
         dirtyRect.intersect(pixelSnappedIntRect(bounds));
     } else {
         dirtyRect.move(roundedIntSize(paintInfo.renderLayer->subpixelAccumulation()));
     }
 
 #if ENABLE(ASSERT)
-    paintInfo.renderLayer->renderer()->assertSubtreeIsLaidOut();
+    paintInfo.renderLayer->layoutObject()->assertSubtreeIsLaidOut();
 #endif
 
-    float deviceScaleFactor = blink::deviceScaleFactor(paintInfo.renderLayer->renderer()->frame());
+    float deviceScaleFactor = blink::deviceScaleFactor(paintInfo.renderLayer->layoutObject()->frame());
     context->setDeviceScaleFactor(deviceScaleFactor);
 
     if (paintInfo.renderLayer->compositingState() != PaintsIntoGroupedBacking) {
         // FIXME: GraphicsLayers need a way to split for LayoutRegions.
         LayerPaintingInfo paintingInfo(paintInfo.renderLayer, LayoutRect(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 {
@@ skipping 39 matching lines @@
     scrollbar->paint(&context, transformedClip);
 }
 
 // Up-call from compositing layer drawing callback.
 void CompositedLayerMapping::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase graphicsLayerPaintingPhase, const IntRect& clip)
 {
     // https://code.google.com/p/chromium/issues/detail?id=343772
     DisableCompositingQueryAsserts disabler;
 #if ENABLE(ASSERT)
     // FIXME: once the state machine is ready, this can be removed and we can refer to that instead.
-    if (Page* page = renderer()->frame()->page())
+    if (Page* page = layoutObject()->frame()->page())
         page->setIsPainting(true);
 #endif
-    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Paint", "data", InspectorPaintEvent::data(m_owningLayer.renderer(), LayoutRect(clip), graphicsLayer));
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "Paint", "data", InspectorPaintEvent::data(m_owningLayer.layoutObject(), LayoutRect(clip), graphicsLayer));
 
     PaintLayerFlags paintLayerFlags = 0;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintBackground)
         paintLayerFlags |= PaintLayerPaintingCompositingBackgroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintForeground)
         paintLayerFlags |= PaintLayerPaintingCompositingForegroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintMask)
         paintLayerFlags |= PaintLayerPaintingCompositingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintChildClippingMask)
         paintLayerFlags |= PaintLayerPaintingChildClippingMaskPhase;
@@ skipping 32 matching lines @@
     } else if (graphicsLayer == layerForScrollCorner()) {
         const IntRect& scrollCornerAndResizer = m_owningLayer.scrollableArea()->scrollCornerAndResizerRect();
         context.save();
         context.translate(-scrollCornerAndResizer.x(), -scrollCornerAndResizer.y());
         IntRect transformedClip = clip;
         transformedClip.moveBy(scrollCornerAndResizer.location());
         ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintScrollCorner(&context, IntPoint(), transformedClip);
         ScrollableAreaPainter(*m_owningLayer.scrollableArea()).paintResizer(&context, IntPoint(), transformedClip);
         context.restore();
     }
-    InspectorInstrumentation::didPaint(m_owningLayer.renderer(), graphicsLayer, &context, LayoutRect(clip));
+    InspectorInstrumentation::didPaint(m_owningLayer.layoutObject(), graphicsLayer, &context, LayoutRect(clip));
 #if ENABLE(ASSERT)
-    if (Page* page = renderer()->frame()->page())
+    if (Page* page = layoutObject()->frame()->page())
         page->setIsPainting(false);
 #endif
 }
 
 bool CompositedLayerMapping::isTrackingPaintInvalidations() const
 {
     GraphicsLayerClient* client = compositor();
     return client ? client->isTrackingPaintInvalidations() : false;
 }
 
 #if ENABLE(ASSERT)
 void CompositedLayerMapping::verifyNotPainting()
 {
-    ASSERT(!renderer()->frame()->page() || !renderer()->frame()->page()->isPainting());
+    ASSERT(!layoutObject()->frame()->page() || !layoutObject()->frame()->page()->isPainting());
 }
 #endif
 
 void CompositedLayerMapping::notifyAnimationStarted(const GraphicsLayer*, double monotonicTime, int group)
 {
-    renderer()->node()->document().compositorPendingAnimations().notifyCompositorAnimationStarted(monotonicTime, group);
+    layoutObject()->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(Layer* squashedLayer, const Layer& owningLayer, size_t nextSquashedLayerIndex)
@@ skipping 85 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink