Rename renderer() to layoutObject().

Source/core/paint/BlockPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/BlockPainter.h"
 
 #include "core/editing/Caret.h"
 #include "core/editing/FrameSelection.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 107 matching lines @@
 
 void BlockPainter::paintChildAsInlineBlock(LayoutBox& child, const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     LayoutPoint childPoint = m_layoutBlock.flipForWritingModeForChild(&child, paintOffset);
     if (!child.hasSelfPaintingLayer() && !child.isFloating())
         paintAsInlineBlock(child, paintInfo, childPoint);
 }
 
 void BlockPainter::paintInlineBox(InlineBox& inlineBox, const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    if (!paintInfo.shouldPaintWithinRoot(&inlineBox.renderer()) || (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection))
+    if (!paintInfo.shouldPaintWithinRoot(&inlineBox.layoutObject()) || (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection))
         return;
 
     LayoutPoint childPoint = paintOffset;
-    if (inlineBox.parent()->renderer().style()->isFlippedBlocksWritingMode()) // Faster than calling containingBlock().
-        childPoint = inlineBox.renderer().containingBlock()->flipForWritingModeForChild(&toLayoutBox(inlineBox.renderer()), childPoint);
+    if (inlineBox.parent()->layoutObject().style()->isFlippedBlocksWritingMode()) // Faster than calling containingBlock().
+        childPoint = inlineBox.layoutObject().containingBlock()->flipForWritingModeForChild(&toLayoutBox(inlineBox.layoutObject()), childPoint);
 
-    paintAsInlineBlock(inlineBox.renderer(), paintInfo, childPoint);
+    paintAsInlineBlock(inlineBox.layoutObject(), paintInfo, childPoint);
 }
 
 void BlockPainter::paintAsInlineBlock(LayoutObject& renderer, const PaintInfo& paintInfo, const LayoutPoint& childPoint)
 {
     if (paintInfo.phase != PaintPhaseForeground && paintInfo.phase != PaintPhaseSelection)
         return;
 
     // Paint all phases atomically, as though the element established its own
     // stacking context.  (See Appendix E.2, section 7.2.1.4 on
     // inline block/table/replaced elements in the CSS2.1 specification.)
@@ skipping 328 matching lines @@
         paintInfoForChild.phase = newPhase;
         paintInfoForChild.updatePaintingRootForChildren(&m_layoutBlock);
         m_layoutBlock.paintChildren(paintInfoForChild, paintOffset);
     }
 }
 
 void BlockPainter::paintContinuationOutlines(const PaintInfo& info, const LayoutPoint& paintOffset)
 {
     LayoutInline* inlineCont = m_layoutBlock.inlineElementContinuation();
     if (inlineCont && inlineCont->style()->hasOutline() && inlineCont->style()->visibility() == VISIBLE) {
-        LayoutInline* inlineRenderer = toLayoutInline(inlineCont->node()->renderer());
+        LayoutInline* inlineRenderer = toLayoutInline(inlineCont->node()->layoutObject());
         LayoutBlock* cb = m_layoutBlock.containingBlock();
 
         bool inlineEnclosedInSelfPaintingLayer = false;
         for (LayoutBoxModelObject* box = inlineRenderer; box != cb; box = box->parent()->enclosingBoxModelObject()) {
             if (box->hasSelfPaintingLayer()) {
                 inlineEnclosedInSelfPaintingLayer = true;
                 break;
             }
         }
 
@@ skipping 23 matching lines @@
         LayoutBlock* block = flow->containingBlock();
         for ( ; block && block != &m_layoutBlock; block = block->containingBlock())
             accumulatedPaintOffset.moveBy(block->location());
         ASSERT(block);
         InlinePainter(*flow).paintOutline(info, accumulatedPaintOffset);
     }
 }
 
 
 } // namespace blink