Rename renderer() to layoutObject().

Source/core/svg/SVGSVGElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 187 matching lines @@
 }
 
 void SVGSVGElement::setCurrentTranslate(const FloatPoint& point)
 {
     m_translation->setValue(point);
     updateCurrentTranslate();
 }
 
 void SVGSVGElement::updateCurrentTranslate()
 {
-    if (LayoutObject* object = renderer())
+    if (LayoutObject* object = layoutObject())
         object->setNeedsLayoutAndFullPaintInvalidation();
 }
 
 bool SVGSVGElement::zoomAndPanEnabled() const
 {
     const SVGZoomAndPan* currentViewSpec = this;
     if (m_useCurrentView)
         currentViewSpec = m_viewSpec.get();
     return currentViewSpec && currentViewSpec->zoomAndPan() == SVGZoomAndPanMagnify;
 }
@@ skipping 76 matching lines @@
         invalidateRelativeLengthClients();
 
         // At the SVG/HTML boundary (aka LayoutSVGRoot), the width and
         // height attributes can affect the replaced size so we need
         // to mark it for updating.
         //
         // FIXME: For width/height animated as XML attributes on SVG
         // roots, there is an attribute synchronization missing. See
         // http://crbug.com/364807
         if (widthChanged || heightChanged) {
-            LayoutObject* layoutObject = renderer();
+            LayoutObject* layoutObject = this->layoutObject();
             if (layoutObject && layoutObject->isSVGRoot()) {
                 invalidateSVGPresentationAttributeStyle();
                 setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SVGContainerSizeChange));
             }
         } else {
             invalidateSVGPresentationAttributeStyle();
             setNeedsStyleRecalc(LocalStyleChange,
                 StyleChangeReasonForTracing::fromAttribute(attrName));
         }
     }
 
     if (SVGFitToViewBox::isKnownAttribute(attrName)) {
         updateRelativeLengthsOrViewBox = true;
-        if (LayoutObject* object = renderer())
+        if (LayoutObject* object = layoutObject())
             object->setNeedsTransformUpdate();
     }
 
     SVGElement::InvalidationGuard invalidationGuard(this);
 
     if (updateRelativeLengthsOrViewBox
         || SVGZoomAndPan::isKnownAttribute(attrName)) {
-        if (renderer())
-            markForLayoutAndParentResourceInvalidation(renderer());
+        if (layoutObject())
+            markForLayoutAndParentResourceInvalidation(layoutObject());
         return;
     }
 
     SVGGraphicsElement::svgAttributeChanged(attrName);
 }
 
 // FloatRect::intersects does not consider horizontal or vertical lines (because of isEmpty()).
 static bool intersectsAllowingEmpty(const FloatRect& r1, const FloatRect& r2)
 {
     if (r1.width() < 0 || r1.height() < 0 || r2.width() < 0 || r2.height() < 0)
         return false;
 
     return r1.x() < r2.maxX() && r2.x() < r1.maxX()
         && r1.y() < r2.maxY() && r2.y() < r1.maxY();
 }
 
 // One of the element types that can cause graphics to be drawn onto the target canvas.
 // Specifically: circle, ellipse, image, line, path, polygon, polyline, rect, text and use.
 static bool isIntersectionOrEnclosureTarget(LayoutObject* renderer)
 {
     return renderer->isSVGShape()
         || renderer->isSVGText()
         || renderer->isSVGImage()
         || isSVGUseElement(*renderer->node());
 }
 
 bool SVGSVGElement::checkIntersectionOrEnclosure(const SVGElement& element, const FloatRect& rect,
     CheckIntersectionOrEnclosure mode) const
 {
-    LayoutObject* renderer = element.renderer();
+    LayoutObject* renderer = element.layoutObject();
     ASSERT(!renderer || renderer->style());
     if (!renderer || renderer->style()->pointerEvents() == PE_NONE)
         return false;
 
     if (!isIntersectionOrEnclosureTarget(renderer))
         return false;
 
     AffineTransform ctm = toSVGGraphicsElement(element).computeCTM(AncestorScope, DisallowStyleUpdate, this);
     FloatRect mappedRepaintRect = ctm.mapRect(renderer->paintInvalidationRectInLocalCoordinates());
 
@@ skipping 119 matching lines @@
     if (!hasEmptyViewBox()) {
         FloatSize size = currentViewportSize();
         viewBoxTransform = viewBoxToViewTransform(size.width(), size.height());
     }
 
     AffineTransform transform;
     if (!isOutermostSVGSVGElement()) {
         SVGLengthContext lengthContext(this);
         transform.translate(m_x->currentValue()->value(lengthContext), m_y->currentValue()->value(lengthContext));
     } else if (mode == SVGElement::ScreenScope) {
-        if (LayoutObject* renderer = this->renderer()) {
+        if (LayoutObject* renderer = this->layoutObject()) {
             FloatPoint location;
             float zoomFactor = 1;
 
             // At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
             // to map an element from SVG viewport coordinates to CSS box coordinates.
             // LayoutSVGRoot's localToAbsolute method expects CSS box coordinates.
             // We also need to adjust for the zoom level factored into CSS coordinates (bug #96361).
             if (renderer->isSVGRoot()) {
                 location = toLayoutSVGRoot(renderer)->localToBorderBoxTransform().mapPoint(location);
                 zoomFactor = 1 / renderer->style()->effectiveZoom();
@@ skipping 107 matching lines @@
 }
 
 FloatRect SVGSVGElement::currentViewBoxRect() const
 {
     if (m_useCurrentView)
         return m_viewSpec ? m_viewSpec->viewBox()->currentValue()->value() : FloatRect();
 
     FloatRect useViewBox = viewBox()->currentValue()->value();
     if (!useViewBox.isEmpty())
         return useViewBox;
-    if (!renderer() || !renderer()->isSVGRoot())
+    if (!layoutObject() || !layoutObject()->isSVGRoot())
         return FloatRect();
-    if (!toLayoutSVGRoot(renderer())->isEmbeddedThroughSVGImage())
+    if (!toLayoutSVGRoot(layoutObject())->isEmbeddedThroughSVGImage())
         return FloatRect();
 
     // If no viewBox is specified but non-relative width/height values, then we
     // should always synthesize a viewBox if we're embedded through a SVGImage.
     return FloatRect(FloatPoint(), FloatSize(floatValueForLength(intrinsicWidth(), 0), floatValueForLength(intrinsicHeight(), 0)));
 }
 
 FloatSize SVGSVGElement::currentViewportSize() const
 {
-    if (!renderer())
+    if (!layoutObject())
         return FloatSize();
 
-    if (renderer()->isSVGRoot()) {
-        LayoutRect contentBoxRect = toLayoutSVGRoot(renderer())->contentBoxRect();
-        return FloatSize(contentBoxRect.width() / renderer()->style()->effectiveZoom(), contentBoxRect.height() / renderer()->style()->effectiveZoom());
+    if (layoutObject()->isSVGRoot()) {
+        LayoutRect contentBoxRect = toLayoutSVGRoot(layoutObject())->contentBoxRect();
+        return FloatSize(contentBoxRect.width() / layoutObject()->style()->effectiveZoom(), contentBoxRect.height() / layoutObject()->style()->effectiveZoom());
     }
 
-    FloatRect viewportRect = toLayoutSVGViewportContainer(renderer())->viewport();
+    FloatRect viewportRect = toLayoutSVGViewportContainer(layoutObject())->viewport();
     return FloatSize(viewportRect.width(), viewportRect.height());
 }
 
 bool SVGSVGElement::hasIntrinsicWidth() const
 {
     return width()->currentValue()->unitType() != LengthTypePercentage;
 }
 
 bool SVGSVGElement::hasIntrinsicHeight() const
 {
@@ skipping 30 matching lines @@
 
     AffineTransform transform;
     if (transformList->concatenate(transform))
         ctm *= transform;
 
     return ctm;
 }
 
 void SVGSVGElement::setupInitialView(const String& fragmentIdentifier, Element* anchorNode)
 {
-    LayoutObject* renderer = this->renderer();
+    LayoutObject* renderer = this->layoutObject();
     SVGViewSpec* view = m_viewSpec.get();
     if (view)
         view->reset();
 
     bool hadUseCurrentView = m_useCurrentView;
     m_useCurrentView = false;
 
     if (fragmentIdentifier.startsWith("xpointer(")) {
         // FIXME: XPointer references are ignored (https://bugs.webkit.org/show_bug.cgi?id=17491)
         if (renderer && hadUseCurrentView)
@@ skipping 18 matching lines @@
     // Spec: If the SVG fragment identifier addresses a 'view' element within an SVG document (e.g., MyDrawing.svg#MyView
     // or MyDrawing.svg#xpointer(id('MyView'))) then the closest ancestor 'svg' element is displayed in the viewport.
     // Any view specification attributes included on the given 'view' element override the corresponding view specification
     // attributes on the closest ancestor 'svg' element.
     if (isSVGViewElement(anchorNode)) {
         SVGViewElement& viewElement = toSVGViewElement(*anchorNode);
 
         if (SVGSVGElement* svg = viewElement.ownerSVGElement()) {
             svg->inheritViewAttributes(&viewElement);
 
-            if (LayoutObject* renderer = svg->renderer())
+            if (LayoutObject* renderer = svg->layoutObject())
                 markForLayoutAndParentResourceInvalidation(renderer);
 
             return;
         }
     }
 
     // If we previously had a view and didn't get a new one, we need to
     // layout again.
     if (renderer && hadUseCurrentView)
         markForLayoutAndParentResourceInvalidation(renderer);
@@ skipping 46 matching lines @@
     visitor->trace(m_width);
     visitor->trace(m_height);
     visitor->trace(m_translation);
     visitor->trace(m_timeContainer);
     visitor->trace(m_viewSpec);
     SVGGraphicsElement::trace(visitor);
     SVGFitToViewBox::trace(visitor);
 }
 
 } // namespace blink