Add additive animation support for CSS property translate

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

+// 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 "core/animation/CSSTranslateInterpolationType.h"
+
+#include "core/animation/CSSLengthInterpolationType.h"
+#include "core/css/CSSValueList.h"
+#include "core/css/resolver/StyleResolverState.h"
+#include "platform/transforms/TranslateTransformOperation.h"
+
+namespace blink {
+
+namespace {
+
+class ParentTranslateChecker : public InterpolationType::ConversionChecker {
+public:
+    ~ParentTranslateChecker() {}
+
+    static PassOwnPtr<ParentTranslateChecker> create(PassRefPtr<TranslateTransformOperation> parentTranslate)
+    {
+        return adoptPtr(new ParentTranslateChecker(parentTranslate));
+    }
+
+    bool isValid(const InterpolationEnvironment& environment, const InterpolationValue& underlying) const final
+    {
+        const TransformOperation* parentTranslate = environment.state().parentStyle()->translate();
+        if (m_parentTranslate == parentTranslate)
+            return true;
+        if (!m_parentTranslate || !parentTranslate)
+            return false;
+        return *m_parentTranslate == *parentTranslate;
+    }
+
+private:
+    ParentTranslateChecker(PassRefPtr<TranslateTransformOperation> parentTranslate)
+        : m_parentTranslate(parentTranslate)
+    { }
+
+    RefPtr<TransformOperation> m_parentTranslate;
+};
+
+enum TranslateComponentIndex {
+    TranslateX,
+    TranslateY,
+    TranslateZ,
+    TranslateComponentIndexCount,
+};
+
+InterpolationValue createNeutralValue()
+{
+    OwnPtr<InterpolableList> result = InterpolableList::create(TranslateComponentIndexCount);
+    result->set(TranslateX, CSSLengthInterpolationType::createNeutralInterpolableValue());
+    result->set(TranslateY, CSSLengthInterpolationType::createNeutralInterpolableValue());
+    result->set(TranslateZ, CSSLengthInterpolationType::createNeutralInterpolableValue());
+    return InterpolationValue(result.release());
+}
+
+InterpolationValue convertTranslateOperation(const TranslateTransformOperation* translate, double zoom)
+{
+    if (!translate)
+        return createNeutralValue();
+
+    OwnPtr<InterpolableList> result = InterpolableList::create(TranslateComponentIndexCount);
+    result->set(TranslateX, CSSLengthInterpolationType::maybeConvertLength(translate->x(), zoom).interpolableValue.release());
+    result->set(TranslateY, CSSLengthInterpolationType::maybeConvertLength(translate->y(), zoom).interpolableValue.release());
+    result->set(TranslateZ, CSSLengthInterpolationType::maybeConvertLength(Length(translate->z(), Fixed), zoom).interpolableValue.release());
+    return InterpolationValue(result.release());
+}
+
+} // namespace
+
+InterpolationValue CSSTranslateInterpolationType::maybeConvertNeutral(const InterpolationValue& underlying, ConversionCheckers&) const
+{
+    return createNeutralValue();
+}
+
+InterpolationValue CSSTranslateInterpolationType::maybeConvertInitial() const
+{
+    return createNeutralValue();
+}
+
+InterpolationValue CSSTranslateInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
+{

[Eric Willigers, 2016/02/17 07:15:50]

Do we need
if (!state.parentStyle()) return nullptr;

[alancutter (OOO until 2018), 2016/02/17 23:50:22]

This check is no longer needed, I will make a clean up patch to remove existing
instances of them.

+    TranslateTransformOperation* parentTranslate = state.parentStyle()->translate();
+    conversionCheckers.append(ParentTranslateChecker::create(parentTranslate));
+    return convertTranslateOperation(parentTranslate, state.parentStyle()->effectiveZoom());
+}
+
+InterpolationValue CSSTranslateInterpolationType::maybeConvertValue(const CSSValue& value, const StyleResolverState&, ConversionCheckers&) const
+{
+    if (!value.isBaseValueList())
+        return nullptr;
+
+    const CSSValueList& list = toCSSValueList(value);
+    if (list.length() < 1 || list.length() > 3)
+        return nullptr;
+
+    OwnPtr<InterpolableList> result = InterpolableList::create(TranslateComponentIndexCount);
+    for (size_t i = 0; i < TranslateComponentIndexCount; i++) {
+        InterpolationValue component = nullptr;
+        if (i < list.length()) {
+            component = CSSLengthInterpolationType::maybeConvertCSSValue(*list.item(i));
+            if (!component)
+                return nullptr;
+        } else {
+            component = InterpolationValue(CSSLengthInterpolationType::createNeutralInterpolableValue());
+        }
+        result->set(i, component.interpolableValue.release());
+    }
+    return InterpolationValue(result.release());
+}
+
+InterpolationValue CSSTranslateInterpolationType::maybeConvertUnderlyingValue(const InterpolationEnvironment& environment) const
+{
+    return convertTranslateOperation(environment.state().style()->translate(), environment.state().style()->effectiveZoom());
+}
+
+void CSSTranslateInterpolationType::apply(const InterpolableValue& interpolableValue, const NonInterpolableValue*, InterpolationEnvironment& environment) const
+{
+    const InterpolableList& list = toInterpolableList(interpolableValue);
+    const CSSToLengthConversionData& conversionData = environment.state().cssToLengthConversionData();
+    Length x = CSSLengthInterpolationType::resolveInterpolableLength(*list.get(TranslateX), nullptr, conversionData, ValueRangeAll);
+    Length y = CSSLengthInterpolationType::resolveInterpolableLength(*list.get(TranslateY), nullptr, conversionData, ValueRangeAll);
+    float z = CSSLengthInterpolationType::resolveInterpolableLength(*list.get(TranslateZ), nullptr, conversionData, ValueRangeAll).pixels();
+
+    RefPtr<TranslateTransformOperation> result = nullptr;
+    if (!x.isZero() || !y.isZero() || z != 0)
+        result = TranslateTransformOperation::create(x, y, z, TransformOperation::Translate3D);
+    environment.state().style()->setTranslate(result.release());
+}
+
+} // namespace blink