Move the remaining rendering/svg/RenderSVG* files to layout.

Source/core/layout/svg/SVGLayoutSupport.cpp

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 16 matching lines @@
 
 #include "core/frame/FrameHost.h"
 #include "core/layout/Layer.h"
 #include "core/layout/LayoutGeometryMap.h"
 #include "core/layout/PaintInfo.h"
 #include "core/layout/SubtreeLayoutScope.h"
 #include "core/layout/svg/LayoutSVGInlineText.h"
 #include "core/layout/svg/LayoutSVGResourceClipper.h"
 #include "core/layout/svg/LayoutSVGResourceFilter.h"
 #include "core/layout/svg/LayoutSVGResourceMasker.h"
+#include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/LayoutSVGShape.h"
 #include "core/layout/svg/LayoutSVGText.h"
 #include "core/layout/svg/LayoutSVGViewportContainer.h"
 #include "core/layout/svg/SVGResources.h"
 #include "core/layout/svg/SVGResourcesCache.h"
-#include "core/rendering/svg/RenderSVGRoot.h"
 #include "core/svg/SVGElement.h"
 #include "platform/geometry/TransformState.h"
 
 namespace blink {
 
 static inline LayoutRect enclosingIntRectIfNotEmpty(const FloatRect& rect)
 {
     if (rect.isEmpty())
         return LayoutRect();
     return enclosingIntRect(rect);
@@ skipping 17 matching lines @@
         // FIXME: These are quirks carried forward from the old paint invalidation infrastructure.
         LayoutRect rect = enclosingIntRectIfNotEmpty(paintInvalidationRect);
         // Offset by SVG root paint offset and apply clipping as needed.
         rect.move(paintInvalidationState->paintOffset());
         if (paintInvalidationState->isClipped())
             rect.intersect(paintInvalidationState->clipRect());
         return rect;
     }
 
     LayoutRect rect;
-    const RenderSVGRoot& svgRoot = mapRectToSVGRootForPaintInvalidation(object, paintInvalidationRect, rect);
+    const LayoutSVGRoot& svgRoot = mapRectToSVGRootForPaintInvalidation(object, paintInvalidationRect, rect);
     svgRoot.mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
     return rect;
 }
 
-const RenderSVGRoot& SVGLayoutSupport::mapRectToSVGRootForPaintInvalidation(const LayoutObject* object, const FloatRect& localPaintInvalidationRect, LayoutRect& rect)
+const LayoutSVGRoot& SVGLayoutSupport::mapRectToSVGRootForPaintInvalidation(const LayoutObject* object, const FloatRect& localPaintInvalidationRect, LayoutRect& rect)
 {
     ASSERT(object && object->isSVG() && !object->isSVGRoot());
 
     FloatRect paintInvalidationRect = localPaintInvalidationRect;
     // FIXME: Building the transform to the SVG root border box and then doing
     // mapRect() with that would be slightly more efficient, but requires some
     // additions to AffineTransform (preMultiply, preTranslate) to avoid
     // excessive copying and to get a similar fast-path for translations.
     const LayoutObject* parent = object;
     do {
         paintInvalidationRect = parent->localToParentTransform().mapRect(paintInvalidationRect);
         parent = parent->parent();
     } while (!parent->isSVGRoot());
 
-    const RenderSVGRoot& svgRoot = toRenderSVGRoot(*parent);
+    const LayoutSVGRoot& svgRoot = toLayoutSVGRoot(*parent);
 
     paintInvalidationRect = svgRoot.localToBorderBoxTransform().mapRect(paintInvalidationRect);
     rect = enclosingIntRectIfNotEmpty(paintInvalidationRect);
     return svgRoot;
 }
 
 void SVGLayoutSupport::mapLocalToContainer(const LayoutObject* object, const LayoutLayerModelObject* paintInvalidationContainer, TransformState& transformState, bool* wasFixed, const PaintInvalidationState* paintInvalidationState)
 {
     transformState.applyTransform(object->localToParentTransform());
 
     if (paintInvalidationState && paintInvalidationState->canMapToContainer(paintInvalidationContainer)) {
         // |svgTransform| contains localToBorderBoxTransform mentioned below.
         transformState.applyTransform(paintInvalidationState->svgTransform());
         transformState.move(paintInvalidationState->paintOffset());
         return;
     }
 
     LayoutObject* parent = object->parent();
 
-    // At the SVG/HTML boundary (aka RenderSVGRoot), we apply the localToBorderBoxTransform
+    // At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
     // to map an element from SVG viewport coordinates to CSS box coordinates.
-    // RenderSVGRoot's mapLocalToContainer method expects CSS box coordinates.
+    // LayoutSVGRoot's mapLocalToContainer method expects CSS box coordinates.
     if (parent->isSVGRoot())
-        transformState.applyTransform(toRenderSVGRoot(parent)->localToBorderBoxTransform());
+        transformState.applyTransform(toLayoutSVGRoot(parent)->localToBorderBoxTransform());
 
     MapCoordinatesFlags mode = UseTransforms;
     parent->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
 }
 
 const LayoutObject* SVGLayoutSupport::pushMappingToContainer(const LayoutObject* object, const LayoutLayerModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap)
 {
     ASSERT_UNUSED(ancestorToStopAt, ancestorToStopAt != object);
 
     LayoutObject* parent = object->parent();
 
-    // At the SVG/HTML boundary (aka RenderSVGRoot), we apply the localToBorderBoxTransform
+    // At the SVG/HTML boundary (aka LayoutSVGRoot), we apply the localToBorderBoxTransform
     // to map an element from SVG viewport coordinates to CSS box coordinates.
-    // RenderSVGRoot's mapLocalToContainer method expects CSS box coordinates.
+    // LayoutSVGRoot's mapLocalToContainer method expects CSS box coordinates.
     if (parent->isSVGRoot()) {
         TransformationMatrix matrix(object->localToParentTransform());
-        matrix.multiply(toRenderSVGRoot(parent)->localToBorderBoxTransform());
+        matrix.multiply(toLayoutSVGRoot(parent)->localToBorderBoxTransform());
         geometryMap.push(object, matrix);
     } else {
         geometryMap.push(object, object->localToParentTransform());
     }
 
     return parent;
 }
 
 // Update a bounding box taking into account the validity of the other bounding box.
 inline void SVGLayoutSupport::updateObjectBoundingBox(FloatRect& objectBoundingBox, bool& objectBoundingBoxValid, LayoutObject* other, FloatRect otherBoundingBox)
