Rename renderer() to layoutObject().

Source/core/layout/LayerClipper.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 54 matching lines @@
         clipRects.setOverflowClipRect(clipRects.posClipRect());
     }
 }
 
 static void applyClipRects(const ClipRectsContext& context, LayoutObject& renderer, LayoutPoint offset, ClipRects& clipRects)
 {
     ASSERT(renderer.hasOverflowClip() || renderer.hasClip());
 
     LayoutView* view = renderer.view();
     ASSERT(view);
-    if (clipRects.fixed() && context.rootLayer->renderer() == view)
+    if (clipRects.fixed() && context.rootLayer->layoutObject() == view)
         offset -= view->frameView()->scrollOffsetForViewportConstrainedObjects();
 
     if (renderer.hasOverflowClip()) {
         ClipRect newOverflowClip = toLayoutBox(renderer).overflowClipRect(offset, context.scrollbarRelevancy);
         newOverflowClip.setHasRadius(renderer.style()->hasBorderRadius());
         clipRects.setOverflowClipRect(intersection(newOverflowClip, clipRects.overflowClipRect()));
         if (renderer.isPositioned())
             clipRects.setPosClipRect(intersection(newOverflowClip, clipRects.posClipRect()));
     }
 
@@ skipping 92 matching lines @@
 LayoutRect LayerClipper::childrenClipRect() const
 {
     // FIXME: border-radius not accounted for.
     // FIXME: Regions not accounted for.
     Layer* clippingRootLayer = clippingRootForPainting();
     LayoutRect layerBounds;
     ClipRect backgroundRect, foregroundRect, outlineRect;
     // Need to use uncached clip rects, because the value of 'dontClipToOverflow' may be different from the painting path (<rdar://problem/11844909>).
     ClipRectsContext context(clippingRootLayer, UncachedClipRects);
     calculateRects(context, LayoutRect(m_renderer.view()->unscaledDocumentRect()), layerBounds, backgroundRect, foregroundRect, outlineRect);
-    return LayoutRect(clippingRootLayer->renderer()->localToAbsoluteQuad(FloatQuad(foregroundRect.rect())).enclosingBoundingBox());
+    return LayoutRect(clippingRootLayer->layoutObject()->localToAbsoluteQuad(FloatQuad(foregroundRect.rect())).enclosingBoundingBox());
 }
 
 LayoutRect LayerClipper::localClipRect() const
 {
     // FIXME: border-radius not accounted for.
     Layer* clippingRootLayer = clippingRootForPainting();
     LayoutRect layerBounds;
     ClipRect backgroundRect, foregroundRect, outlineRect;
     ClipRectsContext context(clippingRootLayer, PaintingClipRects);
     calculateRects(context, LayoutRect(LayoutRect::infiniteIntRect()), layerBounds, backgroundRect, foregroundRect, outlineRect);
@@ skipping 98 matching lines @@
     } else {
         clipRects.reset(LayoutRect(LayoutRect::infiniteIntRect()));
     }
 
     adjustClipRectsForChildren(m_renderer, clipRects);
 
     if ((m_renderer.hasOverflowClip() && (context.respectOverflowClip == RespectOverflowClip || !isClippingRoot)) || m_renderer.hasClip()) {
         // This offset cannot use convertToLayerCoords, because sometimes our rootLayer may be across
         // some transformed layer boundary, for example, in the LayerCompositor overlapMap, where
         // clipRects are needed in view space.
-        applyClipRects(context, m_renderer, roundedLayoutPoint(m_renderer.localToContainerPoint(FloatPoint(), context.rootLayer->renderer())), clipRects);
+        applyClipRects(context, m_renderer, roundedLayoutPoint(m_renderer.localToContainerPoint(FloatPoint(), context.rootLayer->layoutObject())), clipRects);
     }
 }
 
 static ClipRect backgroundClipRectForPosition(const ClipRects& parentRects, EPosition position)
 {
     if (position == FixedPosition)
         return parentRects.fixedClipRect();
 
     if (position == AbsolutePosition)
         return parentRects.posClipRect();
 
     return parentRects.overflowClipRect();
 }
 
 ClipRect LayerClipper::backgroundClipRect(const ClipRectsContext& context) const
 {
     ASSERT(m_renderer.layer()->parent());
     ASSERT(m_renderer.view());
 
     RefPtr<ClipRects> parentClipRects = ClipRects::create();
     if (m_renderer.layer() == context.rootLayer)
         parentClipRects->reset(LayoutRect(LayoutRect::infiniteIntRect()));
     else
         m_renderer.layer()->parent()->clipper().getOrCalculateClipRects(context, *parentClipRects);
 
     ClipRect result = backgroundClipRectForPosition(*parentClipRects, m_renderer.style()->position());
 
     // Note: infinite clipRects should not be scrolled here, otherwise they will accidentally no longer be considered infinite.
-    if (parentClipRects->fixed() && context.rootLayer->renderer() == m_renderer.view() && result != LayoutRect(LayoutRect::infiniteIntRect()))
+    if (parentClipRects->fixed() && context.rootLayer->layoutObject() == m_renderer.view() && result != LayoutRect(LayoutRect::infiniteIntRect()))
         result.move(m_renderer.view()->frameView()->scrollOffsetForViewportConstrainedObjects());
 
     return result;
 }
 
 void LayerClipper::getOrCalculateClipRects(const ClipRectsContext& context, ClipRects& clipRects) const
 {
     if (context.usesCache())
         clipRects = *getClipRects(context);
     else
@@ skipping 18 matching lines @@
         ASSERT(current);
         if (current->transform() || current->isPaintInvalidationContainer())
             return const_cast<Layer*>(current);
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 } // namespace blink