Rename renderer() to layoutObject().

Source/core/layout/Layer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 135 matching lines @@
     if (!renderer->slowFirstChild() && renderer->style()) {
         m_visibleContentStatusDirty = false;
         m_hasVisibleContent = renderer->style()->visibility() == VISIBLE;
     }
 
     updateScrollableArea();
 }
 
 Layer::~Layer()
 {
-    if (renderer()->frame() && renderer()->frame()->page()) {
-        if (ScrollingCoordinator* scrollingCoordinator = renderer()->frame()->page()->scrollingCoordinator())
+    if (layoutObject()->frame() && layoutObject()->frame()->page()) {
+        if (ScrollingCoordinator* scrollingCoordinator = layoutObject()->frame()->page()->scrollingCoordinator())
             scrollingCoordinator->willDestroyLayer(this);
     }
 
     removeFilterInfoIfNeeded();
 
     if (groupedMapping()) {
         DisableCompositingQueryAsserts disabler;
         groupedMapping()->removeLayerFromSquashingGraphicsLayer(this);
         setGroupedMapping(0);
     }
 
     // Child layers will be deleted by their corresponding render objects, so
     // we don't need to delete them ourselves.
 
     clearCompositedLayerMapping(true);
 
     if (m_reflectionInfo)
         m_reflectionInfo->destroy();
 }
 
 String Layer::debugName() const
 {
     if (isReflection()) {
-        return renderer()->parent()->debugName() + " (reflection)";
+        return layoutObject()->parent()->debugName() + " (reflection)";
     }
-    return renderer()->debugName();
+    return layoutObject()->debugName();
 }
 
 LayerCompositor* Layer::compositor() const
 {
-    if (!renderer()->view())
+    if (!layoutObject()->view())
         return 0;
-    return renderer()->view()->compositor();
+    return layoutObject()->view()->compositor();
 }
 
 void Layer::contentChanged(ContentChangeType changeType)
 {
     // updateLayerCompositingState will query compositingReasons for accelerated overflow scrolling.
     // This is tripped by LayoutTests/compositing/content-changed-chicken-egg.html
     DisableCompositingQueryAsserts disabler;
 
     if (changeType == CanvasChanged)
         compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterCompositingInputChange);
 
     if (changeType == CanvasContextChanged) {
         compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterCompositingInputChange);
 
         // Although we're missing test coverage, we need to call
         // GraphicsLayer::setContentsToPlatformLayer with the new platform
         // layer for this canvas.
         // See http://crbug.com/349195
         if (hasCompositedLayerMapping())
             compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
     }
 
     if (m_compositedLayerMapping)
         m_compositedLayerMapping->contentChanged(changeType);
 }
 
 bool Layer::paintsWithFilters() const
 {
-    if (!renderer()->hasFilter())
+    if (!layoutObject()->hasFilter())
         return false;
 
     // https://code.google.com/p/chromium/issues/detail?id=343759
     DisableCompositingQueryAsserts disabler;
     return !m_compositedLayerMapping || compositingState() != PaintsIntoOwnBacking;
 }
 
 LayoutSize Layer::subpixelAccumulation() const
 {
     return m_subpixelAccumulation;
@@ skipping 67 matching lines @@
         // in this case, there is no need to dirty our ancestors further.
         if (layer->isSelfPaintingLayer()) {
             ASSERT(!parent() || parent()->m_hasSelfPaintingLayerDescendantDirty || parent()->m_hasSelfPaintingLayerDescendant);
             break;
         }
     }
 }
 
 bool Layer::scrollsWithViewport() const
 {
-    return renderer()->style()->position() == FixedPosition && renderer()->containerForFixedPosition() == renderer()->view();
+    return layoutObject()->style()->position() == FixedPosition && layoutObject()->containerForFixedPosition() == layoutObject()->view();
 }
 
 bool Layer::scrollsWithRespectTo(const Layer* other) const
 {
     if (scrollsWithViewport() != other->scrollsWithViewport())
         return true;
     return ancestorScrollingLayer() != other->ancestorScrollingLayer();
 }
 
 void Layer::updateLayerPositionsAfterOverflowScroll()
