Web Animations API: Start implementation of Element.animate().

Source/core/animation/ElementAnimation.cpp

+/*
+ * 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/ElementAnimation.h"
+
+#include "core/animation/DocumentTimeline.h"
+#include "core/css/CSSParser.h"
+#include "core/css/resolver/StyleResolver.h"
+#include "core/page/RuntimeCSSEnabled.h"
+#include "wtf/text/StringBuilder.h"
+
+
+namespace WebCore {
+
+namespace {
+
+static CSSPropertyID camelCaseCSSPropertyNameToID(StringImpl* propertyName)
+{
+    typedef HashMap<StringImpl*, CSSPropertyID> CSSPropertyIDMap;
+    DEFINE_STATIC_LOCAL(CSSPropertyIDMap, map, ());
+
+    CSSPropertyID id = map.get(propertyName);
+
+    if (propertyName->find('-') != kNotFound)
+        return CSSPropertyInvalid;
+
+    if (!id) {
+        StringBuilder builder;
+        size_t position = 0;
+        size_t end;
+        while ((end = propertyName->find(isASCIIUpper, position)) != kNotFound) {
+            builder.append(propertyName->substring(position, end) + "-" + toASCIILower((*propertyName)[end]));
+            position = end + 1;
+        }
+        builder.append(propertyName->substring(position));
+        // Doesn't handle prefixed properties.

[esprehn, 2013/12/11 00:26:11]

We won't be able to ship this until either transform is finished and unprefixed
or you support prefixes.

[rjwright, 2013/12/11 03:12:12]

See issue description.

+        id = cssPropertyID(builder.toString());
+        if (id != CSSPropertyInvalid && RuntimeCSSEnabled::isCSSPropertyEnabled(id))
+            map.add(propertyName, id);
+    }
+
+    return id;
+}
+
+} // namespace
+
+void ElementAnimation::animate(Element* element, Vector<Dictionary> keyframeDictionaryVector)
+{
+    ASSERT(RuntimeEnabledFeatures::webAnimationsAPIEnabled());

[esprehn, 2013/12/11 00:26:11]

You need an early return for when calling this on elements that are not in
active documents.

if (!document.isActive())
  return;

[rjwright, 2013/12/11 03:12:12]

Why?

+
+    KeyframeAnimationEffect::KeyframeVector keyframes;

[esprehn, 2013/12/11 00:26:11]

You need to call updateLayoutIgnorePendingStylesheets() or
updateStyleIfNeeded(), otherwise all relative values below are computed wrong
since you didn't update style so 2em has nothing to resolve against.

Does animations support animating from 20% to 50% on width? That would require
doing a layout here.

[rjwright, 2013/12/11 03:12:12]

See issue description.

+    Vector<RefPtr<MutableStylePropertySet> > propertySetVector;
+
+    for (size_t i = 0; i < keyframeDictionaryVector.size(); ++i) {
+        RefPtr<MutableStylePropertySet> propertySet = MutableStylePropertySet::create();
+        propertySetVector.append(propertySet);
+
+        RefPtr<Keyframe> keyframe = Keyframe::create();
+        keyframes.append(keyframe);
+
+        double offset;
+        if (keyframeDictionaryVector[i].get("offset", offset)) {
+            keyframe->setOffset(offset);
+        } else {
+            // FIXME: Web Animations CSS engine does not yet implement handling of
+            // keyframes without specified offsets. This check can be removed when
+            // that funcitonality is implemented.
+            ASSERT_NOT_REACHED();
+            return;
+        }
+
+        String compositeString;
+        keyframeDictionaryVector[i].get("composite", compositeString);
+        if (compositeString == String("add"))

[esprehn, 2013/12/11 00:26:11]

Don't wrap in String, you want the char* overload. You're doing a malloc here
for no reason.

== "add"

[rjwright, 2013/12/11 03:12:12]

Done.

+            keyframe->setComposite(AnimationEffect::CompositeAdd);
+
+        Vector<String> keyframeProperties;
+        keyframeDictionaryVector[i].getOwnPropertyNames(keyframeProperties);
+
+        for (size_t j = 0; j < keyframeProperties.size(); ++j) {
+            String property = keyframeProperties[j];
+            CSSPropertyID id = camelCaseCSSPropertyNameToID(property.impl());
+
+            // FIXME: There is no way to store invalid properties or invalid values
+            // in a Keyframe object, so for now I just skip over them. Eventually we
+            // will need to support getFrames(), which should return exactly the
+            // keyframes that were input through the API. We will add a layer to wrap
+            // KeyframeAnimationEffect, store input keyframes and implement getFrames.

[esprehn, 2013/12/11 00:26:11]

I don't think this is how CSS generally works, we drop unknown properties. Your
API should probably work the same.

[rjwright, 2013/12/11 03:12:12]

This is required by the specification and is unrelated to CSS. It's a feature of
the JS API.

+            if (id == CSSPropertyInvalid || !CSSAnimations::isAnimatableProperty(id))
+                continue;
+
+            String value;
+            keyframeDictionaryVector[i].get(property, value);
+            propertySet->setProperty(id, value);
+        }
+    }
+
+    RefPtr<KeyframeAnimationEffect> effect = StyleResolver::createKeyframeAnimationEffect(element, propertySetVector, keyframes);

[esprehn, 2013/12/11 00:26:11]

document.ensureStyleResolver().createKeyframeAnimationEffect(...)

[rjwright, 2013/12/11 03:12:12]

As discussed in the issue description, this is a temporary measure until
resolution-independent animation primitives have been introduced.

Why do you think this needs to be non-static?

+
+    // FIXME: Totally hardcoded Timing for now. Will handle timing parameters later.
+    Timing timing;
+    timing.hasIterationDuration = true;
+    timing.iterationDuration = 1;
+
+    RefPtr<Animation> animation = Animation::create(element, effect, timing);
+    DocumentTimeline* timeline = element->document().timeline();
+    ASSERT(timeline);

[esprehn, 2013/12/11 00:26:11]

Timeline should return a reference, but we can fix that in a future patch.

+    timeline->play(animation.get());
+}
+
+} // namespace WebCore