Rename renderer() to layoutObject().

Source/web/LinkHighlight.cpp

 /*
  * Copyright (C) 2012 Google 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
@@ skipping 148 matching lines @@
     // FIXME: Make this create rounded quad-paths, just like the axis-aligned case.
     path.moveTo(quad.p1());
     path.addLineTo(quad.p2());
     path.addLineTo(quad.p3());
     path.addLineTo(quad.p4());
     path.closeSubpath();
 }
 
 void LinkHighlight::computeQuads(const Node& node, Vector<FloatQuad>& outQuads) const
 {
-    if (!node.renderer())
+    if (!node.layoutObject())
         return;
 
-    LayoutObject* renderer = node.renderer();
+    LayoutObject* renderer = node.layoutObject();
 
     // For inline elements, absoluteQuads will return a line box based on the line-height
     // and font metrics, which is technically incorrect as replaced elements like images
     // should use their intristic height and expand the linebox  as needed. To get an
     // appropriately sized highlight we descend into the children and have them add their
     // boxes.
     if (renderer->isLayoutInline()) {
         for (Node* child = NodeRenderingTraversal::firstChild(node); child; child = NodeRenderingTraversal::nextSibling(*child))
             computeQuads(*child, outQuads);
     } else {
         // FIXME: this does not need to be absolute, just in the paint invalidation container's space.
         renderer->absoluteQuads(outQuads);
     }
 }
 
 bool LinkHighlight::computeHighlightLayerPathAndPosition(const LayoutBoxModelObject* paintInvalidationContainer)
 {
-    if (!m_node || !m_node->renderer() || !m_currentGraphicsLayer)
+    if (!m_node || !m_node->layoutObject() || !m_currentGraphicsLayer)
         return false;
     ASSERT(paintInvalidationContainer);
 
     // FIXME: This is defensive code to avoid crashes such as those described in
     // crbug.com/440887. This should be cleaned up once we fix the root cause of
     // of the paint invalidation container not being composited.
     if (!paintInvalidationContainer->layer()->compositedLayerMapping() && !paintInvalidationContainer->layer()->groupedMapping())
         return false;
 
     // Get quads for node in absolute coordinates.
     Vector<FloatQuad> quads;
     computeQuads(*m_node, quads);
     ASSERT(quads.size());
     Path newPath;
 
     FloatPoint positionAdjustForCompositedScrolling = IntPoint(m_currentGraphicsLayer->offsetFromRenderer());
 
     for (size_t quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
         FloatQuad absoluteQuad = quads[quadIndex];
 
         // FIXME: this hack should not be necessary. It's a consequence of the fact that composited layers for scrolling are represented
         // differently in Blink than other composited layers.
-        if (paintInvalidationContainer->layer()->needsCompositedScrolling() && m_node->renderer() != paintInvalidationContainer)
+        if (paintInvalidationContainer->layer()->needsCompositedScrolling() && m_node->layoutObject() != paintInvalidationContainer)
             absoluteQuad.move(-positionAdjustForCompositedScrolling.x(), -positionAdjustForCompositedScrolling.y());
 
         // Transform node quads in target absolute coords to local coordinates in the compositor layer.
         FloatQuad transformedQuad;
-        convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), paintInvalidationContainer, transformedQuad);
+        convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->layoutObject(), paintInvalidationContainer, transformedQuad);
 
         // FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
         // we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
         // links: these should ideally be merged into a single rect before creating the path, but that's
         // another CL.
         if (quads.size() == 1 && transformedQuad.isRectilinear()
             && !m_owningWebViewImpl->settingsImpl()->mockGestureTapHighlightsEnabled()) {
             FloatSize rectRoundingRadii(3, 3);
             newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
         } else
             addQuadToPath(transformedQuad, newPath);
     }
 
     FloatRect boundingRect = newPath.boundingRect();
     newPath.translate(-toFloatSize(boundingRect.location()));
 
     bool pathHasChanged = !(newPath == m_path);
     if (pathHasChanged) {
         m_path = newPath;
         m_contentLayer->layer()->setBounds(enclosingIntRect(boundingRect).size());
     }
 
     m_contentLayer->layer()->setPosition(boundingRect.location());
 
     return pathHasChanged;
 }
 
 void LinkHighlight::paintContents(WebCanvas* canvas, const WebRect& webClipRect, WebContentLayerClient::PaintingControlSetting paintingControl)
 {
-    if (!m_node || !m_node->renderer())
+    if (!m_node || !m_node->layoutObject())
         return;
 
     GraphicsContext::DisabledMode disabledMode = GraphicsContext::NothingDisabled;
     if (paintingControl == WebContentLayerClient::DisplayListConstructionDisabled)
         disabledMode = GraphicsContext::FullyDisabled;
 
     OwnPtr<GraphicsContext> graphicsContext;
     OwnPtr<DisplayItemList> displayItemList;
     if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
         displayItemList = DisplayItemList::create();
         graphicsContext = adoptPtr(new GraphicsContext(nullptr, displayItemList.get(), disabledMode));
     } else {
         graphicsContext = adoptPtr(new GraphicsContext(canvas, nullptr, disabledMode));
     }
 
     IntRect clipRect(IntPoint(webClipRect.x, webClipRect.y), IntSize(webClipRect.width, webClipRect.height));
     {
         DrawingRecorder drawingRecorder(graphicsContext.get(), displayItemClient(), DisplayItem::LinkHighlight, clipRect);
 
         graphicsContext->clip(clipRect);
-        graphicsContext->setFillColor(m_node->renderer()->style()->tapHighlightColor());
+        graphicsContext->setFillColor(m_node->layoutObject()->style()->tapHighlightColor());
         graphicsContext->fillPath(m_path);
     }
 
     if (RuntimeEnabledFeatures::slimmingPaintEnabled()) {
         GraphicsContext canvasGraphicsContext(canvas, nullptr, disabledMode);
         displayItemList->replay(&canvasGraphicsContext);
     }
 }
 
 void LinkHighlight::startHighlightAnimationIfNeeded()
@@ skipping 52 matching lines @@
 
 void LinkHighlight::updateGeometry()
 {
     // To avoid unnecessary updates (e.g. other entities have requested animations from our WebViewImpl),
     // only proceed if we actually requested an update.
     if (!m_geometryNeedsUpdate)
         return;
 
     m_geometryNeedsUpdate = false;
 
-    bool hasRenderer = m_node && m_node->renderer();
-    const LayoutBoxModelObject* paintInvalidationContainer = hasRenderer ? m_node->renderer()->containerForPaintInvalidation() : 0;
+    bool hasRenderer = m_node && m_node->layoutObject();
+    const LayoutBoxModelObject* paintInvalidationContainer = hasRenderer ? m_node->layoutObject()->containerForPaintInvalidation() : 0;
     if (paintInvalidationContainer)
         attachLinkHighlightToCompositingLayer(paintInvalidationContainer);
     if (paintInvalidationContainer && computeHighlightLayerPathAndPosition(paintInvalidationContainer)) {
         // We only need to invalidate the layer if the highlight size has changed, otherwise
         // we can just re-position the layer without needing to repaint.
         m_contentLayer->layer()->invalidate();
 
         if (m_currentGraphicsLayer)
             m_currentGraphicsLayer->addRepaintRect(FloatRect(layer()->position().x, layer()->position().y, layer()->bounds().width, layer()->bounds().height));
     } else if (!hasRenderer) {
@@ skipping 13 matching lines @@
     // Make sure we update geometry on the next callback from WebViewImpl::layout().
     m_geometryNeedsUpdate = true;
 }
 
 WebLayer* LinkHighlight::layer()
 {
     return clipLayer();
 }
 
 } // namespace blink