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..5ac8a22b53abde5b48cad79fcbc01018b87dd095
--- /dev/null
+++ b/Source/core/animation/AnimatableRepeatable.cpp
@@ -0,0 +1,87 @@
+/*
+ * 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 WebCore {
+
+static size_t gcd(size_t a, size_t b)

[Steve Block, 2013/10/08 23:21:49]

I think Blink style is to use size_t only for sizes. Values which happen to be
always positive should use int and assertions. Also, spell out names -
greatestCommonDivisor().

[Steve Block, 2013/10/08 23:27:23]

I think we prefer anonymous namespaces to static

[alancutter (OOO until 2018), 2013/10/09 07:20:55]

Done.

[Steve Block, 2013/10/09 23:19:05]

What about using int rather than size_t?

[alancutter (OOO until 2018), 2013/10/10 00:58:38]

Because these functions are used for vector sizes based on vector sizes I think
size_t is semantically appropriate.

+{
+    return b ? gcd(b, a % b) : a;
+}
+
+static size_t lcm(size_t a, size_t b)

[Steve Block, 2013/10/08 23:21:49]

Hmm, I've just implemented lowestCommonMultiple() in
https://codereview.chromium.org/26292004/diff/28001/Source/core/animation/Ani....
We should share the two.

[alancutter (OOO until 2018), 2013/10/09 07:20:55]

Given that you intend to rebase ontop of this patch it might be best to land it
as it is here and then pull it out as a utility function in the rebase.

[Steve Block, 2013/10/09 23:19:05]

Agreed

+{
+    ASSERT(a && b);
+    return a / gcd(a, b) * b;
+}
+
+PassRefPtr<AnimatableValue> AnimatableRepeatable::interpolateTo(const AnimatableValue* value, double fraction) const
+{
+    const Vector<RefPtr<AnimatableValue> >& otherValues = toAnimatableRepeatable(value)->m_values;
+    Vector<RefPtr<AnimatableValue> > interpolatedValues(lcm(m_values.size(), otherValues.size()));

[Steve Block, 2013/10/08 23:27:23]

If one or other of the lists has zero entries, lcm() will hit the assertion. Can
this happen? What's the correct behavior?

[alancutter (OOO until 2018), 2013/10/09 07:20:55]

Added support for 0 length AnimatableRepeatables.

+    for (size_t i = 0; i < interpolatedValues.size(); ++i) {
+        const AnimatableValue* from = m_values[i % m_values.size()].get();
+        const AnimatableValue* to = otherValues[i % otherValues.size()].get();
+        if (!from->isSameType(to))

[dstockwell, 2013/10/08 22:52:05]

Needs a comment

[Steve Block, 2013/10/08 23:21:49]

When could this happen? Should it be an assertion?

[alancutter (OOO until 2018), 2013/10/09 07:20:55]

This is most likely to happen when a keyword is used as one of the values. See
background-size for a possible scenario:
http://dev.w3.org/csswg/css-backgrounds/#the-background-size
Personally I think the spec made an unintuitive decision here but there it is.

[alancutter (OOO until 2018), 2013/10/09 07:20:55]

Added comment for method.

+            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(lcm(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;

[Steve Block, 2013/10/08 23:21:49]

If we added operator==() to AnimatableValue(), we could just use
Vector<>::operator==() here. WDYT?

[alancutter (OOO until 2018), 2013/10/09 07:20:55]

As discussed because it's a vector of RefPtrs we don't gain this shortcut.

+}
+
+} // namespace WebCore