CSS animation for SVG presentation attribute 'd'

third_party/WebKit/Source/core/animation/animatable/AnimatablePath.cpp

Index: third_party/WebKit/Source/core/animation/animatable/AnimatablePath.cpp
diff --git a/third_party/WebKit/Source/core/animation/animatable/AnimatablePath.cpp b/third_party/WebKit/Source/core/animation/animatable/AnimatablePath.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b30309676b013ab5e79108ce5798abd425cf0dd
--- /dev/null
+++ b/third_party/WebKit/Source/core/animation/animatable/AnimatablePath.cpp
@@ -0,0 +1,68 @@
+// 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/animatable/AnimatablePath.h"
+
+#include "core/style/DataEquivalency.h"
+#include "core/svg/SVGPathBlender.h"
+#include "core/svg/SVGPathByteStreamBuilder.h"
+#include "core/svg/SVGPathByteStreamSource.h"
+#include "core/svg/SVGPathUtilities.h"
+
+namespace blink {
+
+bool AnimatablePath::usesDefaultInterpolationWith(const AnimatableValue* value) const
+{
+    // Default interpolation is used if either path is not specified,
+    // or the paths have different lengths,
+    // or the paths have a segment with different types (ignoring "relativeness").
+
+    const SVGPathByteStream* toByteStream = toAnimatablePath(value)->m_byteStream.get();
+    if (!m_byteStream || !toByteStream)
+        return true;
+
+    SVGPathByteStreamSource fromSource(*m_byteStream);
+    SVGPathByteStreamSource toSource(*toByteStream);
+
+    while (fromSource.hasMoreData()) {
+        if (!toSource.hasMoreData())
+            return true;
+
+        PathSegmentData fromSeg = fromSource.parseSegment();
+        PathSegmentData toSeg = toSource.parseSegment();
+        if (fromSeg.command == PathSegUnknown || toSeg.command == PathSegUnknown)
+            return true;
+
+        if (toAbsolutePathSegType(fromSeg.command) != toAbsolutePathSegType(toSeg.command))
+            return true;
+    }
+
+    return toSource.hasMoreData();
+}
+
+PassRefPtr<AnimatableValue> AnimatablePath::interpolateTo(const AnimatableValue* value, double fraction) const
+{
+    if (usesDefaultInterpolationWith(value))
+        return defaultInterpolateTo(this, value, fraction);
+
+    OwnPtr<SVGPathByteStream> byteStream;
+    byteStream = SVGPathByteStream::create();
+    SVGPathByteStreamBuilder builder(*byteStream);
+
+    SVGPathByteStreamSource fromSource(*m_byteStream);
+    SVGPathByteStreamSource toSource(*toAnimatablePath(value)->m_byteStream);

[dstockwell, 2015/11/26 08:38:40]

Is there a representation of paths which is not encoded as a byte stream? This
sounds expensive.

Are we planning to migrate to the InterpolationType in
https://codereview.chromium.org/1441853002/ ?

[fs, 2015/11/26 11:21:38]

I believe it's the cheapest representation that retains full semantics of the
path (the other option is 'String', but that has a higher cost since it needs to
string-to-float a lot.) It's not terribly expensive though since it's a fairly
straight memcpy.
 
That'd be good. Needs to untie from SVGPath (SVGPropertyBAse) though for that.

[Eric Willigers, 2015/11/26 21:16:33]

We will have an InterpolationType. It will fix this CL's failing expectations in
d-responsive-expected.txt
But I think we always have distinct InterpolationType classes for CSS and SVG.
Alan? 

I understand we still need this AnimatableValue for transitions.

+
+    SVGPathBlender blender(&fromSource, &toSource, &builder);
+    bool ok = blender.blendAnimatedPath(fraction);
+    ASSERT_UNUSED(ok, ok);
+    return AnimatablePath::create(byteStream.release());
+}
+
+bool AnimatablePath::equalTo(const AnimatableValue* value) const
+{
+    return dataEquivalent(m_byteStream, toAnimatablePath(value)->m_byteStream);
+}
+
+} // namespace blink