Remove SVGPathElement.pathSegList and related interfaces

third_party/WebKit/Source/core/animation/PathSVGInterpolation.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/animation/PathSVGInterpolation.h"
 
 #include "core/svg/SVGPathByteStreamBuilder.h"
 #include "core/svg/SVGPathByteStreamSource.h"
 #include "core/svg/SVGPathElement.h"
@@ skipping 165 matching lines @@
 }
 
 PathSegmentData pathSegArcFromInterpolableValue(const InterpolableValue& value, SVGPathSegType segType, SubPathCoordinates& coordinates)
 {
     const InterpolableList& list = toInterpolableList(value);
     bool isAbsolute = isAbsolutePathSegType(segType);
     PathSegmentData segment;
     segment.command = segType;
     segment.targetPoint.setX(specifiedFromInterpolableValue(list.get(0), isAbsolute, coordinates.currentX));
     segment.targetPoint.setY(specifiedFromInterpolableValue(list.get(1), isAbsolute, coordinates.currentY));
-    segment.point1.setX(toInterpolableNumber(list.get(2))->value());
-    segment.point1.setY(toInterpolableNumber(list.get(3))->value());
-    segment.point2.setX(toInterpolableNumber(list.get(4))->value());
+    segment.arcRadii().setX(toInterpolableNumber(list.get(2))->value());
+    segment.arcRadii().setY(toInterpolableNumber(list.get(3))->value());
+    segment.setArcAngle(toInterpolableNumber(list.get(4))->value());
     segment.arcLarge = toInterpolableBool(list.get(5))->value();
     segment.arcSweep = toInterpolableBool(list.get(6))->value();
     return segment;
 }
 
 PassOwnPtr<InterpolableValue> pathSegLinetoHorizontalToInterpolableValue(const PathSegmentData& segment, SubPathCoordinates& coordinates)
 {
     bool isAbsolute = isAbsolutePathSegType(segment.command);
     return specifiedToInterpolableValue(segment.x(), isAbsolute, coordinates.currentX);
 }
@@ skipping 186 matching lines @@
         pathSource.parseSegment();
         ++count;
     }
     return count;
 }
 
 } // namespace
 
 PassRefPtr<PathSVGInterpolation> PathSVGInterpolation::maybeCreate(SVGPropertyBase* start, SVGPropertyBase* end, PassRefPtrWillBeRawPtr<SVGAnimatedPropertyBase> attribute)
 {
-    ASSERT(start->type() == SVGPathSegList::classType());
-    ASSERT(end->type() == SVGPathSegList::classType());
+    ASSERT(start->type() == SVGPath::classType());
+    ASSERT(end->type() == SVGPath::classType());
 
-    const SVGPathByteStream& startPath = static_cast<SVGPathSegList*>(start)->byteStream();
-    const SVGPathByteStream& endPath = static_cast<SVGPathSegList*>(end)->byteStream();
+    const SVGPathByteStream& startPath = static_cast<SVGPath*>(start)->byteStream();
+    const SVGPathByteStream& endPath = static_cast<SVGPath*>(end)->byteStream();
 
     if (startPath.size() != endPath.size())
         return nullptr;
 
     size_t length = countPathCommands(startPath);
 
     SVGPathByteStreamSource startPathSource(startPath);
     SVGPathByteStreamSource endPathSource(endPath);
 
     Vector<SVGPathSegType> pathSegTypes(length);
@@ skipping 14 matching lines @@
         endValue->set(i, pathSegToInterpolableValue(endSeg, endCoordinates, &pathSegTypes.at(i)));
 
         ++i;
     }
     ASSERT(!endPathSource.hasMoreData());
     ASSERT(i == length);
 
     return adoptRef(new PathSVGInterpolation(startValue.release(), endValue.release(), attribute, pathSegTypes));
 }
 
-PassRefPtrWillBeRawPtr<SVGPropertyBase> PathSVGInterpolation::fromInterpolableValue(const InterpolableValue& value, const Vector<SVGPathSegType>& pathSegTypes, SVGPathElement* element)
+PassRefPtrWillBeRawPtr<SVGPropertyBase> PathSVGInterpolation::fromInterpolableValue(const InterpolableValue& value, const Vector<SVGPathSegType>& pathSegTypes)
 {
-    RefPtrWillBeRawPtr<SVGPathSegList> result = SVGPathSegList::create(element);
-    result->invalidateList();
+    RefPtrWillBeRawPtr<SVGPath> result = SVGPath::create();
     InterpolatedPathSource source(toInterpolableList(value), pathSegTypes);
     SVGPathByteStreamBuilder builder(result->mutableByteStream());
     SVGPathParser parser(&source, &builder);
     parser.parsePathDataFromSource(UnalteredParsing, false);
     return result.release();
 }
 
-PassRefPtrWillBeRawPtr<SVGPropertyBase> PathSVGInterpolation::interpolatedValue(SVGElement& element) const
+PassRefPtrWillBeRawPtr<SVGPropertyBase> PathSVGInterpolation::interpolatedValue(SVGElement&) const
 {
-    return fromInterpolableValue(*m_cachedValue, m_pathSegTypes, toSVGPathElement(&element));
+    return fromInterpolableValue(*m_cachedValue, m_pathSegTypes);
 }
 
 }