Rename renderer() to layoutObject().

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 964 matching lines @@
 
     IntRect result = rects[0];
     for (size_t i = 1; i < n; ++i)
         result.unite(rects[i]);
     return result;
 }
 
 IntRect LayoutObject::absoluteFocusRingBoundingBoxRect() const
 {
     Vector<LayoutRect> rects;
-    const LayoutBoxModelObject* container = enclosingLayer()->renderer();
+    const LayoutBoxModelObject* container = enclosingLayer()->layoutObject();
     addFocusRingRects(rects, LayoutPoint(localToContainerPoint(FloatPoint(), container)));
     return container->localToAbsoluteQuad(FloatQuad(unionRect(rects))).enclosingBoundingBox();
 }
 
 FloatRect LayoutObject::absoluteBoundingBoxRectForRange(const Range* range)
 {
     if (!range || !range->startContainer())
         return FloatRect();
 
     range->ownerDocument().updateLayout();
@@ skipping 34 matching lines @@
     return adjustCompositedContainerForSpecialAncestors(enclosingCompositedContainer());
 }
 
 const LayoutBoxModelObject* LayoutObject::enclosingCompositedContainer() const
 {
     LayoutBoxModelObject* container = 0;
     // FIXME: CompositingState is not necessarily up to date for many callers of this function.
     DisableCompositingQueryAsserts disabler;
 
     if (Layer* compositingLayer = enclosingLayer()->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
-        container = compositingLayer->renderer();
+        container = compositingLayer->layoutObject();
     return container;
 }
 
 const LayoutBoxModelObject* LayoutObject::adjustCompositedContainerForSpecialAncestors(const LayoutBoxModelObject* paintInvalidationContainer) const
 {
     if (paintInvalidationContainer)
         return paintInvalidationContainer;
 
     LayoutView* layoutView = view();
     while (layoutView->frame()->ownerLayoutObject())
@@ skipping 721 matching lines @@
         if (RuntimeEnabledFeatures::fastMobileScrollingEnabled()) {
             // On low-powered/mobile devices, preventing blitting on a scroll can cause noticeable delays
             // when scrolling a page with a fixed background image. As an optimization, assuming there are
             // no fixed positoned elements on the page, we can acclerate scrolling (via blitting) if we
             // ignore the CSS property "background-attachment: fixed".
             shouldBlitOnFixedBackgroundImage = true;
         }
         bool newStyleSlowScroll = !shouldBlitOnFixedBackgroundImage && newStyle.hasFixedBackgroundImage();
         bool oldStyleSlowScroll = m_style && !shouldBlitOnFixedBackgroundImage && m_style->hasFixedBackgroundImage();
 
-        bool drawsRootBackground = isDocumentElement() || (isBody() && !rendererHasBackground(document().documentElement()->renderer()));
+        bool drawsRootBackground = isDocumentElement() || (isBody() && !rendererHasBackground(document().documentElement()->layoutObject()));
         if (drawsRootBackground && !shouldBlitOnFixedBackgroundImage) {
             if (view()->compositor()->supportsFixedRootBackgroundCompositing()) {
                 if (newStyleSlowScroll && newStyle.hasEntirelyFixedBackground())
                     newStyleSlowScroll = false;
 
                 if (oldStyleSlowScroll && m_style->hasEntirelyFixedBackground())
                     oldStyleSlowScroll = false;
             }
         }
 
@@ skipping 339 matching lines @@
 void LayoutObject::computeLayerHitTestRects(LayerHitTestRects& layerRects) const
 {
     // Figure out what layer our container is in. Any offset (or new layer) for this
     // renderer within it's container will be applied in addLayerHitTestRects.
     LayoutPoint layerOffset;
     const Layer* currentLayer = 0;
 
     if (!hasLayer()) {
         LayoutObject* container = this->container();
         currentLayer = container->enclosingLayer();
-        if (container && currentLayer->renderer() != container) {
-            layerOffset.move(container->offsetFromAncestorContainer(currentLayer->renderer()));
+        if (container && currentLayer->layoutObject() != container) {
+            layerOffset.move(container->offsetFromAncestorContainer(currentLayer->layoutObject()));
             // If the layer itself is scrolled, we have to undo the subtraction of its scroll
             // offset since we want the offset relative to the scrolling content, not the
             // element itself.
-            if (currentLayer->renderer()->hasOverflowClip())
+            if (currentLayer->layoutObject()->hasOverflowClip())
                 layerOffset.move(currentLayer->layoutBox()->scrolledContentOffset());
         }
     }
 
     this->addLayerHitTestRects(layerRects, currentLayer, layerOffset, LayoutRect());
 }
 
 void LayoutObject::addLayerHitTestRects(LayerHitTestRects& layerRects, const Layer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
 {
     ASSERT(currentLayer);
@@ skipping 61 matching lines @@
 
 LayoutObject* LayoutObject::rendererForRootBackground()
 {
     ASSERT(isDocumentElement());
     if (!hasBackground() && isHTMLHtmlElement(node())) {
         // Locate the <body> element using the DOM. This is easier than trying
         // to crawl around a render tree with potential :before/:after content and
         // anonymous blocks created by inline <body> tags etc. We can locate the <body>
         // render object very easily via the DOM.
         HTMLElement* body = document().body();
-        LayoutObject* bodyObject = isHTMLBodyElement(body) ? body->renderer() : 0;
+        LayoutObject* bodyObject = isHTMLBodyElement(body) ? body->layoutObject() : 0;
         if (bodyObject)
             return bodyObject;
     }
 
     return this;
 }
 
 RespectImageOrientationEnum LayoutObject::shouldRespectImageOrientation() const
 {
     // Respect the image's orientation if it's being used as a full-page image or it's
@@ skipping 489 matching lines @@
 }
 
 PassRefPtr<LayoutStyle> LayoutObject::getUncachedPseudoStyleFromParentOrShadowHost() const
 {
     if (!node())
         return nullptr;
 
     if (ShadowRoot* root = node()->containingShadowRoot()) {
         if (root->type() == ShadowRoot::ClosedShadowRoot) {
             if (Element* shadowHost = node()->shadowHost()) {
-                return shadowHost->renderer()->getUncachedPseudoStyle(PseudoStyleRequest(SELECTION));
+                return shadowHost->layoutObject()->getUncachedPseudoStyle(PseudoStyleRequest(SELECTION));
             }
         }
     }
 
     return getUncachedPseudoStyle(PseudoStyleRequest(SELECTION));
 }
 
 void LayoutObject::getTextDecorations(unsigned decorations, AppliedTextDecoration& underline, AppliedTextDecoration& overline, AppliedTextDecoration& linethrough, bool quirksMode, bool firstlineStyle)
 {
     LayoutObject* curr = this;
@@ skipping 466 matching lines @@
 {
     if (object1) {
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif