Rename renderer() to layoutObject().

Source/core/layout/compositing/CompositingReasonFinder.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/layout/compositing/CompositingReasonFinder.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/dom/Document.h"
 #include "core/frame/FrameView.h"
@@ skipping 32 matching lines @@
 {
     // FIXME: LocalFrame::isMainFrame() is probably better.
     return !m_layoutView.document().ownerElement();
 }
 
 CompositingReasons CompositingReasonFinder::directReasons(const Layer* layer) const
 {
     if (RuntimeEnabledFeatures::slimmingPaintCompositorLayerizationEnabled())
         return CompositingReasonNone;
 
-    ASSERT(potentialCompositingReasonsFromStyle(layer->renderer()) == layer->potentialCompositingReasonsFromStyle());
+    ASSERT(potentialCompositingReasonsFromStyle(layer->layoutObject()) == layer->potentialCompositingReasonsFromStyle());
     CompositingReasons styleDeterminedDirectCompositingReasons = layer->potentialCompositingReasonsFromStyle() & CompositingReasonComboAllDirectStyleDeterminedReasons;
 
     // Apply optimizations for scroll-blocks-on which require comparing style between objects.
-    if ((styleDeterminedDirectCompositingReasons & CompositingReasonScrollBlocksOn) && !requiresCompositingForScrollBlocksOn(layer->renderer()))
+    if ((styleDeterminedDirectCompositingReasons & CompositingReasonScrollBlocksOn) && !requiresCompositingForScrollBlocksOn(layer->layoutObject()))
         styleDeterminedDirectCompositingReasons &= ~CompositingReasonScrollBlocksOn;
 
     return styleDeterminedDirectCompositingReasons | nonStyleDeterminedDirectReasons(layer);
 }
 
 // This information doesn't appear to be incorporated into CompositingReasons.
 bool CompositingReasonFinder::requiresCompositingForScrollableFrame() const
 {
     // Need this done first to determine overflow.
     ASSERT(!m_layoutView.needsLayout());
@@ skipping 71 matching lines @@
 bool CompositingReasonFinder::requiresCompositingForTransform(LayoutObject* renderer) const
 {
     // Note that we ask the renderer if it has a transform, because the style may have transforms,
     // but the renderer may be an inline that doesn't support them.
     return renderer->hasTransformRelatedProperty() && renderer->style()->transform().has3DOperation();
 }
 
 CompositingReasons CompositingReasonFinder::nonStyleDeterminedDirectReasons(const Layer* layer) const
 {
     CompositingReasons directReasons = CompositingReasonNone;
-    LayoutObject* renderer = layer->renderer();
+    LayoutObject* renderer = layer->layoutObject();
 
     if (hasOverflowScrollTrigger()) {
         if (layer->clipParent())
             directReasons |= CompositingReasonOutOfFlowClipping;
 
         if (layer->needsCompositedScrolling())
             directReasons |= CompositingReasonOverflowScrollingTouch;
     }
 
     // Composite |layer| if it is inside of an ancestor scrolling layer, but that
@@ skipping 36 matching lines @@
     // only on the style of their object.  This function runs at CompositingRequirementsUpdater::update
     // time, and so can consider the style of other objects.
     const LayoutStyle& style = renderer->styleRef();
 
     // We should only get here by CompositingReasonScrollBlocksOn being a potential compositing reason.
     ASSERT(style.hasScrollBlocksOn() && !renderer->isDocumentElement());
 
     // scroll-blocks-on style is propagated from the document element to the document.
     ASSERT(!renderer->isLayoutView()
         || !renderer->document().documentElement()
-        || !renderer->document().documentElement()->renderer()
-        || renderer->document().documentElement()->renderer()->style()->scrollBlocksOn() == style.scrollBlocksOn());
+        || !renderer->document().documentElement()->layoutObject()
+        || renderer->document().documentElement()->layoutObject()->style()->scrollBlocksOn() == style.scrollBlocksOn());
 
     // When a scroll occurs, it's the union of all bits set on the target element's containing block
     // chain that determines the behavior.  Thus we really only need a new layer if this object contains
     // additional bits from those set by all objects in it's containing block chain.  But determining
     // this fully is probably more expensive than it's worth.  Instead we just have fast-paths here for
     // the most common cases of unnecessary layer creation.
     // Optimizing this fully would avoid layer explosion in pathological cases like '*' rules.
     // We could consider tracking the current state in CompositingRequirementsUpdater::update.
 
     // Ensure iframes don't get composited when they require no more blocking than their parent.
     if (renderer->isLayoutView()) {
         if (const FrameView* parentFrame = toLayoutView(renderer)->frameView()->parentFrameView()) {
             if (const LayoutView* parentRenderer = parentFrame->layoutView()) {
                 // Does this frame contain only blocks-on bits already present in the parent frame?
                 if (!(style.scrollBlocksOn() & ~parentRenderer->style()->scrollBlocksOn()))
                     return false;
             }
         } else {
             // The root frame will either always already be composited, or compositing will be disabled.
             // Either way, we don't need to require compositing for scroll blocks on.  This avoids
             // enabling compositing by default, and avoids cluttering the root layers compositing reasons.
             return false;
         }
     }
 
     return true;
 }
 
 }