Fewer reused duplicate symbol names in animation.

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/LengthInterpolationFunctions.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "platform/transforms/TranslateTransformOperation.h"
@@ skipping 41 matching lines @@
   RefPtr<TransformOperation> m_inheritedTranslate;
 };
 
 enum TranslateComponentIndex : unsigned {
   TranslateX,
   TranslateY,
   TranslateZ,
   TranslateComponentIndexCount,
 };
 
-std::unique_ptr<InterpolableValue> createIdentityInterpolableValue() {
+std::unique_ptr<InterpolableValue> createTranslateIdentity() {
   std::unique_ptr<InterpolableList> result =
       InterpolableList::create(TranslateComponentIndexCount);
   result->set(TranslateX,
               LengthInterpolationFunctions::createNeutralInterpolableValue());
   result->set(TranslateY,
               LengthInterpolationFunctions::createNeutralInterpolableValue());
   result->set(TranslateZ,
               LengthInterpolationFunctions::createNeutralInterpolableValue());
   return std::move(result);
 }
@@ skipping 16 matching lines @@
                               Length(translate->z(), Fixed), zoom)
                               .interpolableValue);
   return InterpolationValue(std::move(result));
 }
 
 }  // namespace
 
 InterpolationValue CSSTranslateInterpolationType::maybeConvertNeutral(
     const InterpolationValue& underlying,
     ConversionCheckers&) const {
-  return InterpolationValue(createIdentityInterpolableValue());
+  return InterpolationValue(createTranslateIdentity());
 }
 
 InterpolationValue CSSTranslateInterpolationType::maybeConvertInitial(
     const StyleResolverState&,
     ConversionCheckers&) const {
   return createNoneValue();
 }
 
 InterpolationValue CSSTranslateInterpolationType::maybeConvertInherit(
     const StyleResolverState& state,
@@ skipping 36 matching lines @@
   return InterpolationValue(std::move(result));
 }
 
 PairwiseInterpolationValue CSSTranslateInterpolationType::maybeMergeSingles(
     InterpolationValue&& start,
     InterpolationValue&& end) const {
   size_t startListLength =
       toInterpolableList(*start.interpolableValue).length();
   size_t endListLength = toInterpolableList(*end.interpolableValue).length();
   if (startListLength < endListLength)
-    start.interpolableValue = createIdentityInterpolableValue();
+    start.interpolableValue = createTranslateIdentity();
   else if (endListLength < startListLength)
-    end.interpolableValue = createIdentityInterpolableValue();
+    end.interpolableValue = createTranslateIdentity();
 
   return PairwiseInterpolationValue(std::move(start.interpolableValue),
                                     std::move(end.interpolableValue));
 }
 
 InterpolationValue
 CSSTranslateInterpolationType::maybeConvertStandardPropertyUnderlyingValue(
     const ComputedStyle& style) const {
   return convertTranslateOperation(style.translate(), style.effectiveZoom());
 }
 
 void CSSTranslateInterpolationType::composite(
     UnderlyingValueOwner& underlyingValueOwner,
     double underlyingFraction,
     const InterpolationValue& value,
     double interpolationFraction) const {
   if (isNoneValue(value)) {
     return;
   }
 
   if (isNoneValue(underlyingValueOwner.mutableValue())) {
     underlyingValueOwner.mutableValue().interpolableValue =
-        createIdentityInterpolableValue();
+        createTranslateIdentity();
   }
 
   return CSSInterpolationType::composite(
       underlyingValueOwner, underlyingFraction, value, interpolationFraction);
 }
 
 void CSSTranslateInterpolationType::applyStandardPropertyValue(
     const InterpolableValue& interpolableValue,
     const NonInterpolableValue*,
     StyleResolverState& state) const {
@@ skipping 12 matching lines @@
                 *list.get(TranslateZ), nullptr, conversionData, ValueRangeAll)
                 .pixels();
 
   RefPtr<TranslateTransformOperation> result =
       TranslateTransformOperation::create(x, y, z,
                                           TransformOperation::Translate3D);
   state.style()->setTranslate(std::move(result));
 }
 
 }  // namespace blink