Move rendering/RenderObject to layout/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 19 matching lines @@
 #include "core/css/CSSHelper.h"
 #include "core/dom/Document.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/editing/FrameSelection.h"
 #include "core/events/EventListener.h"
 #include "core/frame/LocalFrame.h"
 #include "core/page/FrameTree.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/UseCounter.h"
-#include "core/rendering/RenderObject.h"
+#include "core/layout/LayoutObject.h"
 #include "core/rendering/svg/RenderSVGModelObject.h"
 #include "core/rendering/svg/RenderSVGRoot.h"
 #include "core/rendering/svg/RenderSVGViewportContainer.h"
 #include "core/svg/SVGAngleTearOff.h"
 #include "core/svg/SVGNumberTearOff.h"
 #include "core/svg/SVGPreserveAspectRatio.h"
 #include "core/svg/SVGRectTearOff.h"
 #include "core/svg/SVGTransform.h"
 #include "core/svg/SVGTransformList.h"
 #include "core/svg/SVGTransformTearOff.h"
@@ skipping 146 matching lines @@
 }
 
 void SVGSVGElement::setCurrentTranslate(const FloatPoint& point)
 {
     m_translation->setValue(point);
     updateCurrentTranslate();
 }
 
 void SVGSVGElement::updateCurrentTranslate()
 {
-    if (RenderObject* object = renderer())
+    if (LayoutObject* object = renderer())
         object->setNeedsLayoutAndFullPaintInvalidation();
 }
 
 void SVGSVGElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (!nearestViewportElement()) {
         bool setListener = true;
 
         // Only handle events if we're the outermost <svg> element
         if (name == HTMLNames::onunloadAttr)
@@ skipping 58 matching lines @@
         invalidateRelativeLengthClients();
 
         // At the SVG/HTML boundary (aka RenderSVGRoot), 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) {
-            RenderObject* renderObject = renderer();
-            if (renderObject && renderObject->isSVGRoot()) {
+            LayoutObject* layoutObject = renderer();
+            if (layoutObject && layoutObject->isSVGRoot()) {
                 invalidateSVGPresentationAttributeStyle();
                 setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SVGContainerSizeChange));
             }
         }
     }
 
     if (SVGFitToViewBox::isKnownAttribute(attrName)) {
         updateRelativeLengthsOrViewBox = true;
-        if (RenderObject* object = renderer())
+        if (LayoutObject* object = renderer())
             object->setNeedsTransformUpdate();
     }
 
     SVGElement::InvalidationGuard invalidationGuard(this);
 
     if (updateRelativeLengthsOrViewBox
         || SVGZoomAndPan::isKnownAttribute(attrName)) {
         if (renderer())
             markForLayoutAndParentResourceInvalidation(renderer());
         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(RenderObject* renderer)
+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
 {
-    RenderObject* renderer = element.renderer();
+    LayoutObject* renderer = element.renderer();
     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 (RenderObject* renderer = this->renderer()) {
+        if (LayoutObject* renderer = this->renderer()) {
             FloatPoint location;
             float zoomFactor = 1;
 
             // At the SVG/HTML boundary (aka RenderSVGRoot), we apply the localToBorderBoxTransform
             // to map an element from SVG viewport coordinates to CSS box coordinates.
             // RenderSVGRoot'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 = toRenderSVGRoot(renderer)->localToBorderBoxTransform().mapPoint(location);
                 zoomFactor = 1 / renderer->style()->effectiveZoom();
@@ skipping 24 matching lines @@
 {
     // FIXME: We should respect display: none on the documentElement svg element
     // but many things in FrameView and SVGImage depend on the RenderSVGRoot when
     // they should instead depend on the RenderView.
     // https://bugs.webkit.org/show_bug.cgi?id=103493
     if (document().documentElement() == this)
         return true;
     return Element::rendererIsNeeded(style);
 }
 
-RenderObject* SVGSVGElement::createRenderer(const RenderStyle&)
+LayoutObject* SVGSVGElement::createRenderer(const RenderStyle&)
 {
     if (isOutermostSVGSVGElement())
         return new RenderSVGRoot(this);
 
     return new RenderSVGViewportContainer(this);
 }
 
 Node::InsertionNotificationRequest SVGSVGElement::insertedInto(ContainerNode* rootParent)
 {
     if (rootParent->inDocument()) {
@@ skipping 134 matching lines @@
 
     AffineTransform transform;
     if (transformList->concatenate(transform))
         ctm *= transform;
 
     return ctm;
 }
 
 void SVGSVGElement::setupInitialView(const String& fragmentIdentifier, Element* anchorNode)
 {
-    RenderObject* renderer = this->renderer();
+    LayoutObject* renderer = this->renderer();
     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 (RenderObject* renderer = svg->renderer())
+            if (LayoutObject* renderer = svg->renderer())
                 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