@@ skipping 30 matching lines @@
 
         const AffineTransform& transform = current->localToParentTransform();
         updateObjectBoundingBox(objectBoundingBox, objectBoundingBoxValid, current,
             transform.mapRect(current->objectBoundingBox()));
         strokeBoundingBox.unite(transform.mapRect(current->paintInvalidationRectInLocalCoordinates()));
     }
 
     paintInvalidationBoundingBox = strokeBoundingBox;
 }
 
-const RenderSVGRoot* SVGLayoutSupport::findTreeRootObject(const LayoutObject* start)
+const LayoutSVGRoot* SVGLayoutSupport::findTreeRootObject(const LayoutObject* start)
 {
     while (start && !start->isSVGRoot())
         start = start->parent();
 
     ASSERT(start);
     ASSERT(start->isSVGRoot());
-    return toRenderSVGRoot(start);
+    return toLayoutSVGRoot(start);
 }
 
 inline bool SVGLayoutSupport::layoutSizeOfNearestViewportChanged(const LayoutObject* start)
 {
     while (start && !start->isSVGRoot() && !start->isSVGViewportContainer())
         start = start->parent();
 
     ASSERT(start);
     ASSERT(start->isSVGRoot() || start->isSVGViewportContainer());
     if (start->isSVGViewportContainer())
         return toLayoutSVGViewportContainer(start)->isLayoutSizeChanged();
 
-    return toRenderSVGRoot(start)->isLayoutSizeChanged();
+    return toLayoutSVGRoot(start)->isLayoutSizeChanged();
 }
 
 bool SVGLayoutSupport::transformToRootChanged(LayoutObject* ancestor)
 {
     while (ancestor && !ancestor->isSVGRoot()) {
         if (ancestor->isSVGTransformableContainer())
             return toLayoutSVGContainer(ancestor)->didTransformToRootUpdate();
         if (ancestor->isSVGViewportContainer())
             return toLayoutSVGViewportContainer(ancestor)->didTransformToRootUpdate();
         ancestor = ancestor->parent();
@@ skipping 56 matching lines @@
 {
     ASSERT(object);
 
     SVGResources* resources = SVGResourcesCache::cachedResourcesForLayoutObject(object);
     if (resources)
         resources->layoutIfNeeded();
 }
 
 bool SVGLayoutSupport::isOverflowHidden(const LayoutObject* object)
 {
-    // RenderSVGRoot should never query for overflow state - it should always clip itself to the initial viewport size.
+    // LayoutSVGRoot should never query for overflow state - it should always clip itself to the initial viewport size.
     ASSERT(!object->isDocumentElement());
 
     return object->style()->overflowX() == OHIDDEN || object->style()->overflowX() == OSCROLL;
 }
 
 void SVGLayoutSupport::intersectPaintInvalidationRectWithResources(const LayoutObject* renderer, FloatRect& paintInvalidationRect)
 {
     ASSERT(renderer);
 
     SVGResources* resources = SVGResourcesCache::cachedResourcesForLayoutObject(renderer);
@@ skipping 210 matching lines @@
 
         layer = layer->parent();
     }
 
     ctm.scale(deviceScaleFactor);
 
     return narrowPrecisionToFloat(sqrt((pow(ctm.xScale(), 2) + pow(ctm.yScale(), 2)) / 2));
 }
 
 }