Rename renderer() to layoutObject().

Source/core/layout/compositing/LayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 159 matching lines @@
     while (fullscreenElement && fullscreenElement->isFrameOwnerElement()) {
         contentDocument = toHTMLFrameOwnerElement(fullscreenElement)->contentDocument();
         if (!contentDocument)
             return 0;
         fullscreenElement = Fullscreen::fullscreenElementFrom(*contentDocument);
     }
     // Get the current fullscreen element from the document.
     fullscreenElement = Fullscreen::currentFullScreenElementFrom(*contentDocument);
     if (!isHTMLVideoElement(fullscreenElement))
         return 0;
-    LayoutObject* renderer = fullscreenElement->renderer();
+    LayoutObject* renderer = fullscreenElement->layoutObject();
     if (!renderer)
         return 0;
     return toLayoutVideo(renderer);
 }
 
 void LayerCompositor::updateIfNeededRecursive()
 {
     for (Frame* child = m_layoutView.frameView()->frame().tree().firstChild(); child; child = child->tree().nextSibling()) {
         if (child->isLocalFrame())
             toLocalFrame(child)->contentRenderer()->compositor()->updateIfNeededRecursive();
@@ skipping 201 matching lines @@
         if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled())
             applyOverlayFullscreenVideoAdjustment();
     }
 
     if (m_needsUpdateFixedBackground) {
         rootFixedBackgroundsChanged();
         m_needsUpdateFixedBackground = false;
     }
 
     for (unsigned i = 0; i < layersNeedingPaintInvalidation.size(); i++)
-        forceRecomputePaintInvalidationRectsIncludingNonCompositingDescendants(layersNeedingPaintInvalidation[i]->renderer());
+        forceRecomputePaintInvalidationRectsIncludingNonCompositingDescendants(layersNeedingPaintInvalidation[i]->layoutObject());
 
     // Inform the inspector that the layer tree has changed.
     if (m_layoutView.frame()->isMainFrame())
         InspectorInstrumentation::layerTreeDidChange(m_layoutView.frame());
 }
 
 bool LayerCompositor::allocateOrClearCompositedLayerMapping(Layer* layer, const CompositingStateTransitionType compositedLayerUpdate)
 {
     bool compositedLayerMappingChanged = false;
 
@@ skipping 26 matching lines @@
         }
         break;
     case RemoveOwnCompositedLayerMapping:
     // PutInSquashingLayer means you might have to remove the composited layer mapping first.
     case PutInSquashingLayer:
         if (layer->hasCompositedLayerMapping()) {
             // If we're removing the compositedLayerMapping from a reflection, clear the source GraphicsLayer's pointer to
             // its replica GraphicsLayer. In practice this should never happen because reflectee and reflection
             // are both either composited, or not composited.
             if (layer->isReflection()) {
-                Layer* sourceLayer = toLayoutBoxModelObject(layer->renderer()->parent())->layer();
+                Layer* sourceLayer = toLayoutBoxModelObject(layer->layoutObject()->parent())->layer();
                 if (sourceLayer->hasCompositedLayerMapping()) {
                     ASSERT(sourceLayer->compositedLayerMapping()->mainGraphicsLayer()->replicaLayer() == layer->compositedLayerMapping()->mainGraphicsLayer());
                     sourceLayer->compositedLayerMapping()->mainGraphicsLayer()->setReplicatedByLayer(0);
                 }
             }
 
             layer->clearCompositedLayerMapping();
             compositedLayerMappingChanged = true;
         }
 
         break;
     case RemoveFromSquashingLayer:
     case NoCompositingStateChange:
         // Do nothing.
         break;
     }
 