@@ skipping 22 matching lines @@
     }
 }
 
 void Layer::updateTransform(const LayoutStyle* oldStyle, const LayoutStyle& newStyle)
 {
     if (oldStyle && newStyle.transformDataEquivalent(*oldStyle))
         return;
 
     // hasTransform() on the renderer is also true when there is transform-style: preserve-3d or perspective set,
     // so check style too.
-    bool hasTransform = renderer()->hasTransformRelatedProperty() && newStyle.hasTransform();
+    bool hasTransform = layoutObject()->hasTransformRelatedProperty() && newStyle.hasTransform();
     bool had3DTransform = has3DTransform();
 
     bool hadTransform = m_transform;
     if (hasTransform != hadTransform) {
         if (hasTransform)
             m_transform = adoptPtr(new TransformationMatrix);
         else
             m_transform.clear();
 
         // Layers with transforms act as clip rects roots, so clear the cached clip rects here.
         m_clipper.clearClipRectsIncludingDescendants();
     } else if (hasTransform) {
         m_clipper.clearClipRectsIncludingDescendants(AbsoluteClipRects);
     }
 
     updateTransformationMatrix();
 
     if (had3DTransform != has3DTransform())
         dirty3DTransformedDescendantStatus();
 }
 
 static Layer* enclosingLayerForContainingBlock(Layer* layer)
 {
-    if (LayoutObject* containingBlock = layer->renderer()->containingBlock())
+    if (LayoutObject* containingBlock = layer->layoutObject()->containingBlock())
         return containingBlock->enclosingLayer();
     return 0;
 }
 
 Layer* Layer::renderingContextRoot()
 {
     Layer* renderingContext = 0;
 
     if (shouldPreserve3D())
         renderingContext = this;
@@ skipping 56 matching lines @@
     // Otherwise we are paginated by the columns block.
     return true;
 }
 
 // Convert a bounding box from flow thread coordinates, relative to |layer|, to visual coordinates, relative to |ancestorLayer|.
 // See http://www.chromium.org/developers/design-documents/multi-column-layout for more info on these coordinate types.
 static void convertFromFlowThreadToVisualBoundingBoxInAncestor(const Layer* layer, const Layer* ancestorLayer, LayoutRect& rect)
 {
     Layer* paginationLayer = layer->enclosingPaginationLayer();
     ASSERT(paginationLayer);
-    LayoutFlowThread* flowThread = toLayoutFlowThread(paginationLayer->renderer());
+    LayoutFlowThread* flowThread = toLayoutFlowThread(paginationLayer->layoutObject());
 
     // First make the flow thread rectangle relative to the flow thread, not to |layer|.
     LayoutPoint offsetWithinPaginationLayer;
     layer->convertToLayerCoords(paginationLayer, offsetWithinPaginationLayer);
     rect.moveBy(offsetWithinPaginationLayer);
 
     // Then make the rectangle visual, relative to the fragmentation context. Split our box up into
     // the actual fragment boxes that render in the columns/pages and unite those together to get
     // our true bounding box.
     rect = flowThread->fragmentsBoundingBox(rect);
 
     // Finally, make the visual rectangle relative to |ancestorLayer|.
     if (ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
         rect.moveBy(paginationLayer->visualOffsetFromAncestor(ancestorLayer));
         return;
     }
     // The ancestor layer is inside the same pagination layer as |layer|, so we need to subtract
     // the visual distance from the ancestor layer to the pagination layer.
     rect.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
 }
 
 bool Layer::useRegionBasedColumns() const
 {
-    return renderer()->document().regionBasedColumnsEnabled();
+    return layoutObject()->document().regionBasedColumnsEnabled();
 }
 
 void Layer::updatePaginationRecursive(bool needsPaginationUpdate)
 {
     m_isPaginated = false;
     m_enclosingPaginationLayer = 0;
 
-    if (useRegionBasedColumns() && renderer()->isLayoutFlowThread())
+    if (useRegionBasedColumns() && layoutObject()->isLayoutFlowThread())
         needsPaginationUpdate = true;
 
     if (needsPaginationUpdate)
         updatePagination();
 
-    if (renderer()->hasColumns())
+    if (layoutObject()->hasColumns())
         needsPaginationUpdate = true;
 
     for (Layer* child = firstChild(); child; child = child->nextSibling())
         child->updatePaginationRecursive(needsPaginationUpdate);
 }
 
 void Layer::updatePagination()
 {
     bool usesRegionBasedColumns = useRegionBasedColumns();
     if ((!usesRegionBasedColumns && compositingState() != NotComposited) || !parent())
         return; // FIXME: For now the LayoutView can't be paginated.  Eventually printing will move to a model where it is though.
 
     // The main difference between the paginated booleans for the old column code and the new column code
     // is that each paginated layer has to paint on its own with the new code. There is no
     // recurring into child layers. This means that the m_isPaginated bits for the new column code can't just be set on
     // "roots" that get split and paint all their descendants. Instead each layer has to be checked individually and
     // genuinely know if it is going to have to split itself up when painting only its contents (and not any other descendant
     // layers). We track an enclosingPaginationLayer instead of using a simple bit, since we want to be able to get back
     // to that layer easily.
-    if (usesRegionBasedColumns && renderer()->isLayoutFlowThread()) {
+    if (usesRegionBasedColumns && layoutObject()->isLayoutFlowThread()) {
         m_enclosingPaginationLayer = this;
         return;
     }
 
     if (m_stackingNode->isNormalFlowOnly()) {
         if (usesRegionBasedColumns) {
             // Content inside a transform is not considered to be paginated, since we simply
             // paint the transform multiple times in each column, so we don't have to use
             // fragments for the transformed content.
             m_enclosingPaginationLayer = parent()->enclosingPaginationLayer();
             if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransformRelatedProperty())
                 m_enclosingPaginationLayer = 0;
         } else {
-            m_isPaginated = parent()->renderer()->hasColumns();
+            m_isPaginated = parent()->layoutObject()->hasColumns();
         }
         return;
     }
 
     // For the new columns code, we want to walk up our containing block chain looking for an enclosing layer. Once
     // we find one, then we just check its pagination status.
     if (usesRegionBasedColumns) {
-        LayoutView* view = renderer()->view();
+        LayoutView* view = layoutObject()->view();
         LayoutBlock* containingBlock;
-        for (containingBlock = renderer()->containingBlock();
+        for (containingBlock = layoutObject()->containingBlock();
             containingBlock && containingBlock != view;
             containingBlock = containingBlock->containingBlock()) {
             if (containingBlock->hasLayer()) {
                 // Content inside a transform is not considered to be paginated, since we simply
                 // paint the transform multiple times in each column, so we don't have to use
                 // fragments for the transformed content.
                 m_enclosingPaginationLayer = containingBlock->layer()->enclosingPaginationLayer();
                 if (m_enclosingPaginationLayer && m_enclosingPaginationLayer->hasTransformRelatedProperty())
                     m_enclosingPaginationLayer = 0;
                 return;
             }
         }
         return;
     }
 
     // If we're not normal flow, then we need to look for a multi-column object between us and our stacking container.
     LayerStackingNode* ancestorStackingContextNode = m_stackingNode->ancestorStackingContextNode();
     for (Layer* curr = parent(); curr; curr = curr->parent()) {
-        if (curr->renderer()->hasColumns()) {
-            m_isPaginated = checkContainingBlockChainForPagination(renderer(), curr->layoutBox());
+        if (curr->layoutObject()->hasColumns()) {
+            m_isPaginated = checkContainingBlockChainForPagination(layoutObject(), curr->layoutBox());
             return;
         }
         if (curr->stackingNode() == ancestorStackingContextNode)
             return;
     }
 }
 
 void Layer::clearPaginationRecursive()
 {
     m_enclosingPaginationLayer = 0;
@@ skipping 13 matching lines @@
 }
 
 void Layer::mapPointToPaintBackingCoordinates(const LayoutBoxModelObject* paintInvalidationContainer, FloatPoint& point)
 {
     Layer* paintInvalidationLayer = paintInvalidationContainer->layer();
     if (!paintInvalidationLayer->groupedMapping()) {
         point.move(paintInvalidationLayer->compositedLayerMapping()->contentOffsetInCompositingLayer());
         return;
     }
 
-    LayoutBoxModelObject* transformedAncestor = paintInvalidationLayer->enclosingTransformedAncestor()->renderer();
+    LayoutBoxModelObject* transformedAncestor = paintInvalidationLayer->enclosingTransformedAncestor()->layoutObject();
     if (!transformedAncestor)
         return;
 
     // |paintInvalidationContainer| may have a local 2D transform on it, so take that into account when mapping into the space of the
     // transformed ancestor.
     point = paintInvalidationContainer->localToContainerPoint(point, transformedAncestor);
 
     point.moveBy(-paintInvalidationLayer->groupedMapping()->squashingOffsetFromTransformedAncestor());
 }
 
 void Layer::mapRectToPaintBackingCoordinates(const LayoutBoxModelObject* paintInvalidationContainer, LayoutRect& rect)
 {
     Layer* paintInvalidationLayer = paintInvalidationContainer->layer();
     if (!paintInvalidationLayer->groupedMapping()) {
         rect.move(paintInvalidationLayer->compositedLayerMapping()->contentOffsetInCompositingLayer());
         return;
     }
 
-    LayoutBoxModelObject* transformedAncestor = paintInvalidationLayer->enclosingTransformedAncestor()->renderer();
+    LayoutBoxModelObject* transformedAncestor = paintInvalidationLayer->enclosingTransformedAncestor()->layoutObject();
     if (!transformedAncestor)
         return;
 
     // |paintInvalidationContainer| may have a local 2D transform on it, so take that into account when mapping into the space of the
     // transformed ancestor.
     rect = LayoutRect(paintInvalidationContainer->localToContainerQuad(FloatRect(rect), transformedAncestor).boundingBox());
 
     rect.moveBy(-paintInvalidationLayer->groupedMapping()->squashingOffsetFromTransformedAncestor());
 }
 
 void Layer::mapRectToPaintInvalidationBacking(const LayoutObject* layoutObject, const LayoutBoxModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState)
 {
     if (!paintInvalidationContainer->layer()->groupedMapping()) {
         layoutObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
         return;
     }
 
     // This code adjusts the paint invalidation rectangle to be in the space of the transformed ancestor of the grouped (i.e. squashed)
     // layer. This is because all layers that squash together need to issue paint invalidations w.r.t. a single container that is
     // an ancestor of all of them, in order to properly take into account any local transforms etc.
     // FIXME: remove this special-case code that works around the paint invalidation code structure.
     layoutObject->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
 
     mapRectToPaintBackingCoordinates(paintInvalidationContainer, rect);
 }
 
 LayoutRect Layer::computePaintInvalidationRect(const LayoutObject* layoutObject, const Layer* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState)
 {
     if (!paintInvalidationContainer->groupedMapping())
-        return layoutObject->computePaintInvalidationRect(paintInvalidationContainer->renderer(), paintInvalidationState);
+        return layoutObject->computePaintInvalidationRect(paintInvalidationContainer->layoutObject(), paintInvalidationState);
 
-    LayoutRect rect = layoutObject->clippedOverflowRectForPaintInvalidation(paintInvalidationContainer->renderer(), paintInvalidationState);
-    mapRectToPaintBackingCoordinates(paintInvalidationContainer->renderer(), rect);
+    LayoutRect rect = layoutObject->clippedOverflowRectForPaintInvalidation(paintInvalidationContainer->layoutObject(), paintInvalidationState);
+    mapRectToPaintBackingCoordinates(paintInvalidationContainer->layoutObject(), rect);
     return rect;
 }
 
 void Layer::dirtyVisibleContentStatus()
 {
     m_visibleContentStatusDirty = true;
     if (parent())
         parent()->dirtyAncestorChainVisibleDescendantStatus();
 }
 
@@ skipping 15 matching lines @@
         layer->m_visibleDescendantStatusDirty = true;
     }
 }
 
 // FIXME: this is quite brute-force. We could be more efficient if we were to
 // track state and update it as appropriate as changes are made in the Render tree.
 void Layer::updateScrollingStateAfterCompositingChange()
 {
     TRACE_EVENT0("blink", "Layer::updateScrollingStateAfterCompositingChange");
     m_hasVisibleNonLayerContent = false;
-    for (LayoutObject* r = renderer()->slowFirstChild(); r; r = r->nextSibling()) {
+    for (LayoutObject* r = layoutObject()->slowFirstChild(); r; r = r->nextSibling()) {
         if (!r->hasLayer()) {
             m_hasVisibleNonLayerContent = true;
             break;
         }
     }
 
     m_hasNonCompositedChild = false;
     for (Layer* child = firstChild(); child; child = child->nextSibling()) {
         if (child->compositingState() == NotComposited) {
             m_hasNonCompositedChild = true;
@@ skipping 30 matching lines @@
                 m_hasVisibleDescendant = true;
                 break;
             }
         }
 
         m_visibleDescendantStatusDirty = false;
     }
 
     if (m_visibleContentStatusDirty) {
         bool previouslyHasVisibleContent = m_hasVisibleContent;
-        if (renderer()->style()->visibility() == VISIBLE) {
+        if (layoutObject()->style()->visibility() == VISIBLE) {
             m_hasVisibleContent = true;
         } else {
             // layer may be hidden but still have some visible content, check for this
             m_hasVisibleContent = false;
-            LayoutObject* r = renderer()->slowFirstChild();
+            LayoutObject* r = layoutObject()->slowFirstChild();
             while (r) {
                 if (r->style()->visibility() == VISIBLE && !r->hasLayer()) {
                     m_hasVisibleContent = true;
                     break;
                 }
                 LayoutObject* rendererFirstChild = r->slowFirstChild();
                 if (rendererFirstChild && !r->hasLayer()) {
                     r = rendererFirstChild;
                 } else if (r->nextSibling()) {
                     r = r->nextSibling();
                 } else {
                     do {
                         r = r->parent();
-                        if (r == renderer())
+                        if (r == layoutObject())
                             r = 0;
                     } while (r && !r->nextSibling());
                     if (r)
                         r = r->nextSibling();
                 }
             }
         }
         m_visibleContentStatusDirty = false;
 
         if (hasVisibleContent() != previouslyHasVisibleContent) {
@@ skipping 46 matching lines @@
         return has3DTransform() || m_has3DTransformedDescendant;
 
     return has3DTransform();
 }
 
 bool Layer::updateLayerPosition()
 {
     LayoutPoint localPoint;
     LayoutPoint inlineBoundingBoxOffset; // We don't put this into the Layer x/y for inlines, so we need to subtract it out when done.
 
-    if (renderer()->isInline() && renderer()->isLayoutInline()) {
-        LayoutInline* inlineFlow = toLayoutInline(renderer());
+    if (layoutObject()->isInline() && layoutObject()->isLayoutInline()) {
+        LayoutInline* inlineFlow = toLayoutInline(layoutObject());
         IntRect lineBox = inlineFlow->linesBoundingBox();
         m_size = lineBox.size();
         inlineBoundingBoxOffset = lineBox.location();
         localPoint.moveBy(inlineBoundingBoxOffset);
     } else if (LayoutBox* box = layoutBox()) {
         m_size = pixelSnappedIntSize(box->size(), box->location());
         localPoint.moveBy(box->topLeftLocation());
     }
 
-    if (!renderer()->isOutOfFlowPositioned() && !renderer()->isColumnSpanAll() && renderer()->parent()) {
+    if (!layoutObject()->isOutOfFlowPositioned() && !layoutObject()->isColumnSpanAll() && layoutObject()->parent()) {
         // We must adjust our position by walking up the render tree looking for the
         // nearest enclosing object with a layer.
-        LayoutObject* curr = renderer()->parent();
+        LayoutObject* curr = layoutObject()->parent();
         while (curr && !curr->hasLayer()) {
             if (curr->isBox() && !curr->isTableRow()) {
                 // Rows and cells share the same coordinate space (that of the section).
                 // Omit them when computing our xpos/ypos.
                 localPoint.moveBy(toLayoutBox(curr)->topLeftLocation());
             }
             curr = curr->parent();
         }
         if (curr->isBox() && curr->isTableRow()) {
             // Put ourselves into the row coordinate space.
             localPoint.moveBy(-toLayoutBox(curr)->topLeftLocation());
         }
     }
 
     // Subtract our parent's scroll offset.
-    if (renderer()->isOutOfFlowPositioned() && enclosingPositionedAncestor()) {
+    if (layoutObject()->isOutOfFlowPositioned() && enclosingPositionedAncestor()) {
         Layer* positionedParent = enclosingPositionedAncestor();
 
         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
-        if (positionedParent->renderer()->hasOverflowClip()) {
+        if (positionedParent->layoutObject()->hasOverflowClip()) {
             IntSize offset = positionedParent->layoutBox()->scrolledContentOffset();
             localPoint -= offset;
         }
 
-        if (positionedParent->renderer()->isRelPositioned() && positionedParent->renderer()->isLayoutInline()) {
-            LayoutSize offset = toLayoutInline(positionedParent->renderer())->offsetForInFlowPositionedInline(*toLayoutBox(renderer()));
+        if (positionedParent->layoutObject()->isRelPositioned() && positionedParent->layoutObject()->isLayoutInline()) {
+            LayoutSize offset = toLayoutInline(positionedParent->layoutObject())->offsetForInFlowPositionedInline(*toLayoutBox(layoutObject()));
             localPoint += offset;
         }
     } else if (parent()) {
         // FIXME: This code is very wrong, but luckily only needed in the old/current multicol
         // implementation. The compositing system doesn't understand columns and we're hacking
         // around that fact by faking the position of the Layers when we think we'll end up
         // being composited.
         if (hasStyleDeterminedDirectCompositingReasons() && !useRegionBasedColumns()) {
             // FIXME: Composited layers ignore pagination, so about the best we can do is make sure they're offset into the appropriate column.
             // They won't split across columns properly.
-            if (!parent()->renderer()->hasColumns() && parent()->renderer()->isDocumentElement() && renderer()->view()->hasColumns())
-                localPoint += renderer()->view()->columnOffset(localPoint);
+            if (!parent()->layoutObject()->hasColumns() && parent()->layoutObject()->isDocumentElement() && layoutObject()->view()->hasColumns())
+                localPoint += layoutObject()->view()->columnOffset(localPoint);
             else
-                localPoint += parent()->renderer()->columnOffset(localPoint);
+                localPoint += parent()->layoutObject()->columnOffset(localPoint);
         }
 
-        if (parent()->renderer()->hasOverflowClip()) {
+        if (parent()->layoutObject()->hasOverflowClip()) {
             IntSize scrollOffset = parent()->layoutBox()->scrolledContentOffset();
             localPoint -= scrollOffset;
         }
     }
 
     bool positionOrOffsetChanged = false;
-    if (renderer()->isRelPositioned()) {
-        LayoutSize newOffset = renderer()->offsetForInFlowPosition();
+    if (layoutObject()->isRelPositioned()) {
+        LayoutSize newOffset = layoutObject()->offsetForInFlowPosition();
         positionOrOffsetChanged = newOffset != m_offsetForInFlowPosition;
         m_offsetForInFlowPosition = newOffset;
         localPoint.move(m_offsetForInFlowPosition);
     } else {
         m_offsetForInFlowPosition = LayoutSize();
     }
 
     // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
     localPoint.moveBy(-inlineBoundingBoxOffset);
 
     if (m_location != localPoint)
         positionOrOffsetChanged = true;
     m_location = localPoint;
 
 #if ENABLE(ASSERT)
     m_needsPositionUpdate = false;
 #endif
     return positionOrOffsetChanged;
 }
 
 TransformationMatrix Layer::perspectiveTransform() const
 {
-    if (!renderer()->hasTransformRelatedProperty())
+    if (!layoutObject()->hasTransformRelatedProperty())
         return TransformationMatrix();
 
-    const LayoutStyle& style = renderer()->styleRef();
+    const LayoutStyle& style = layoutObject()->styleRef();
     if (!style.hasPerspective())
         return TransformationMatrix();
 
     // Maybe fetch the perspective from the backing?
-    const IntRect borderBox = toLayoutBox(renderer())->pixelSnappedBorderBoxRect();
+    const IntRect borderBox = toLayoutBox(layoutObject())->pixelSnappedBorderBoxRect();
     const float boxWidth = borderBox.width();
     const float boxHeight = borderBox.height();
 
     float perspectiveOriginX = floatValueForLength(style.perspectiveOriginX(), boxWidth);
     float perspectiveOriginY = floatValueForLength(style.perspectiveOriginY(), boxHeight);
 
     // A perspective origin of 0,0 makes the vanishing point in the center of the element.
     // We want it to be in the top-left, so subtract half the height and width.
     perspectiveOriginX -= boxWidth / 2.0f;
     perspectiveOriginY -= boxHeight / 2.0f;
 
     TransformationMatrix t;
     t.translate(perspectiveOriginX, perspectiveOriginY);
     t.applyPerspective(style.perspective());
     t.translate(-perspectiveOriginX, -perspectiveOriginY);
 
     return t;
 }
 
 FloatPoint Layer::perspectiveOrigin() const
 {
-    if (!renderer()->hasTransformRelatedProperty())
+    if (!layoutObject()->hasTransformRelatedProperty())
         return FloatPoint();
 
-    const LayoutRect borderBox = toLayoutBox(renderer())->borderBoxRect();
-    const LayoutStyle& style = renderer()->styleRef();
+    const LayoutRect borderBox = toLayoutBox(layoutObject())->borderBoxRect();
+    const LayoutStyle& style = layoutObject()->styleRef();
 
     return FloatPoint(floatValueForLength(style.perspectiveOriginX(), borderBox.width().toFloat()), floatValueForLength(style.perspectiveOriginY(), borderBox.height().toFloat()));
 }
 
 static inline bool isFixedPositionedContainer(Layer* layer)
 {
     return layer->isRootLayer() || layer->hasTransformRelatedProperty();
 }
 
 Layer* Layer::enclosingPositionedAncestor() const
 {
     Layer* curr = parent();
     while (curr && !curr->isPositionedContainer())
         curr = curr->parent();
 
     return curr;
 }
 
 Layer* Layer::enclosingTransformedAncestor() const
 {
     Layer* curr = parent();
-    while (curr && !curr->isRootLayer() && !curr->renderer()->hasTransformRelatedProperty())
+    while (curr && !curr->isRootLayer() && !curr->layoutObject()->hasTransformRelatedProperty())
         curr = curr->parent();
 
     return curr;
 }
 
 LayoutPoint Layer::computeOffsetFromTransformedAncestor() const
 {
     const AncestorDependentCompositingInputs& properties = ancestorDependentCompositingInputs();
 
     TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
     // FIXME: add a test that checks flipped writing mode and ApplyContainerFlip are correct.
-    renderer()->mapLocalToContainer(properties.transformAncestor ? properties.transformAncestor->renderer() : 0, transformState, ApplyContainerFlip);
+    layoutObject()->mapLocalToContainer(properties.transformAncestor ? properties.transformAncestor->layoutObject() : 0, transformState, ApplyContainerFlip);
     transformState.flatten();
     return LayoutPoint(transformState.lastPlanarPoint());
 }
 
 const Layer* Layer::compositingContainer() const
 {
     if (stackingNode()->isNormalFlowOnly())
         return parent();
     if (LayerStackingNode* ancestorStackingNode = stackingNode()->ancestorStackingContextNode())
         return ancestorStackingNode->layer();
@@ skipping 24 matching lines @@
 
 // Return the enclosingCompositedLayerForPaintInvalidation for the given Layer
 // including crossing frame boundaries.
 Layer* Layer::enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const
 {
     const Layer* layer = this;
     Layer* compositedLayer = 0;
     while (!compositedLayer) {
         compositedLayer = layer->enclosingLayerForPaintInvalidation();
         if (!compositedLayer) {
-            LayoutObject* owner = layer->renderer()->frame()->ownerLayoutObject();
+            LayoutObject* owner = layer->layoutObject()->frame()->ownerLayoutObject();
             if (!owner)
                 break;
             layer = owner->enclosingLayer();
         }
     }
     return compositedLayer;
 }
 
 Layer* Layer::enclosingLayerForPaintInvalidation() const
 {
@@ skipping 38 matching lines @@
     ASSERT(!needsCompositingInputsUpdate());
     m_childNeedsCompositingInputsUpdate = false;
     if (m_scrollableArea)
         m_scrollableArea->updateNeedsCompositedScrolling();
 }
 
 bool Layer::hasNonIsolatedDescendantWithBlendMode() const
 {
     if (descendantDependentCompositingInputs().hasNonIsolatedDescendantWithBlendMode)
         return true;
-    if (renderer()->isSVGRoot())
-        return toLayoutSVGRoot(renderer())->hasNonIsolatedBlendingDescendants();
+    if (layoutObject()->isSVGRoot())
+        return toLayoutSVGRoot(layoutObject())->hasNonIsolatedBlendingDescendants();
     return false;
 }
 
 void Layer::setCompositingReasons(CompositingReasons reasons, CompositingReasons mask)
 {
     if ((compositingReasons() & mask) == (reasons & mask))
         return;
     m_compositingReasons = (reasons & mask) | (compositingReasons() & ~mask);
 }
 
@@ skipping 15 matching lines @@
 
     m_shouldIsolateCompositedDescendants = shouldIsolateCompositedDescendants;
 
     if (hasCompositedLayerMapping())
         compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
 }
 
 bool Layer::hasAncestorWithFilterOutsets() const
 {
     for (const Layer* curr = this; curr; curr = curr->parent()) {
-        LayoutBoxModelObject* renderer = curr->renderer();
+        LayoutBoxModelObject* renderer = curr->layoutObject();
         if (renderer->style()->hasFilterOutsets())
             return true;
     }
     return false;
 }
 
 static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const Layer* layer, const Layer* rootLayer,
     Layer::TransparencyClipBoxBehavior transparencyBehavior, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
 {
     // If we have a mask, then the clip is limited to the border box area (and there is
     // no need to examine child layers).
-    if (!layer->renderer()->hasMask()) {
+    if (!layer->layoutObject()->hasMask()) {
         // Note: we don't have to walk z-order lists since transparent elements always establish
         // a stacking container. This means we can just walk the layer tree directly.
         for (Layer* curr = layer->firstChild(); curr; curr = curr->nextSibling()) {
             if (!layer->reflectionInfo() || layer->reflectionInfo()->reflectionLayer() != curr)
                 clipRect.unite(Layer::transparencyClipBox(curr, rootLayer, transparencyBehavior, Layer::DescendantsOfTransparencyClipBox, subPixelAccumulation, paintBehavior));
         }
     }
 
     // If we have a reflection, then we need to account for that when we push the clip.  Reflect our entire
     // current transparencyClipBox to catch all child layers.
     // FIXME: Accelerated compositing will eventually want to do something smart here to avoid incorporating this
     // size into the parent layer.
-    if (layer->renderer()->hasReflection()) {
+    if (layer->layoutObject()->hasReflection()) {
         LayoutPoint delta;
         layer->convertToLayerCoords(rootLayer, delta);
         clipRect.move(-delta.x(), -delta.y());
         clipRect.unite(layer->layoutBox()->reflectedRect(clipRect));
         clipRect.moveBy(delta);
     }
 }
 
 LayoutRect Layer::transparencyClipBox(const Layer* layer, const Layer* rootLayer, TransparencyClipBoxBehavior transparencyBehavior,
     TransparencyClipBoxMode transparencyMode, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
@@ skipping 14 matching lines @@
         delta.move(subPixelAccumulation);
         IntPoint pixelSnappedDelta = roundedIntPoint(delta);
         TransformationMatrix transform;
         transform.translate(pixelSnappedDelta.x(), pixelSnappedDelta.y());
         transform = transform * *layer->transform();
 
         // We don't use fragment boxes when collecting a transformed layer's bounding box, since it always
         // paints unfragmented.
         LayoutRect clipRect = layer->physicalBoundingBox(layer);
         expandClipRectForDescendantsAndReflection(clipRect, layer, layer, transparencyBehavior, subPixelAccumulation, paintBehavior);
-        clipRect.expand(layer->renderer()->style()->filterOutsets());
+        clipRect.expand(layer->layoutObject()->style()->filterOutsets());
         LayoutRect result = transform.mapRect(clipRect);
         if (!paginationLayer)
             return result;
 
         // We have to break up the transformed extent across our columns.
         // Split our box up into the actual fragment boxes that render in the columns/pages and unite those together to
         // get our true bounding box.
-        LayoutFlowThread* enclosingFlowThread = toLayoutFlowThread(paginationLayer->renderer());
+        LayoutFlowThread* enclosingFlowThread = toLayoutFlowThread(paginationLayer->layoutObject());
         result = enclosingFlowThread->fragmentsBoundingBox(result);
 
         LayoutPoint rootLayerDelta;
         paginationLayer->convertToLayerCoords(rootLayer, rootLayerDelta);
         result.moveBy(rootLayerDelta);
         return result;
     }
 
     LayoutRect clipRect = layer->fragmentsBoundingBox(rootLayer);
     expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, transparencyBehavior, subPixelAccumulation, paintBehavior);
-    clipRect.expand(layer->renderer()->style()->filterOutsets());
+    clipRect.expand(layer->layoutObject()->style()->filterOutsets());
     clipRect.move(subPixelAccumulation);
     return clipRect;
 }
 
 LayoutRect Layer::paintingExtent(const Layer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
 {
     return intersection(transparencyClipBox(this, rootLayer, PaintingTransparencyClipBox, RootOfTransparencyClipBox, subPixelAccumulation, paintBehavior), paintDirtyRect);
 }
 
 void* Layer::operator new(size_t sz)
@@ skipping 60 matching lines @@
     if (oldChild->stackingNode()->isNormalFlowOnly())
         m_stackingNode->dirtyNormalFlowList();
     if (!oldChild->stackingNode()->isNormalFlowOnly() || oldChild->firstChild()) {
         // Dirty the z-order list in which we are contained.  When called via the
         // reattachment process in removeOnlyThisLayer, the layer may already be disconnected
         // from the main layer tree, so we need to null-check the
         // |stackingContext| value.
         oldChild->stackingNode()->dirtyStackingContextZOrderLists();
     }
 
-    if (renderer()->style()->visibility() != VISIBLE)
+    if (layoutObject()->style()->visibility() != VISIBLE)
         dirtyVisibleContentStatus();
 
     oldChild->setPreviousSibling(0);
     oldChild->setNextSibling(0);
     oldChild->m_parent = 0;
 
     dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
     oldChild->updateDescendantDependentFlags();
 
@@ skipping 42 matching lines @@
         current = next;
     }
 
     // Remove us from the parent.
     m_parent->removeChild(this);
     m_renderer->destroyLayer();
 }
 
 void Layer::insertOnlyThisLayer()
 {
-    if (!m_parent && renderer()->parent()) {
-        // We need to connect ourselves when our renderer() has a parent.
+    if (!m_parent && layoutObject()->parent()) {
+        // We need to connect ourselves when our layoutObject() has a parent.
         // Find our enclosingLayer and add ourselves.
-        Layer* parentLayer = renderer()->parent()->enclosingLayer();
+        Layer* parentLayer = layoutObject()->parent()->enclosingLayer();
         ASSERT(parentLayer);
-        Layer* beforeChild = !parentLayer->reflectionInfo() || parentLayer->reflectionInfo()->reflectionLayer() != this ? renderer()->parent()->findNextLayer(parentLayer, renderer()) : 0;
+        Layer* beforeChild = !parentLayer->reflectionInfo() || parentLayer->reflectionInfo()->reflectionLayer() != this ? layoutObject()->parent()->findNextLayer(parentLayer, layoutObject()) : 0;
         parentLayer->addChild(this, beforeChild);
     }
 
     // Remove all descendant layers from the hierarchy and add them to the new position.
-    for (LayoutObject* curr = renderer()->slowFirstChild(); curr; curr = curr->nextSibling())
+    for (LayoutObject* curr = layoutObject()->slowFirstChild(); curr; curr = curr->nextSibling())
         curr->moveLayers(m_parent, this);
 
     // Clear out all the clip rects.
     m_clipper.clearClipRectsIncludingDescendants();
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const Layer* accumulateOffsetTowardsAncestor(const Layer* layer, const Layer* ancestorLayer, LayoutPoint& location)
 {
     ASSERT(ancestorLayer != layer);
 
-    const LayoutBoxModelObject* renderer = layer->renderer();
+    const LayoutBoxModelObject* renderer = layer->layoutObject();
     EPosition position = renderer->style()->position();
 
     // FIXME: Positioning of out-of-flow(fixed, absolute) elements collected in a LayoutFlowThread
     // may need to be revisited in a future patch.
     // If the fixed renderer is inside a LayoutFlowThread, we should not compute location using localToAbsolute,
     // since localToAbsolute maps the coordinates from flow thread to regions coordinates and regions can be
     // positioned in a completely different place in the viewport (LayoutView).
     if (position == FixedPosition && (!ancestorLayer || ancestorLayer == renderer->view()->layer())) {
         // If the fixed layer's container is the root, just add in the offset of the view. We can obtain this by calling
         // localToAbsolute() on the LayoutView.
@@ skipping 125 matching lines @@
     if (ancestorLayer == this)
         return offset;
     Layer* paginationLayer = enclosingPaginationLayer();
     if (paginationLayer == this)
         paginationLayer = parent()->enclosingPaginationLayer();
     if (!paginationLayer) {
         convertToLayerCoords(ancestorLayer, offset);
         return offset;
     }
 
-    LayoutFlowThread* flowThread = toLayoutFlowThread(paginationLayer->renderer());
+    LayoutFlowThread* flowThread = toLayoutFlowThread(paginationLayer->layoutObject());
     convertToLayerCoords(paginationLayer, offset);
     offset = flowThread->flowThreadPointToVisualPoint(offset);
     if (ancestorLayer == paginationLayer)
         return offset;
 
     if (ancestorLayer->enclosingPaginationLayer() != paginationLayer) {
         offset.moveBy(paginationLayer->visualOffsetFromAncestor(ancestorLayer));
     } else {
         // The ancestor layer is also inside the pagination layer, so we need to subtract the visual
         // distance from the ancestor layer to the pagination layer.
         offset.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
     }
     return offset;
 }
 
 void Layer::didUpdateNeedsCompositedScrolling()
 {
     updateSelfPaintingLayer();
 }
 
 void Layer::updateReflectionInfo(const LayoutStyle* oldStyle)
 {
-    ASSERT(!oldStyle || !renderer()->style()->reflectionDataEquivalent(oldStyle));
-    if (renderer()->hasReflection()) {
+    ASSERT(!oldStyle || !layoutObject()->style()->reflectionDataEquivalent(oldStyle));
+    if (layoutObject()->hasReflection()) {
         if (!m_reflectionInfo)
             m_reflectionInfo = adoptPtr(new LayerReflectionInfo(*layoutBox()));
         m_reflectionInfo->updateAfterStyleChange(oldStyle);
     } else if (m_reflectionInfo) {
         m_reflectionInfo->destroy();
         m_reflectionInfo = nullptr;
     }
 }
 
 void Layer::updateStackingNode()
 {
     if (requiresStackingNode())
         m_stackingNode = adoptPtr(new LayerStackingNode(this));
     else
         m_stackingNode = nullptr;
 }
 
 void Layer::updateScrollableArea()
 {
     if (requiresScrollableArea())
         m_scrollableArea = adoptPtr(new LayerScrollableArea(*this));
     else
         m_scrollableArea = nullptr;
 }
 
 bool Layer::hasOverflowControls() const
 {
-    return m_scrollableArea && (m_scrollableArea->hasScrollbar() || m_scrollableArea->scrollCorner() || renderer()->style()->resize() != RESIZE_NONE);
+    return m_scrollableArea && (m_scrollableArea->hasScrollbar() || m_scrollableArea->scrollCorner() || layoutObject()->style()->resize() != RESIZE_NONE);
 }
 
 void Layer::appendSingleFragmentIgnoringPagination(LayerFragments& fragments, const Layer* rootLayer, const LayoutRect& dirtyRect, ClipRectsCacheSlot clipRectsCacheSlot, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy, ShouldRespectOverflowClip respectOverflowClip, const LayoutPoint* offsetFromRoot, const LayoutSize& subPixelAccumulation)
 {
     LayerFragment fragment;
     ClipRectsContext clipRectsContext(rootLayer, clipRectsCacheSlot, inOverlayScrollbarSizeRelevancy, subPixelAccumulation);
     if (respectOverflowClip == IgnoreOverflowClip)
         clipRectsContext.setIgnoreOverflowClip();
     clipper().calculateRects(clipRectsContext, dirtyRect, fragment.layerBounds, fragment.backgroundRect, fragment.foregroundRect, fragment.outlineRect, offsetFromRoot);
     fragments.append(fragment);
@@ skipping 23 matching lines @@
     ClipRect foregroundRectInFlowThread;
     ClipRect outlineRectInFlowThread;
     clipper().calculateRects(paginationClipRectsContext, LayoutRect(LayoutRect::infiniteIntRect()), layerBoundsInFlowThread, backgroundRectInFlowThread, foregroundRectInFlowThread,
         outlineRectInFlowThread, &offsetWithinPaginatedLayer);
 
     // Take our bounding box within the flow thread and clip it.
     LayoutRect layerBoundingBoxInFlowThread = layerBoundingBox ? *layerBoundingBox : physicalBoundingBox(enclosingPaginationLayer(), &offsetWithinPaginatedLayer);
     layerBoundingBoxInFlowThread.intersect(backgroundRectInFlowThread.rect());
 
     // Make the dirty rect relative to the fragmentation context (multicol container, etc.).
-    LayoutFlowThread* enclosingFlowThread = toLayoutFlowThread(enclosingPaginationLayer()->renderer());
+    LayoutFlowThread* enclosingFlowThread = toLayoutFlowThread(enclosingPaginationLayer()->layoutObject());
     LayoutPoint offsetOfPaginationLayerFromRoot; // Visual offset from the root layer to the nearest fragmentation context.
     bool rootLayerIsInsidePaginationLayer = rootLayer->enclosingPaginationLayer() == enclosingPaginationLayer();
     if (rootLayerIsInsidePaginationLayer) {
         // The root layer is in the same fragmentation context as this layer, so we need to look
         // inside it and subtract the offset between the fragmentation context and the root layer.
         offsetOfPaginationLayerFromRoot = -rootLayer->visualOffsetFromAncestor(enclosingPaginationLayer());
     } else {
         offsetOfPaginationLayerFromRoot = enclosingPaginationLayer()->visualOffsetFromAncestor(rootLayer);
     }
     LayoutRect dirtyRectInFlowThread(dirtyRect);
@@ skipping 50 matching lines @@
 bool Layer::hitTest(const HitTestRequest& request, HitTestResult& result)
 {
     return hitTest(request, result.hitTestLocation(), result);
 }
 
 bool Layer::hitTest(const HitTestRequest& request, const HitTestLocation& hitTestLocation, HitTestResult& result)
 {
     ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
     // LayoutView should make sure to update layout before entering hit testing
-    ASSERT(!renderer()->frame()->view()->layoutPending());
-    ASSERT(!renderer()->document().layoutView()->needsLayout());
+    ASSERT(!layoutObject()->frame()->view()->layoutPending());
+    ASSERT(!layoutObject()->document().layoutView()->needsLayout());
 
     // Start with frameVisibleRect to ensure we include the scrollbars.
-    LayoutRect hitTestArea = frameVisibleRect(renderer());
+    LayoutRect hitTestArea = frameVisibleRect(layoutObject());
     if (request.ignoreClipping())
-        hitTestArea.unite(LayoutRect(renderer()->view()->documentRect()));
+        hitTestArea.unite(LayoutRect(layoutObject()->view()->documentRect()));
 
     Layer* insideLayer = hitTestLayer(this, 0, request, result, hitTestArea, hitTestLocation, false);
     if (!insideLayer) {
         // We didn't hit any layer. If we are the root layer and the mouse is -- or just was -- down,
         // return ourselves. We do this so mouse events continue getting delivered after a drag has
         // exited the WebView, and so hit testing over a scrollbar hits the content document.
         // In addtion, it is possible for the mouse to stay in the document but there is no element.
         // At that time, the events of the mouse should be fired.
         LayoutPoint hitPoint = hitTestLocation.point();
         if (!request.isChildFrameHitTest() && ((request.active() || request.release()) || (request.move() && hitTestArea.contains(hitPoint.x(), hitPoint.y()))) && isRootLayer()) {
-            renderer()->updateHitTestResult(result, toLayoutView(renderer())->flipForWritingMode(hitTestLocation.point()));
+            layoutObject()->updateHitTestResult(result, toLayoutView(layoutObject())->flipForWritingMode(hitTestLocation.point()));
             insideLayer = this;
         }
     }
 
     // Now determine if the result is inside an anchor - if the urlElement isn't already set.
     Node* node = result.innerNode();
     if (node && !result.URLElement())
         result.setURLElement(node->enclosingLinkEventParentOrSelf());
 
     // Now return whether we were inside this layer (this will always be true for the root
     // layer).
     return insideLayer;
 }
 
 Node* Layer::enclosingElement() const
 {
-    for (LayoutObject* r = renderer(); r; r = r->parent()) {
+    for (LayoutObject* r = layoutObject(); r; r = r->parent()) {
         if (Node* e = r->node())
             return e;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 bool Layer::isInTopLayer() const
 {
-    Node* node = renderer()->node();
+    Node* node = layoutObject()->node();
     return node && node->isElementNode() && toElement(node)->isInTopLayer();
 }
 
 // Compute the z-offset of the point in the transformState.
 // This is effectively projecting a ray normal to the plane of ancestor, finding where that
 // ray intersects target, and computing the z delta between those two points.
 static double computeZOffset(const HitTestingTransformState& transformState)
 {
     // We got an affine transform, so no z-offset
     if (transformState.m_accumulatedTransform.isAffine())
@@ skipping 19 matching lines @@
         transformState = HitTestingTransformState::create(*containerTransformState);
         convertToLayerCoords(containerLayer, offset);
     } else {
         // If this is the first time we need to make transform state, then base it off of hitTestLocation,
         // which is relative to rootLayer.
         transformState = HitTestingTransformState::create(hitTestLocation.transformedPoint(), hitTestLocation.transformedRect(), FloatQuad(hitTestRect));
         convertToLayerCoords(rootLayer, offset);
     }
     offset.moveBy(translationOffset);
 
-    LayoutObject* containerRenderer = containerLayer ? containerLayer->renderer() : 0;
-    if (renderer()->shouldUseTransformFromContainer(containerRenderer)) {
+    LayoutObject* containerRenderer = containerLayer ? containerLayer->layoutObject() : 0;
+    if (layoutObject()->shouldUseTransformFromContainer(containerRenderer)) {
         TransformationMatrix containerTransform;
-        renderer()->getTransformFromContainer(containerRenderer, toLayoutSize(offset), containerTransform);
+        layoutObject()->getTransformFromContainer(containerRenderer, toLayoutSize(offset), containerTransform);
         transformState->applyTransform(containerTransform, HitTestingTransformState::AccumulateTransform);
     } else {
         transformState->translate(offset.x(), offset.y(), HitTestingTransformState::AccumulateTransform);
     }
 
     return transformState;
 }
 
 
 static bool isHitCandidate(const Layer* hitLayer, bool canDepthSort, double* zOffset, const HitTestingTransformState* transformState)
@@ skipping 61 matching lines @@
     if (appliedTransform) {
         // We computed the correct state in the caller (above code), so just reference it.
         ASSERT(transformState);
         localTransformState = const_cast<HitTestingTransformState*>(transformState);
     } else if (transformState || m_has3DTransformedDescendant || preserves3D()) {
         // We need transform state for the first time, or to offset the container state, so create it here.
         localTransformState = createLocalTransformState(rootLayer, containerLayer, hitTestRect, hitTestLocation, transformState);
     }
 
     // Check for hit test on backface if backface-visibility is 'hidden'
-    if (localTransformState && renderer()->style()->backfaceVisibility() == BackfaceVisibilityHidden) {
+    if (localTransformState && layoutObject()->style()->backfaceVisibility() == BackfaceVisibilityHidden) {
         TransformationMatrix invertedMatrix = localTransformState->m_accumulatedTransform.inverse();
         // If the z-vector of the matrix is negative, the back is facing towards the viewer.
         if (invertedMatrix.m33() < 0)
             return 0;
     }
 
     RefPtr<HitTestingTransformState> unflattenedTransformState = localTransformState;
     if (localTransformState && !preserves3D()) {
         // Keep a copy of the pre-flattening state, for computing z-offsets for the container
         unflattenedTransformState = HitTestingTransformState::create(*localTransformState);
@@ skipping 41 matching lines @@
     }
 
     // Collect the fragments. This will compute the clip rectangles for each layer fragment.
     LayerFragments layerFragments;
     if (appliedTransform)
         appendSingleFragmentIgnoringPagination(layerFragments, rootLayer, hitTestRect, RootRelativeClipRects, IncludeOverlayScrollbarSize);
     else
         collectFragments(layerFragments, rootLayer, hitTestRect, RootRelativeClipRects, IncludeOverlayScrollbarSize);
 
     if (m_scrollableArea && m_scrollableArea->hitTestResizerInFragments(layerFragments, hitTestLocation)) {
-        renderer()->updateHitTestResult(result, hitTestLocation.point());
+        layoutObject()->updateHitTestResult(result, hitTestLocation.point());
         return this;
     }
 
     // Next we want to see if the mouse pos is inside the child LayoutObjects of the layer. Check
     // every fragment in reverse order.
     if (isSelfPaintingLayer()) {
         // Hit test with a temporary HitTestResult, because we only want to commit to 'result' if we know we're frontmost.
         HitTestResult tempResult(result.hitTestLocation());
         bool insideFragmentForegroundRect = false;
         if (hitTestContentsForFragments(layerFragments, request, tempResult, hitTestLocation, HitTestDescendants, insideFragmentForegroundRect)
@@ skipping 125 matching lines @@
         newHitTestLocation = HitTestLocation(localPoint);
 
     // Now do a hit test with the root layer shifted to be us.
     return hitTestLayer(this, containerLayer, request, result, localHitTestRect, newHitTestLocation, true, newTransformState.get(), zOffset);
 }
 
 bool Layer::hitTestContents(const HitTestRequest& request, HitTestResult& result, const LayoutRect& layerBounds, const HitTestLocation& hitTestLocation, HitTestFilter hitTestFilter) const
 {
     ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
-    if (!renderer()->hitTest(request, result, hitTestLocation, toLayoutPoint(layerBounds.location() - layoutBoxLocation()), hitTestFilter)) {
+    if (!layoutObject()->hitTest(request, result, hitTestLocation, toLayoutPoint(layerBounds.location() - layoutBoxLocation()), hitTestFilter)) {
         // It's wrong to set innerNode, but then claim that you didn't hit anything, unless it is
         // a rect-based test.
         ASSERT(!result.innerNode() || (request.listBased() && result.listBasedTestResult().size()));
         return false;
     }
 
     // For positioned generated content, we might still not have a
     // node by the time we get to the layer level, since none of
     // the content in the layer has an element. So just walk up
     // the tree.
@@ skipping 47 matching lines @@
 
     return resultLayer;
 }
 
 Layer* Layer::hitTestPaginatedChildLayer(Layer* childLayer, Layer* rootLayer, const HitTestRequest& request, HitTestResult& result,
     const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset)
 {
     Vector<Layer*> columnLayers;
     LayerStackingNode* ancestorNode = m_stackingNode->isNormalFlowOnly() ? parent()->stackingNode() : m_stackingNode->ancestorStackingContextNode();
     for (Layer* curr = childLayer->parent(); curr; curr = curr->parent()) {
-        if (curr->renderer()->hasColumns() && checkContainingBlockChainForPagination(childLayer->renderer(), curr->layoutBox()))
+        if (curr->layoutObject()->hasColumns() && checkContainingBlockChainForPagination(childLayer->layoutObject(), curr->layoutBox()))
             columnLayers.append(curr);
         if (curr->stackingNode() == ancestorNode)
             break;
     }
 
     ASSERT(columnLayers.size());
     return hitTestChildLayerColumns(childLayer, rootLayer, request, result, hitTestRect, hitTestLocation, transformState, zOffset,
         columnLayers, columnLayers.size() - 1);
 }
 
 Layer* Layer::hitTestChildLayerColumns(Layer* childLayer, Layer* rootLayer, const HitTestRequest& request, HitTestResult& result,
     const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset,
     const Vector<Layer*>& columnLayers, size_t columnIndex)
 {
-    LayoutBlock* columnBlock = toLayoutBlock(columnLayers[columnIndex]->renderer());
+    LayoutBlock* columnBlock = toLayoutBlock(columnLayers[columnIndex]->layoutObject());
 
     ASSERT(columnBlock && columnBlock->hasColumns());
     if (!columnBlock || !columnBlock->hasColumns())
         return 0;
 
     LayoutPoint layerOffset;
     columnBlock->layer()->convertToLayerCoords(rootLayer, layerOffset);
 
     ColumnInfo* colInfo = columnBlock->columnInfo();
     int colCount = columnBlock->columnCount(colInfo);
@@ skipping 109 matching lines @@
     for (Layer* child = firstChild(); child; child = child->nextSibling()) {
         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
         DisablePaintInvalidationStateAsserts disabler;
         child->invalidatePaintForBlockSelectionGaps();
     }
 
     if (m_blockSelectionGapsBounds.isEmpty())
         return;
 
     LayoutRect rect(m_blockSelectionGapsBounds);
-    if (renderer()->hasOverflowClip()) {
+    if (layoutObject()->hasOverflowClip()) {
         LayoutBox* box = layoutBox();
         rect.move(-box->scrolledContentOffset());
         if (!scrollableArea()->usesCompositedScrolling())
             rect.intersect(box->overflowClipRect(LayoutPoint()));
     }
-    if (renderer()->hasClip())
-        rect.intersect(toLayoutBox(renderer())->clipRect(LayoutPoint()));
+    if (layoutObject()->hasClip())
+        rect.intersect(toLayoutBox(layoutObject())->clipRect(LayoutPoint()));
     if (!rect.isEmpty()) {
         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
         DisablePaintInvalidationStateAsserts disabler;
-        renderer()->invalidatePaintRectangle(rect);
+        layoutObject()->invalidatePaintRectangle(rect);
     }
 }
 
 IntRect Layer::blockSelectionGapsBounds() const
 {
-    if (!renderer()->isLayoutBlockFlow())
+    if (!layoutObject()->isLayoutBlockFlow())
         return IntRect();
 
-    LayoutBlockFlow* layoutBlockFlow = toLayoutBlockFlow(renderer());
+    LayoutBlockFlow* layoutBlockFlow = toLayoutBlockFlow(layoutObject());
     LayoutRect gapRects = layoutBlockFlow->selectionGapRectsForPaintInvalidation(layoutBlockFlow);
 
     return pixelSnappedIntRect(gapRects);
 }
 
 bool Layer::hasBlockSelectionGapBounds() const
 {
     // FIXME: it would be more accurate to return !blockSelectionGapsBounds().isEmpty(), but this is impossible
     // at the moment because it causes invalid queries to layout-dependent code (crbug.com/372802).
-    // ASSERT(renderer()->document().lifecycle().state() >= DocumentLifecycle::LayoutClean);
+    // ASSERT(layoutObject()->document().lifecycle().state() >= DocumentLifecycle::LayoutClean);
 
-    if (!renderer()->isLayoutBlock())
+    if (!layoutObject()->isLayoutBlock())
         return false;
 
-    return toLayoutBlock(renderer())->shouldPaintSelectionGaps();
+    return toLayoutBlock(layoutObject())->shouldPaintSelectionGaps();
 }
 
 bool Layer::intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const Layer* rootLayer, const LayoutPoint* offsetFromRoot) const
 {
     // Always examine the canvas and the root.
     // FIXME: Could eliminate the isDocumentElement() check if we fix background painting so that the LayoutView
     // paints the root's background.
-    if (isRootLayer() || renderer()->isDocumentElement())
+    if (isRootLayer() || layoutObject()->isDocumentElement())
         return true;
 
     // If we aren't an inline flow, and our layer bounds do intersect the damage rect, then we
     // can go ahead and return true.
-    LayoutView* view = renderer()->view();
+    LayoutView* view = layoutObject()->view();
     ASSERT(view);
-    if (view && !renderer()->isLayoutInline()) {
+    if (view && !layoutObject()->isLayoutInline()) {
         if (layerBounds.intersects(damageRect))
             return true;
     }
 
     // Otherwise we need to compute the bounding box of this single layer and see if it intersects
     // the damage rect.
     return physicalBoundingBox(rootLayer, offsetFromRoot).intersects(damageRect);
 }
 
 LayoutRect Layer::logicalBoundingBox() const
 {
     // There are three special cases we need to consider.
     // (1) Inline Flows.  For inline flows we will create a bounding box that fully encompasses all of the lines occupied by the
     // inline.  In other words, if some <span> wraps to three lines, we'll create a bounding box that fully encloses the
     // line boxes of all three lines (including overflow on those lines).
     // (2) Left/Top Overflow.  The width/height of layers already includes right/bottom overflow.  However, in the case of left/top
     // overflow, we have to create a bounding box that will extend to include this overflow.
     // (3) Floats.  When a layer has overhanging floats that it paints, we need to make sure to include these overhanging floats
     // as part of our bounding box.  We do this because we are the responsible layer for both hit testing and painting those
     // floats.
     LayoutRect result;
-    if (renderer()->isInline() && renderer()->isLayoutInline()) {
-        result = toLayoutInline(renderer())->linesVisualOverflowBoundingBox();
-    } else if (renderer()->isTableRow()) {
+    if (layoutObject()->isInline() && layoutObject()->isLayoutInline()) {
+        result = toLayoutInline(layoutObject())->linesVisualOverflowBoundingBox();
+    } else if (layoutObject()->isTableRow()) {
         // Our bounding box is just the union of all of our cells' border/overflow rects.
-        for (LayoutObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
+        for (LayoutObject* child = layoutObject()->slowFirstChild(); child; child = child->nextSibling()) {
             if (child->isTableCell()) {
                 LayoutRect bbox = toLayoutBox(child)->borderBoxRect();
                 result.unite(bbox);
                 LayoutRect overflowRect = layoutBox()->visualOverflowRect();
                 if (bbox != overflowRect)
                     result.unite(overflowRect);
             }
         }
     } else {
         LayoutBox* box = layoutBox();
         ASSERT(box);
         result = box->borderBoxRect();
         result.unite(box->visualOverflowRect());
     }
 
-    ASSERT(renderer()->view());
+    ASSERT(layoutObject()->view());
     return result;
 }
 
 static inline LayoutRect flippedLogicalBoundingBox(LayoutRect boundingBox, LayoutObject* renderer)
 {
     LayoutRect result = boundingBox;
     if (renderer->isBox())
         toLayoutBox(renderer)->flipForWritingMode(result);
     else
         renderer->containingBlock()->flipForWritingMode(result);
     return result;
 }
 
 LayoutRect Layer::physicalBoundingBox(const Layer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
 {
-    LayoutRect result = flippedLogicalBoundingBox(logicalBoundingBox(), renderer());
+    LayoutRect result = flippedLogicalBoundingBox(logicalBoundingBox(), layoutObject());
     if (offsetFromRoot)
         result.moveBy(*offsetFromRoot);
     else
         convertToLayerCoords(ancestorLayer, result);
     return result;
 }
 
 LayoutRect Layer::fragmentsBoundingBox(const Layer* ancestorLayer) const
 {
     if (!enclosingPaginationLayer())
         return physicalBoundingBox(ancestorLayer);
 
-    LayoutRect result = flippedLogicalBoundingBox(logicalBoundingBox(), renderer());
+    LayoutRect result = flippedLogicalBoundingBox(logicalBoundingBox(), layoutObject());
     convertFromFlowThreadToVisualBoundingBoxInAncestor(this, ancestorLayer, result);
     return result;
 }
 
 LayoutRect Layer::boundingBoxForCompositingOverlapTest() const
 {
     return overlapBoundsIncludeChildren() ? boundingBoxForCompositing() : fragmentsBoundingBox(this);
 }
 
 static void expandRectForReflectionAndStackingChildren(const Layer* ancestorLayer, Layer::CalculateBoundsOptions options, LayoutRect& result)
@@ skipping 45 matching lines @@
     if (this != ancestorLayer && !hasVisibleContent() && !hasVisibleDescendant())
         return LayoutRect();
 
     // The root layer is always just the size of the document.
     if (isRootLayer())
         return LayoutRect(m_renderer->view()->unscaledDocumentRect());
 
     // The layer created for the LayoutFlowThread is just a helper for painting and hit-testing,
     // and should not contribute to the bounding box. The LayoutMultiColumnSets will contribute
     // the correct size for the rendered content of the multicol container.
-    if (useRegionBasedColumns() && renderer()->isLayoutFlowThread())
+    if (useRegionBasedColumns() && layoutObject()->isLayoutFlowThread())
         return LayoutRect();
 
     LayoutRect result = clipper().localClipRect();
     if (result == LayoutRect::infiniteIntRect()) {
         LayoutPoint origin;
         result = physicalBoundingBox(ancestorLayer, &origin);
 
         const_cast<Layer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
         // Reflections are implemented with Layers that hang off of the reflected layer. However,
@@ skipping 40 matching lines @@
     if (!m_compositedLayerMapping)
         return NotComposited;
 
     return PaintsIntoOwnBacking;
 }
 
 bool Layer::isAllowedToQueryCompositingState() const
 {
     if (gCompositingQueryMode == CompositingQueriesAreAllowed)
         return true;
-    return renderer()->document().lifecycle().state() >= DocumentLifecycle::InCompositingUpdate;
+    return layoutObject()->document().lifecycle().state() >= DocumentLifecycle::InCompositingUpdate;
 }
 
 CompositedLayerMapping* Layer::compositedLayerMapping() const
 {
     ASSERT(isAllowedToQueryCompositingState());
     return m_compositedLayerMapping.get();
 }
 
 GraphicsLayer* Layer::graphicsLayerBacking() const
 {
@@ skipping 79 matching lines @@
 bool Layer::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     if (!isSelfPaintingLayer() && !hasSelfPaintingLayerDescendant())
         return false;
 
     if (paintsWithTransparency(PaintBehaviorNormal))
         return false;
 
     // We can't use hasVisibleContent(), because that will be true if our renderer is hidden, but some child
     // is visible and that child doesn't cover the entire rect.
-    if (renderer()->style()->visibility() != VISIBLE)
+    if (layoutObject()->style()->visibility() != VISIBLE)
         return false;
 
-    if (paintsWithFilters() && renderer()->style()->filter().hasFilterThatAffectsOpacity())
+    if (paintsWithFilters() && layoutObject()->style()->filter().hasFilterThatAffectsOpacity())
         return false;
 
     // FIXME: Handle simple transforms.
     if (paintsWithTransform(PaintBehaviorNormal))
         return false;
 
     // FIXME: Remove this check.
     // This function should not be called when layer-lists are dirty.
     // It is somehow getting triggered during style update.
     if (m_stackingNode->zOrderListsDirty() || m_stackingNode->normalFlowListDirty())
         return false;
 
     // FIXME: We currently only check the immediate renderer,
     // which will miss many cases.
-    if (renderer()->backgroundIsKnownToBeOpaqueInRect(localRect))
+    if (layoutObject()->backgroundIsKnownToBeOpaqueInRect(localRect))
         return true;
 
     // We can't consult child layers if we clip, since they might cover
     // parts of the rect that are clipped out.
-    if (renderer()->hasOverflowClip())
+    if (layoutObject()->hasOverflowClip())
         return false;
 
     return childBackgroundIsKnownToBeOpaqueInRect(localRect);
 }
 
 bool Layer::childBackgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) const
 {
     LayerStackingNodeReverseIterator revertseIterator(*m_stackingNode, PositiveZOrderChildren | NormalFlowChildren | NegativeZOrderChildren);
     while (LayerStackingNode* child = revertseIterator.next()) {
         const Layer* childLayer = child->layer();
@@ skipping 10 matching lines @@
         childLocalRect.moveBy(-childOffset);
 
         if (childLayer->backgroundIsKnownToBeOpaqueInRect(childLocalRect))
             return true;
     }
     return false;
 }
 
 bool Layer::shouldBeSelfPaintingLayer() const
 {
-    if (renderer()->isLayoutPart() && toLayoutPart(renderer())->requiresAcceleratedCompositing())
+    if (layoutObject()->isLayoutPart() && toLayoutPart(layoutObject())->requiresAcceleratedCompositing())
         return true;
     return m_layerType == NormalLayer
         || (m_scrollableArea && m_scrollableArea->hasOverlayScrollbars())
         || needsCompositedScrolling();
 }
 
 void Layer::updateSelfPaintingLayer()
 {
     bool isSelfPaintingLayer = shouldBeSelfPaintingLayer();
     if (this->isSelfPaintingLayer() == isSelfPaintingLayer)
         return;
 
     m_isSelfPaintingLayer = isSelfPaintingLayer;
 
     if (parent())
         parent()->dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 }
 
 bool Layer::hasNonEmptyChildRenderers() const
 {
     // Some HTML can cause whitespace text nodes to have renderers, like:
     // <div>
     // <img src=...>
     // </div>
     // so test for 0x0 RenderTexts here
-    for (LayoutObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
+    for (LayoutObject* child = layoutObject()->slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->hasLayer()) {
             if (child->isLayoutInline() || !child->isBox())
                 return true;
 
             if (toLayoutBox(child)->size().width() > 0 || toLayoutBox(child)->size().height() > 0)
                 return true;
         }
     }
     return false;
 }
 
 bool Layer::hasBoxDecorationsOrBackground() const
 {
-    return renderer()->style()->hasBoxDecorations() || renderer()->style()->hasBackground();
+    return layoutObject()->style()->hasBoxDecorations() || layoutObject()->style()->hasBackground();
 }
 
 bool Layer::hasVisibleBoxDecorations() const
 {
     if (!hasVisibleContent())
         return false;
 
     return hasBoxDecorationsOrBackground() || hasOverflowControls();
 }
 
@@ skipping 19 matching lines @@
     // update.
 
     if (!diff.hasAtMostPropertySpecificDifferences(StyleDifference::TransformChanged | StyleDifference::OpacityChanged))
         return false;
     // The potentialCompositingReasonsFromStyle could have changed without
     // a corresponding StyleDifference if an animation started or ended.
     if (m_potentialCompositingReasonsFromStyle != oldPotentialCompositingReasonsFromStyle)
         return false;
     // We could add support for reflections if we updated the transform on
     // the reflection layers.
-    if (renderer()->hasReflection())
+    if (layoutObject()->hasReflection())
         return false;
     // If we're unwinding a scheduleSVGFilterLayerUpdateHack(), then we can't
     // perform a direct compositing update because the filters code is going
     // to produce different output this time around. We can remove this code
     // once we fix the chicken/egg bugs in the filters code and delete the
     // scheduleSVGFilterLayerUpdateHack().
-    if (renderer()->node() && renderer()->node()->svgFilterNeedsLayerUpdate())
+    if (layoutObject()->node() && layoutObject()->node()->svgFilterNeedsLayerUpdate())
         return false;
     if (!m_compositedLayerMapping)
         return false;
 
     // To cut off almost all the work in the compositing update for
     // this case, we treat inline transforms has having assumed overlap
     // (similar to how we treat animated transforms). Notice that we read
     // CompositingReasonInlineTransform from the m_compositingReasons, which
     // means that the inline transform actually triggered assumed overlap in
     // the overlap map.
     if (diff.transformChanged() && !(m_compositingReasons & CompositingReasonInlineTransform))
         return false;
 
     // We composite transparent Layers differently from non-transparent
     // Layers even when the non-transparent Layers are already a
     // stacking context.
     if (diff.opacityChanged() && m_renderer->style()->hasOpacity() != oldStyle->hasOpacity())
         return false;
 
-    updateTransform(oldStyle, renderer()->styleRef());
+    updateTransform(oldStyle, layoutObject()->styleRef());
 
     // FIXME: Consider introducing a smaller graphics layer update scope
     // that just handles transforms and opacity. GraphicsLayerUpdateLocal
     // will also program bounds, clips, and many other properties that could
     // not possibly have changed.
     m_compositedLayerMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
     compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterGeometryChange);
     return true;
 }
 
 void Layer::styleChanged(StyleDifference diff, const LayoutStyle* oldStyle)
 {
     if (attemptDirectCompositingUpdate(diff, oldStyle))
         return;
 
     m_stackingNode->updateIsNormalFlowOnly();
     m_stackingNode->updateStackingNodesAfterStyleChange(oldStyle);
 
     if (m_scrollableArea)
         m_scrollableArea->updateAfterStyleChange(oldStyle);
 
     // Overlay scrollbars can make this layer self-painting so we need
     // to recompute the bit once scrollbars have been updated.
     updateSelfPaintingLayer();
 
-    if (!oldStyle || !renderer()->style()->reflectionDataEquivalent(oldStyle)) {
+    if (!oldStyle || !layoutObject()->style()->reflectionDataEquivalent(oldStyle)) {
         ASSERT(!oldStyle || diff.needsFullLayout());
         updateReflectionInfo(oldStyle);
     }
 
     updateDescendantDependentFlags();
 
-    updateTransform(oldStyle, renderer()->styleRef());
-    updateFilters(oldStyle, renderer()->styleRef());
+    updateTransform(oldStyle, layoutObject()->styleRef());
+    updateFilters(oldStyle, layoutObject()->styleRef());
 
     setNeedsCompositingInputsUpdate();
 }
 
 bool Layer::scrollsOverflow() const
 {
     if (LayerScrollableArea* scrollableArea = this->scrollableArea())
         return scrollableArea->scrollsOverflow();
 
     return false;
 }
 
 FilterOperations Layer::computeFilterOperations(const LayoutStyle& style)
 {
     const FilterOperations& filters = style.filter();
     if (filters.hasReferenceFilter()) {
         for (size_t i = 0; i < filters.size(); ++i) {
             FilterOperation* filterOperation = filters.operations().at(i).get();
             if (filterOperation->type() != FilterOperation::REFERENCE)
                 continue;
             ReferenceFilterOperation* referenceOperation = toReferenceFilterOperation(filterOperation);
             // FIXME: Cache the ReferenceFilter if it didn't change.
             RefPtrWillBeRawPtr<ReferenceFilter> referenceFilter = ReferenceFilter::create(style.effectiveZoom());
-            referenceFilter->setLastEffect(ReferenceFilterBuilder::build(referenceFilter.get(), renderer(), referenceFilter->sourceGraphic(),
+            referenceFilter->setLastEffect(ReferenceFilterBuilder::build(referenceFilter.get(), layoutObject(), referenceFilter->sourceGraphic(),
                 referenceOperation));
             referenceOperation->setFilter(referenceFilter.release());
         }
     }
 
     return filters;
 }
 
 void Layer::updateOrRemoveFilterClients()
 {
     if (!hasFilter()) {
         removeFilterInfoIfNeeded();
         return;
     }
 
-    if (renderer()->style()->filter().hasReferenceFilter())
-        ensureFilterInfo()->updateReferenceFilterClients(renderer()->style()->filter());
+    if (layoutObject()->style()->filter().hasReferenceFilter())
+        ensureFilterInfo()->updateReferenceFilterClients(layoutObject()->style()->filter());
     else if (hasFilterInfo())
         filterInfo()->removeReferenceFilterClients();
 }
 
 void Layer::updateOrRemoveFilterEffectRenderer()
 {
     // FilterEffectRenderer is only used to render the filters in software mode,
     // so we always need to run updateOrRemoveFilterEffectRenderer after the composited
     // mode might have changed for this layer.
     if (!paintsWithFilters()) {
         // Don't delete the whole filter info here, because we might use it
         // for loading CSS shader files.
         if (LayerFilterInfo* filterInfo = this->filterInfo())
             filterInfo->setRenderer(nullptr);
 
         return;
     }
 
     LayerFilterInfo* filterInfo = ensureFilterInfo();
-    if (!filterInfo->renderer()) {
+    if (!filterInfo->layoutObject()) {
         RefPtrWillBeRawPtr<FilterEffectRenderer> filterRenderer = FilterEffectRenderer::create();
         filterInfo->setRenderer(filterRenderer.release());
     }
 
     // If the filter fails to build, remove it from the layer. It will still attempt to
     // go through regular processing (e.g. compositing), but never apply anything.
-    if (!filterInfo->renderer()->build(renderer(), computeFilterOperations(renderer()->styleRef())))
+    if (!filterInfo->layoutObject()->build(layoutObject(), computeFilterOperations(layoutObject()->styleRef())))
         filterInfo->setRenderer(nullptr);
 }
 
 void Layer::filterNeedsPaintInvalidation()
 {
     {
-        DeprecatedScheduleStyleRecalcDuringLayout marker(renderer()->document().lifecycle());
+        DeprecatedScheduleStyleRecalcDuringLayout marker(layoutObject()->document().lifecycle());
         // It's possible for scheduleSVGFilterLayerUpdateHack to schedule a style recalc, which
         // is a problem because this function can be called while performing layout.
         // Presumably this represents an illegal data flow of layout or compositing
         // information into the style system.
-        toElement(renderer()->node())->scheduleSVGFilterLayerUpdateHack();
+        toElement(layoutObject()->node())->scheduleSVGFilterLayerUpdateHack();
     }
 
-    renderer()->setShouldDoFullPaintInvalidation();
+    layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void Layer::addLayerHitTestRects(LayerHitTestRects& rects) const
 {
     computeSelfHitTestRects(rects);
     for (Layer* child = firstChild(); child; child = child->nextSibling())
         child->addLayerHitTestRects(rects);
 }
 
 void Layer::computeSelfHitTestRects(LayerHitTestRects& rects) const
@@ skipping 22 matching lines @@
             }
         } else {
             rect.append(logicalBoundingBox());
             rects.set(this, rect);
         }
     }
 }
 
 void Layer::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
 {
-    renderer()->setShouldDoFullPaintInvalidation();
+    layoutObject()->setShouldDoFullPaintInvalidation();
 
     // Disable for reading compositingState() in isPaintInvalidationContainer() below.
     DisableCompositingQueryAsserts disabler;
 
     for (Layer* child = firstChild(); child; child = child->nextSibling()) {
         if (!child->isPaintInvalidationContainer())
             child->setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
     }
 }
 
 DisableCompositingQueryAsserts::DisableCompositingQueryAsserts()
     : m_disabler(gCompositingQueryMode, CompositingQueriesAreAllowed) { }
 
 } // namespace blink
 
 #ifndef NDEBUG
 void showLayerTree(const blink::Layer* layer)
 {
     if (!layer)
         return;
 
-    if (blink::LocalFrame* frame = layer->renderer()->frame()) {
+    if (blink::LocalFrame* frame = layer->layoutObject()->frame()) {
         WTF::String output = externalRepresentation(frame, blink::LayoutAsTextShowAllLayers | blink::LayoutAsTextShowLayerNesting | blink::LayoutAsTextShowCompositedLayers | blink::LayoutAsTextShowAddresses | blink::LayoutAsTextShowIDAndClass | blink::LayoutAsTextDontUpdateLayout | blink::LayoutAsTextShowLayoutState);
         fprintf(stderr, "%s\n", output.utf8().data());
     }
 }
 
 void showLayerTree(const blink::LayoutObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif