Merge 117971

Source/WebCore/rendering/svg/SVGMarkerData.h

 /*
  * Copyright (C) Research In Motion Limited 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 11 matching lines @@
 
 #if ENABLE(SVG)
 #include "FloatConversion.h"
 #include "Path.h"
 #include <wtf/MathExtras.h>
 
 namespace WebCore {
 
 class RenderSVGResourceMarker;
 
-class SVGMarkerData {
-public:
-    enum Type {
-        Unknown = 0,
-        Start,
-        Mid,
-        End
-    };
+enum SVGMarkerType {
+    StartMarker,
+    MidMarker,
+    EndMarker
+};
 
-    SVGMarkerData(const Type& type = Unknown, RenderSVGResourceMarker* marker = 0)
-        : m_type(type)
-        , m_marker(marker)
+struct MarkerPosition {
+    MarkerPosition(SVGMarkerType useType, const FloatPoint& useOrigin, float useAngle)
+        : type(useType)
+        , origin(useOrigin)
+        , angle(useAngle)
     {
     }
 
-    FloatPoint origin() const { return m_origin; }
-    RenderSVGResourceMarker* marker() const { return m_marker; }
+    SVGMarkerType type;
+    FloatPoint origin;
+    float angle;
+};
 
-    float currentAngle() const
+class SVGMarkerData {
+public:
+    SVGMarkerData(Vector<MarkerPosition>& positions)
+        : m_positions(positions)
+        , m_elementIndex(0)
+    {
+    }
+
+    static void updateFromPathElement(void* info, const PathElement* element)
+    {
+        SVGMarkerData* markerData = static_cast<SVGMarkerData*>(info);
+
+        // First update the outslope for the previous element.
+        markerData->updateOutslope(element->points[0]);
+
+        // Record the marker for the previous element.
+        if (markerData->m_elementIndex > 0) {
+            SVGMarkerType markerType = markerData->m_elementIndex == 1 ? StartMarker : MidMarker;
+            markerData->m_positions.append(MarkerPosition(markerType, markerData->m_origin, markerData->currentAngle(markerType)));
+        }
+
+        // Update our marker data for this element.
+        markerData->updateMarkerDataForPathElement(element);
+        ++markerData->m_elementIndex;
+    }
+
+    void pathIsDone()
+    {
+        m_positions.append(MarkerPosition(EndMarker, m_origin, currentAngle(EndMarker)));
+    }
+
+private:
+    float currentAngle(SVGMarkerType type) const
     {
         FloatSize inslopeChange = m_inslopePoints[1] - m_inslopePoints[0];
         FloatSize outslopeChange = m_outslopePoints[1] - m_outslopePoints[0];
 
         double inslope = rad2deg(atan2(inslopeChange.height(), inslopeChange.width()));
         double outslope = rad2deg(atan2(outslopeChange.height(), outslopeChange.width()));
 
-        double angle = 0;
-        switch (m_type) {
-        case Start:
-            angle = outslope;
-            break;
-        case Mid:
-            angle = (inslope + outslope) / 2;
-            break;
-        case End:
-            angle = inslope;
-            break;
-        default:
-            ASSERT_NOT_REACHED();
-            break;
+        switch (type) {
+        case StartMarker:
+            return narrowPrecisionToFloat(outslope);
+        case MidMarker:
+            return narrowPrecisionToFloat((inslope + outslope) / 2);
+        case EndMarker:
+            return narrowPrecisionToFloat(inslope);
         }
 
-        return narrowPrecisionToFloat(angle);
-    }
-
-    void updateTypeAndMarker(const Type& type, RenderSVGResourceMarker* marker)
-    {
-        m_type = type;
-        m_marker = marker;
+        ASSERT_NOT_REACHED();
+        return 0;
     }
 
     void updateOutslope(const FloatPoint& point)
     {
         m_outslopePoints[0] = m_origin;
         m_outslopePoints[1] = point;
     }
 
     void updateMarkerDataForPathElement(const PathElement* element)
     {
@@ skipping 15 matching lines @@
             updateInslope(points[0]);
             m_origin = points[0];
             break;
         case PathElementCloseSubpath:
             updateInslope(points[0]);
             m_origin = m_subpathStart;
             m_subpathStart = FloatPoint();
         }
     }
 
-private:
     void updateInslope(const FloatPoint& point)
     {
         m_inslopePoints[0] = m_origin;
         m_inslopePoints[1] = point;
     }
 
-    Type m_type;
-    RenderSVGResourceMarker* m_marker;
+    Vector<MarkerPosition>& m_positions;
+    unsigned m_elementIndex;
     FloatPoint m_origin;
     FloatPoint m_subpathStart;
     FloatPoint m_inslopePoints[2];
     FloatPoint m_outslopePoints[2];
 };
 
 }
 
 #endif // ENABLE(SVG)
 #endif // SVGMarkerData_h