Web Animations CSS: Support animation of background-position and background-image

Source/core/animation/AnimatableRepeatable.cpp

Index: Source/core/animation/AnimatableRepeatable.cpp
diff --git a/Source/core/animation/AnimatableRepeatable.cpp b/Source/core/animation/AnimatableRepeatable.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dba8e60b3b1aec117721cec1c6c377e7a1d0fabc
--- /dev/null
+++ b/Source/core/animation/AnimatableRepeatable.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (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/animation/AnimatableRepeatable.h"
+
+namespace {
+
+size_t greatestCommonDivisor(size_t a, size_t b)
+{
+    return b ? greatestCommonDivisor(b, a % b) : a;
+}
+
+size_t lowestCommonMultiple(size_t a, size_t b)
+{
+    if (!a && !b)

[Steve Block, 2013/10/10 03:34:52]

This could be an OR

Or switch back to the assert, since this code path should never be used.

[alancutter (OOO until 2018), 2013/10/10 05:32:41]

Done.

+        return 0;
+    return a / greatestCommonDivisor(a, b) * b;
+}
+
+} // namespace
+
+namespace WebCore {
+
+PassRefPtr<AnimatableValue> AnimatableRepeatable::interpolateTo(const AnimatableValue* value, double fraction) const
+{
+    // Interpolation behaviour spec: http://www.w3.org/TR/css3-transitions/#animtype-repeatable-list
+    const Vector<RefPtr<AnimatableValue> >& otherValues = toAnimatableRepeatable(value)->m_values;
+    ASSERT(lowestCommonMultiple(m_values.size(), otherValues.size()));

[Steve Block, 2013/10/10 03:34:52]

I think we usually use a local variable, rather than repeating an expression for
an assertion. The compiler should optimize it away in release builds anyway.

[alancutter (OOO until 2018), 2013/10/10 05:32:41]

Asserts are now at the top of the function and inside lcm.

+    Vector<RefPtr<AnimatableValue> > interpolatedValues(lowestCommonMultiple(m_values.size(), otherValues.size()));
+    for (size_t i = 0; i < interpolatedValues.size(); ++i) {
+        const AnimatableValue* from = m_values[i % m_values.size()].get();

[Steve Block, 2013/10/10 03:34:52]

We should also assert that neither list has length zero, else the behavior of i
% size() here is undefined.

Might be good to add a comment here or on the ctor that we only handle non-empty
lists.

[alancutter (OOO until 2018), 2013/10/10 05:32:41]

Added assert to constructor and top of function.

+        const AnimatableValue* to = otherValues[i % otherValues.size()].get();
+        // Spec: If a pair of values cannot be interpolated, then the lists are not interpolable.
+        if (!from->isSameType(to))
+            return defaultInterpolateTo(this, value, fraction);
+        interpolatedValues[i] = interpolate(from, to, fraction);
+    }
+    return create(interpolatedValues);
+}
+
+PassRefPtr<AnimatableValue> AnimatableRepeatable::addWith(const AnimatableValue* value) const
+{
+    const Vector<RefPtr<AnimatableValue> >& otherValues = toAnimatableRepeatable(value)->m_values;
+    Vector<RefPtr<AnimatableValue> > addedValues(lowestCommonMultiple(m_values.size(), otherValues.size()));
+    for (size_t i = 0; i < addedValues.size(); ++i) {
+        const AnimatableValue* left = m_values[i % m_values.size()].get();
+        const AnimatableValue* right = otherValues[i % otherValues.size()].get();
+        if (!left->isSameType(right))
+            return defaultAddWith(this, value);
+        addedValues[i] = add(left, right);
+    }
+    return create(addedValues);
+}
+
+bool AnimatableRepeatable::equalTo(const AnimatableValue* value) const
+{
+    const Vector<RefPtr<AnimatableValue> >& otherValues = toAnimatableRepeatable(value)->m_values;
+    if (m_values.size() != otherValues.size())
+        return false;
+    for (size_t i = 0; i < m_values.size(); ++i) {
+        if (!m_values[i]->equals(otherValues[i].get()))
+            return false;
+    }
+    return true;
+}
+
+} // namespace WebCore