Move rendering/svg/RenderSVGResource* to layout/svg.

Source/core/layout/svg/SVGLayoutTreeAsText.cpp

 /*
  * Copyright (C) 2004, 2005, 2007, 2009 Apple Inc. All rights reserved.
  *           (C) 2005 Rob Buis <buis@kde.org>
  *           (C) 2006 Alexander Kellett <lypanov@kde.org>
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 14 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/layout/svg/SVGLayoutTreeAsText.h"
 
 #include "core/layout/LayoutTreeAsText.h"
 #include "core/layout/line/InlineTextBox.h"
+#include "core/layout/svg/LayoutSVGResourceClipper.h"
+#include "core/layout/svg/LayoutSVGResourceFilter.h"
+#include "core/layout/svg/LayoutSVGResourceLinearGradient.h"
+#include "core/layout/svg/LayoutSVGResourceMarker.h"
+#include "core/layout/svg/LayoutSVGResourceMasker.h"
+#include "core/layout/svg/LayoutSVGResourcePattern.h"
+#include "core/layout/svg/LayoutSVGResourceRadialGradient.h"
 #include "core/layout/svg/line/SVGInlineTextBox.h"
 #include "core/layout/svg/line/SVGRootInlineBox.h"
 #include "core/rendering/svg/RenderSVGGradientStop.h"
 #include "core/rendering/svg/RenderSVGImage.h"
 #include "core/rendering/svg/RenderSVGInlineText.h"
-#include "core/rendering/svg/RenderSVGResourceClipper.h"
-#include "core/rendering/svg/RenderSVGResourceFilter.h"
-#include "core/rendering/svg/RenderSVGResourceLinearGradient.h"
-#include "core/rendering/svg/RenderSVGResourceMarker.h"
-#include "core/rendering/svg/RenderSVGResourceMasker.h"
-#include "core/rendering/svg/RenderSVGResourcePattern.h"
-#include "core/rendering/svg/RenderSVGResourceRadialGradient.h"
 #include "core/rendering/svg/RenderSVGRoot.h"
 #include "core/rendering/svg/RenderSVGShape.h"
 #include "core/rendering/svg/RenderSVGText.h"
 #include "core/svg/LinearGradientAttributes.h"
 #include "core/svg/PatternAttributes.h"
 #include "core/svg/RadialGradientAttributes.h"
 #include "core/svg/SVGCircleElement.h"
 #include "core/svg/SVGEllipseElement.h"
 #include "core/svg/SVGLineElement.h"
 #include "core/svg/SVGLinearGradientElement.h"
@@ skipping 190 matching lines @@
 }
 
 static void writeSVGPaintingResource(TextStream& ts, const SVGPaintDescription& paintDescription)
 {
     ASSERT(paintDescription.isValid);
     if (!paintDescription.resource) {
         ts << "[type=SOLID] [color=" << paintDescription.color << "]";
         return;
     }
 
-    RenderSVGResourcePaintServer* paintServerContainer = paintDescription.resource;
+    LayoutSVGResourcePaintServer* paintServerContainer = paintDescription.resource;
     SVGElement* element = paintServerContainer->element();
     ASSERT(element);
 
     if (paintServerContainer->resourceType() == PatternResourceType)
         ts << "[type=PATTERN]";
     else if (paintServerContainer->resourceType() == LinearGradientResourceType)
         ts << "[type=LINEAR-GRADIENT]";
     else if (paintServerContainer->resourceType() == RadialGradientResourceType)
         ts << "[type=RADIAL-GRADIENT]";
 
     ts << " [id=\"" << element->getIdAttribute() << "\"]";
 }
 
 static void writeStyle(TextStream& ts, const LayoutObject& object)
 {
     const LayoutStyle& style = object.styleRef();
     const SVGLayoutStyle& svgStyle = style.svgStyle();
 
     if (!object.localTransform().isIdentity())
         writeNameValuePair(ts, "transform", object.localTransform());
     writeIfNotDefault(ts, "image rendering", style.imageRendering(), LayoutStyle::initialImageRendering());
     writeIfNotDefault(ts, "opacity", style.opacity(), LayoutStyle::initialOpacity());
     if (object.isSVGShape()) {
         const RenderSVGShape& shape = static_cast<const RenderSVGShape&>(object);
         ASSERT(shape.element());
 
-        SVGPaintDescription strokePaintDescription = RenderSVGResourcePaintServer::requestPaintDescription(shape, shape.styleRef(), ApplyToStrokeMode);
+        SVGPaintDescription strokePaintDescription = LayoutSVGResourcePaintServer::requestPaintDescription(shape, shape.styleRef(), ApplyToStrokeMode);
         if (strokePaintDescription.isValid) {
             TextStreamSeparator s(" ");
             ts << " [stroke={" << s;
             writeSVGPaintingResource(ts, strokePaintDescription);
 
             SVGLengthContext lengthContext(shape.element());
             double dashOffset = svgStyle.strokeDashOffset()->value(lengthContext);
             double strokeWidth = svgStyle.strokeWidth()->value(lengthContext);
             RefPtrWillBeRawPtr<SVGLengthList> dashes = svgStyle.strokeDashArray();
 
             DashArray dashArray;
             SVGLengthList::ConstIterator it = dashes->begin();
             SVGLengthList::ConstIterator itEnd = dashes->end();
             for (; it != itEnd; ++it)
                 dashArray.append(it->value(lengthContext));
 
             writeIfNotDefault(ts, "opacity", svgStyle.strokeOpacity(), 1.0f);
             writeIfNotDefault(ts, "stroke width", strokeWidth, 1.0);
             writeIfNotDefault(ts, "miter limit", svgStyle.strokeMiterLimit(), 4.0f);
             writeIfNotDefault(ts, "line cap", svgStyle.capStyle(), ButtCap);
             writeIfNotDefault(ts, "line join", svgStyle.joinStyle(), MiterJoin);
             writeIfNotDefault(ts, "dash offset", dashOffset, 0.0);
             if (!dashArray.isEmpty())
                 writeNameValuePair(ts, "dash array", dashArray);
 
             ts << "}]";
         }
 
-        SVGPaintDescription fillPaintDescription = RenderSVGResourcePaintServer::requestPaintDescription(shape, shape.styleRef(), ApplyToFillMode);
+        SVGPaintDescription fillPaintDescription = LayoutSVGResourcePaintServer::requestPaintDescription(shape, shape.styleRef(), ApplyToFillMode);
         if (fillPaintDescription.isValid) {
             TextStreamSeparator s(" ");
             ts << " [fill={" << s;
             writeSVGPaintingResource(ts, fillPaintDescription);
 
             writeIfNotDefault(ts, "opacity", svgStyle.fillOpacity(), 1.0f);
             writeIfNotDefault(ts, "fill rule", svgStyle.fillRule(), RULE_NONZERO);
             ts << "}]";
         }
         writeIfNotDefault(ts, "clip rule", svgStyle.clipRule(), RULE_NONZERO);
@@ skipping 169 matching lines @@
 }
 
 void writeSVGResourceContainer(TextStream& ts, const LayoutObject& object, int indent)
 {
     writeStandardPrefix(ts, object, indent);
 
     Element* element = toElement(object.node());
     const AtomicString& id = element->getIdAttribute();
     writeNameAndQuotedValue(ts, "id", id);
 
-    RenderSVGResourceContainer* resource = toRenderSVGResourceContainer(const_cast<LayoutObject*>(&object));
+    LayoutSVGResourceContainer* resource = toLayoutSVGResourceContainer(const_cast<LayoutObject*>(&object));
     ASSERT(resource);
 
     if (resource->resourceType() == MaskerResourceType) {
-        RenderSVGResourceMasker* masker = toRenderSVGResourceMasker(resource);
+        LayoutSVGResourceMasker* masker = toLayoutSVGResourceMasker(resource);
         writeNameValuePair(ts, "maskUnits", masker->maskUnits());
         writeNameValuePair(ts, "maskContentUnits", masker->maskContentUnits());
         ts << "\n";
     } else if (resource->resourceType() == FilterResourceType) {
-        RenderSVGResourceFilter* filter = toRenderSVGResourceFilter(resource);
+        LayoutSVGResourceFilter* filter = toLayoutSVGResourceFilter(resource);
         writeNameValuePair(ts, "filterUnits", filter->filterUnits());
         writeNameValuePair(ts, "primitiveUnits", filter->primitiveUnits());
         ts << "\n";
         // Creating a placeholder filter which is passed to the builder.
         FloatRect dummyRect;
         IntRect dummyIntRect;
         RefPtrWillBeRawPtr<SVGFilter> dummyFilter = SVGFilter::create(dummyIntRect, dummyRect, dummyRect, true);
         if (RefPtrWillBeRawPtr<SVGFilterBuilder> builder = filter->buildPrimitives(dummyFilter.get())) {
             if (FilterEffect* lastEffect = builder->lastEffect())
                 lastEffect->externalRepresentation(ts, indent + 1);
         }
     } else if (resource->resourceType() == ClipperResourceType) {
-        writeNameValuePair(ts, "clipPathUnits", toRenderSVGResourceClipper(resource)->clipPathUnits());
+        writeNameValuePair(ts, "clipPathUnits", toLayoutSVGResourceClipper(resource)->clipPathUnits());
         ts << "\n";
     } else if (resource->resourceType() == MarkerResourceType) {
-        RenderSVGResourceMarker* marker = toRenderSVGResourceMarker(resource);
+        LayoutSVGResourceMarker* marker = toLayoutSVGResourceMarker(resource);
         writeNameValuePair(ts, "markerUnits", marker->markerUnits());
         ts << " [ref at " << marker->referencePoint() << "]";
         ts << " [angle=";
         if (marker->angle() == -1)
             ts << marker->orientType() << "]\n";
         else
             ts << marker->angle() << "]\n";
     } else if (resource->resourceType() == PatternResourceType) {
-        RenderSVGResourcePattern* pattern = static_cast<RenderSVGResourcePattern*>(resource);
+        LayoutSVGResourcePattern* pattern = static_cast<LayoutSVGResourcePattern*>(resource);
 
         // Dump final results that are used for rendering. No use in asking SVGPatternElement for its patternUnits(), as it may
         // link to other patterns using xlink:href, we need to build the full inheritance chain, aka. collectPatternProperties()
         PatternAttributes attributes;
         toSVGPatternElement(pattern->element())->collectPatternAttributes(attributes);
 
         writeNameValuePair(ts, "patternUnits", attributes.patternUnits());
         writeNameValuePair(ts, "patternContentUnits", attributes.patternContentUnits());
 
         AffineTransform transform = attributes.patternTransform();
         if (!transform.isIdentity())
             ts << " [patternTransform=" << transform << "]";
         ts << "\n";
     } else if (resource->resourceType() == LinearGradientResourceType) {
-        RenderSVGResourceLinearGradient* gradient = static_cast<RenderSVGResourceLinearGradient*>(resource);
+        LayoutSVGResourceLinearGradient* gradient = static_cast<LayoutSVGResourceLinearGradient*>(resource);
 
         // Dump final results that are used for rendering. No use in asking SVGGradientElement for its gradientUnits(), as it may
         // link to other gradients using xlink:href, we need to build the full inheritance chain, aka. collectGradientProperties()
         LinearGradientAttributes attributes;
         toSVGLinearGradientElement(gradient->element())->collectGradientAttributes(attributes);
         writeCommonGradientProperties(ts, attributes.spreadMethod(), attributes.gradientTransform(), attributes.gradientUnits());
 
         ts << " [start=" << gradient->startPoint(attributes) << "] [end=" << gradient->endPoint(attributes) << "]\n";
     }  else if (resource->resourceType() == RadialGradientResourceType) {
-        RenderSVGResourceRadialGradient* gradient = toRenderSVGResourceRadialGradient(resource);
+        LayoutSVGResourceRadialGradient* gradient = toLayoutSVGResourceRadialGradient(resource);
 
         // Dump final results that are used for rendering. No use in asking SVGGradientElement for its gradientUnits(), as it may
         // link to other gradients using xlink:href, we need to build the full inheritance chain, aka. collectGradientProperties()
         RadialGradientAttributes attributes;
         toSVGRadialGradientElement(gradient->element())->collectGradientAttributes(attributes);
         writeCommonGradientProperties(ts, attributes.spreadMethod(), attributes.gradientTransform(), attributes.gradientUnits());
 
         FloatPoint focalPoint = gradient->focalPoint(attributes);
         FloatPoint centerPoint = gradient->centerPoint(attributes);
         float radius = gradient->radius(attributes);
         float focalRadius = gradient->focalRadius(attributes);
 
         ts << " [center=" << centerPoint << "] [focal=" << focalPoint << "] [radius=" << radius << "] [focalRadius=" << focalRadius << "]\n";
     } else {
         ts << "\n";
     }
     writeChildren(ts, object, indent);
 }
 
 void writeSVGContainer(TextStream& ts, const LayoutObject& container, int indent)
 {
-    // Currently RenderSVGResourceFilterPrimitive has no meaningful output.
+    // Currently LayoutSVGResourceFilterPrimitive has no meaningful output.
     if (container.isSVGResourceFilterPrimitive())
         return;
     writeStandardPrefix(ts, container, indent);
     writePositionAndStyle(ts, container);
     ts << "\n";
     writeResources(ts, container, indent);
     writeChildren(ts, container, indent);
 }
 
 void write(TextStream& ts, const RenderSVGRoot& root, int indent)
@@ skipping 48 matching lines @@
 
 void writeResources(TextStream& ts, const LayoutObject& object, int indent)
 {
     const LayoutStyle& style = object.styleRef();
     const SVGLayoutStyle& svgStyle = style.svgStyle();
 
     // FIXME: We want to use SVGResourcesCache to determine which resources are present, instead of quering the resource <-> id cache.
     // For now leave the DRT output as is, but later on we should change this so cycles are properly ignored in the DRT output.
     LayoutObject& renderer = const_cast<LayoutObject&>(object);
     if (!svgStyle.maskerResource().isEmpty()) {
-        if (RenderSVGResourceMasker* masker = getRenderSVGResourceById<RenderSVGResourceMasker>(object.document(), svgStyle.maskerResource())) {
+        if (LayoutSVGResourceMasker* masker = getLayoutSVGResourceById<LayoutSVGResourceMasker>(object.document(), svgStyle.maskerResource())) {
             writeIndent(ts, indent);
             ts << " ";
             writeNameAndQuotedValue(ts, "masker", svgStyle.maskerResource());
             ts << " ";
             writeStandardPrefix(ts, *masker, 0);
             ts << " " << masker->resourceBoundingBox(&renderer) << "\n";
         }
     }
     if (!svgStyle.clipperResource().isEmpty()) {
-        if (RenderSVGResourceClipper* clipper = getRenderSVGResourceById<RenderSVGResourceClipper>(object.document(), svgStyle.clipperResource())) {
+        if (LayoutSVGResourceClipper* clipper = getLayoutSVGResourceById<LayoutSVGResourceClipper>(object.document(), svgStyle.clipperResource())) {
             writeIndent(ts, indent);
             ts << " ";
             writeNameAndQuotedValue(ts, "clipPath", svgStyle.clipperResource());
             ts << " ";
             writeStandardPrefix(ts, *clipper, 0);
             ts << " " << clipper->resourceBoundingBox(&renderer) << "\n";
         }
     }
     if (!svgStyle.filterResource().isEmpty()) {
-        if (RenderSVGResourceFilter* filter = getRenderSVGResourceById<RenderSVGResourceFilter>(object.document(), svgStyle.filterResource())) {
+        if (LayoutSVGResourceFilter* filter = getLayoutSVGResourceById<LayoutSVGResourceFilter>(object.document(), svgStyle.filterResource())) {
             writeIndent(ts, indent);
             ts << " ";
             writeNameAndQuotedValue(ts, "filter", svgStyle.filterResource());
             ts << " ";
             writeStandardPrefix(ts, *filter, 0);
             ts << " " << filter->resourceBoundingBox(&renderer) << "\n";
         }
     }
 }
 
 } // namespace blink