-    if (compositedLayerMappingChanged && layer->renderer()->isLayoutPart()) {
-        LayerCompositor* innerCompositor = frameContentsCompositor(toLayoutPart(layer->renderer()));
+    if (compositedLayerMappingChanged && layer->layoutObject()->isLayoutPart()) {
+        LayerCompositor* innerCompositor = frameContentsCompositor(toLayoutPart(layer->layoutObject()));
         if (innerCompositor && innerCompositor->staleInCompositingMode())
             innerCompositor->updateRootLayerAttachment();
     }
 
     if (compositedLayerMappingChanged)
         layer->clipper().clearClipRectsIncludingDescendants(PaintingClipRects);
 
     // If a fixed position layer gained/lost a compositedLayerMapping or the reason not compositing it changed,
     // the scrolling coordinator needs to recalculate whether it can do fast scrolling.
     if (compositedLayerMappingChanged) {
         if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
             scrollingCoordinator->frameViewFixedObjectsDidChange(m_layoutView.frameView());
     }
 
     return compositedLayerMappingChanged;
 }
 
 void LayerCompositor::paintInvalidationOnCompositingChange(Layer* layer)
 {
     // If the renderer is not attached yet, no need to issue paint invalidations.
-    if (layer->renderer() != &m_layoutView && !layer->renderer()->parent())
+    if (layer->layoutObject() != &m_layoutView && !layer->layoutObject()->parent())
         return;
 
     // For querying Layer::compositingState()
     // Eager invalidation here is correct, since we are invalidating with respect to the previous frame's
     // compositing state when changing the compositing backing of the layer.
     DisableCompositingQueryAsserts disabler;
     // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
     DisablePaintInvalidationStateAsserts paintInvalidationAssertisabler;
 
-    layer->renderer()->invalidatePaintIncludingNonCompositingDescendants();
+    layer->layoutObject()->invalidatePaintIncludingNonCompositingDescendants();
 }
 
 void LayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
 {
     if (m_overflowControlsHostLayer)
         m_overflowControlsHostLayer->setPosition(contentsOffset);
 }
 
 void LayerCompositor::frameViewDidChangeSize()
 {
@@ skipping 227 matching lines @@
     }
     if (m_containerLayer) {
         FrameView* frameView = m_layoutView.frameView();
         m_containerLayer->setSize(frameView->unscaledVisibleContentSize());
         m_overflowControlsHostLayer->setSize(frameView->unscaledVisibleContentSize(IncludeScrollbars));
     }
 }
 
 void LayerCompositor::updatePotentialCompositingReasonsFromStyle(Layer* layer)
 {
-    layer->setPotentialCompositingReasonsFromStyle(m_compositingReasonFinder.potentialCompositingReasonsFromStyle(layer->renderer()));
+    layer->setPotentialCompositingReasonsFromStyle(m_compositingReasonFinder.potentialCompositingReasonsFromStyle(layer->layoutObject()));
 }
 
 void LayerCompositor::updateDirectCompositingReasons(Layer* layer)
 {
     layer->setCompositingReasons(m_compositingReasonFinder.directReasons(layer), CompositingReasonComboAllDirectReasons);
 }
 
 void LayerCompositor::setOverlayLayer(GraphicsLayer* layer)
 {
     ASSERT(rootGraphicsLayer());
 
     if (layer->parent() != m_overflowControlsHostLayer.get())
         m_overflowControlsHostLayer->addChild(layer);
 }
 
 bool LayerCompositor::canBeComposited(const Layer* layer) const
 {
     return m_hasAcceleratedCompositing && layer->isSelfPaintingLayer() && !layer->subtreeIsInvisible();
 }
 
 // Return true if the given layer is a stacking context and has compositing child
 // layers that it needs to clip. In this case we insert a clipping GraphicsLayer
 // into the hierarchy between this layer and its children in the z-order hierarchy.
 bool LayerCompositor::clipsCompositingDescendants(const Layer* layer) const
 {
-    return layer->hasCompositingDescendant() && layer->renderer()->hasClipOrOverflowClip();
+    return layer->hasCompositingDescendant() && layer->layoutObject()->hasClipOrOverflowClip();
 }
 
 // If an element has composited negative z-index children, those children render in front of the
 // layer background, so we need an extra 'contents' layer for the foreground of the layer
 // object.
 bool LayerCompositor::needsContentsCompositingLayer(const Layer* layer) const
 {
     if (!layer->hasCompositingDescendant())
         return false;
     return layer->stackingNode()->hasNegativeZOrderList();
@@ skipping 377 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink