compositor-worker: cc->blink mutation plumbing

third_party/WebKit/Source/core/animation/CompositorMutationAnimations.cpp

Index: third_party/WebKit/Source/core/animation/CompositorMutationAnimations.cpp
diff --git a/third_party/WebKit/Source/core/animation/CompositorMutationAnimations.cpp b/third_party/WebKit/Source/core/animation/CompositorMutationAnimations.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c36b431748d8f778dc26f7d793f7f3495947c967
--- /dev/null
+++ b/third_party/WebKit/Source/core/animation/CompositorMutationAnimations.cpp
@@ -0,0 +1,82 @@
+// Copyright 2016 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 "CompositorMutationAnimations.h"
+
+#include "core/animation/Animation.h"
+#include "core/animation/AnimationTimeline.h"
+#include "core/animation/KeyframeEffect.h"
+#include "core/animation/KeyframeEffectModel.h"
+#include "core/animation/animatable/AnimatableDouble.h"
+#include "core/animation/animatable/AnimatableTransform.h"
+#include "core/animation/animatable/AnimatableValue.h"
+#include "platform/TraceEvent.h"
+#include "platform/graphics/CompositorMutation.h"
+#include "platform/transforms/Matrix3DTransformOperation.h"
+#include "platform/transforms/MatrixTransformOperation.h"
+#include "platform/transforms/TransformOperations.h"
+
+namespace blink {
+
+namespace {
+
+    // Create animation with zero duration, fill mode forward, and two key frames
+    // with same value. This animation is always running and by updating the
+    // key frames we are able to control the applied value.
+    static KeyframeEffect* createInfiniteKeyFrameEffect(Element& element, CSSPropertyID propertyId, PassRefPtr<AnimatableValue> value)

[esprehn, 2016/02/17 01:32:36]

don't indent namespace code

[majidvp, 2016/02/22 17:59:48]

Done.

+    {
+        AnimatableValueKeyframeVector keyframes(2);
+        keyframes[0] = AnimatableValueKeyframe::create();
+        keyframes[0]->setOffset(0.0);
+        keyframes[0]->setPropertyValue(propertyId, value.get());
+        keyframes[1] = AnimatableValueKeyframe::create();
+        keyframes[1]->setOffset(1.0);
+        keyframes[1]->setPropertyValue(propertyId, value.get());
+        keyframes[1]->setComposite(EffectModel::CompositeReplace);
+
+        Timing timing;
+        timing.iterationDuration = 0;
+        timing.fillMode = Timing::FillModeForwards;
+
+        AnimatableValueKeyframeEffectModel* effectModel = AnimatableValueKeyframeEffectModel::create(keyframes);
+        return KeyframeEffect::create(&element, effectModel, timing);
+    }
+
+    static Animation* createOrUpdateAnimation(Animation* animation, Element& element, CSSPropertyID propertyId, PassRefPtr<AnimatableValue> newValue)
+    {
+        if (!animation) {
+            KeyframeEffect* keyframeEffect = createInfiniteKeyFrameEffect(element, propertyId, newValue);
+            return element.document().timeline().play(keyframeEffect);
+        }
+
+        KeyframeEffect* keyframeEffect = toKeyframeEffect(animation->effect());
+        auto effectModel = toAnimatableValueKeyframeEffectModel(keyframeEffect->model());
+        const KeyframeVector& frames = effectModel->getFrames();
+        KeyframeVector newFrames(2);
+        newFrames[0] = toAnimatableValueKeyframe(frames[0]->clone().get());
+        newFrames[1] = toAnimatableValueKeyframe(frames[1]->clone().get());
+        toAnimatableValueKeyframe(newFrames[1].get())->setPropertyValue(propertyId, newValue);
+        effectModel->setFrames(newFrames);
+        return animation;
+    }
+
+} // namespace
+
+void CompositorMutationAnimations::applyUpdate(Element& element, const CompositorMutation& mutation)
+{
+    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), "CompositorMutationAnimations::applyUpdate");
+
+    if (mutation.isOpacityMutated()) {
+        RefPtr<AnimatableValue> animatableValue = AnimatableDouble::create(mutation.opacity());
+        m_opacityAnimation = createOrUpdateAnimation(m_opacityAnimation, element, CSSPropertyOpacity, animatableValue.release());
+    }
+    if (mutation.isTransformMutated()) {
+        TransformOperations ops;
+        ops.operations().append(Matrix3DTransformOperation::create(TransformationMatrix(mutation.transform())));
+        RefPtr<AnimatableValue> animatableValue = AnimatableTransform::create(ops, 1);
+        m_transformAnimation = createOrUpdateAnimation(m_transformAnimation, element, CSSPropertyTransform, animatableValue.release());
+    }
+}
+
+} // namespace blink