Web Animations: Add InterpolableValue hierarchy.

Source/core/animation/InterpolableValue.h

Index: Source/core/animation/InterpolableValue.h
diff --git a/Source/core/animation/InterpolableValue.h b/Source/core/animation/InterpolableValue.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c3d143790edf4f8367a5ddbcd00ee827ca5284d
--- /dev/null
+++ b/Source/core/animation/InterpolableValue.h
@@ -0,0 +1,115 @@
+// Copyright 2014 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.
+
+#ifndef InterpolableValue_h
+#define InterpolableValue_h
+
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
+
+namespace WebCore {
+
+class InterpolableValue {
+public:
+    virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, double percentage) const = 0;
+    virtual PassOwnPtr<InterpolableValue> clone() const = 0;
+
+    virtual bool isNumber() const { return false; }
+    virtual bool isBool() const { return false; }
+    virtual bool isList() const { return false; }
+
+    virtual ~InterpolableValue() { }
+};
+
+class InterpolableNumber : public InterpolableValue {
+public:
+    static PassOwnPtr<InterpolableNumber> create(double value)
+    {
+        return adoptPtr(new InterpolableNumber(value));
+    }
+
+    virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, double progress) const OVERRIDE FINAL;

[alancutter (OOO until 2018), 2014/02/26 00:42:29]

The suite of blend() functions have the "other" being the value to blend from.
The first parameter for interpolate() should be named "to" to avoid confusion.

[shans, 2014/02/26 21:24:20]

Done.

+    virtual PassOwnPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); }
+    virtual bool isNumber() const OVERRIDE FINAL { return true; }
+    double value() const { return m_value; }
+private:
+    double m_value;
+
+    InterpolableNumber(double value)
+        : m_value(value)
+    { }
+
+};
+
+class InterpolableBool : public InterpolableValue {
+public:
+    static PassOwnPtr<InterpolableBool> create(bool value)
+    {
+        return adoptPtr(new InterpolableBool(value));
+    }
+
+    virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, double percentage) const OVERRIDE FINAL;
+    virtual PassOwnPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(m_value); }
+    virtual bool isBool() const OVERRIDE FINAL { return true; }
+    bool value() const { return m_value; }
+private:
+    bool m_value;
+
+    InterpolableBool(bool value)
+        : m_value(value)
+    { }
+};
+
+class InterpolableList : public InterpolableValue {
+public:
+    static PassOwnPtr<InterpolableList> create(const InterpolableList &other)
+    {
+        return adoptPtr(new InterpolableList(other));
+    }
+
+    static PassOwnPtr<InterpolableList> create(size_t size)
+    {
+        return adoptPtr(new InterpolableList(size));
+    }
+
+    virtual PassOwnPtr<InterpolableValue> interpolate(const InterpolableValue &other, double percentage) const OVERRIDE FINAL;
+    virtual PassOwnPtr<InterpolableValue> clone() const OVERRIDE FINAL { return create(*this); }
+    virtual bool isList() const OVERRIDE FINAL { return true; }
+    void set(size_t position, PassOwnPtr<InterpolableValue> value)
+    {
+        ASSERT(position < m_size);
+        m_values.get()[position] = value;
+    }
+    const InterpolableValue* get(size_t position) const
+    {
+        ASSERT(position < m_size);

[alancutter (OOO until 2018), 2014/02/26 00:42:29]

I'm not so sure unchecked array access in release is okay, especially if the
array size must be agreed upon across different code segments (builder and
applicator).
You might want to confirm with someone more senior in the project than I.
Example:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[shans, 2014/02/26 21:24:20]

InterpolableValues should only be constructed in a pairwise fashion, and are
intended to be solely used by the Interpolation class (which will be provided in
a follow-up patch). The 'shape' (i.e. type and list length) of matching
InterpolableValue trees should be checked when an Interpolation object is
constructed, rather than here.

To reflect this I've marked the interpolate function as private and friended the
unit testing class for now. Once Interpolation is available, then
InterpolableValue will friend that instead.

+        return m_values.get()[position].get();
+    }
+
+private:
+    InterpolableList(size_t size)
+        : m_size(size)
+    {
+        m_values = adoptArrayPtr(new OwnPtr<InterpolableValue>[size]);
+    }
+
+    InterpolableList(const InterpolableList& other)
+        : m_size(other.m_size)
+    {
+        m_values = adoptArrayPtr(new OwnPtr<InterpolableValue>[m_size]);
+        for (size_t i = 0; i < m_size; i++)
+            set(i, other.m_values.get()[i]->clone());
+    }
+
+    size_t m_size;
+    OwnPtr<OwnPtr<InterpolableValue>[]> m_values;
+};
+
+DEFINE_TYPE_CASTS(InterpolableNumber, InterpolableValue, value, value->isNumber(), value.isNumber());
+DEFINE_TYPE_CASTS(InterpolableBool, InterpolableValue, value, value->isBool(), value.isBool());
+DEFINE_TYPE_CASTS(InterpolableList, InterpolableValue, value, value->isList(), value.isList());
+
+}
+
+#endif