Fewer reused duplicate symbol names in animation.

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

 // Copyright 2015 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/CSSScaleInterpolationType.h"
 
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "wtf/PtrUtil.h"
@@ skipping 37 matching lines @@
       if (array[i] != other.array[i])
         return false;
     }
     return isNone == other.isNone;
   }
 
   double array[3];
   bool isNone;
 };
 
-std::unique_ptr<InterpolableValue> createIdentityInterpolableValue() {
+std::unique_ptr<InterpolableValue> createScaleIdentity() {
   std::unique_ptr<InterpolableList> list = InterpolableList::create(3);
   for (size_t i = 0; i < 3; i++)
     list->set(i, InterpolableNumber::create(1));
   return std::move(list);
 }
 
 class InheritedScaleChecker : public InterpolationType::ConversionChecker {
  public:
   static std::unique_ptr<InheritedScaleChecker> create(const Scale& scale) {
     return WTF::wrapUnique(new InheritedScaleChecker(scale));
@@ skipping 117 matching lines @@
   toCSSScaleNonInterpolableValue(*value.nonInterpolableValue).setIsAdditive();
 }
 
 PairwiseInterpolationValue CSSScaleInterpolationType::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 = createScaleIdentity();
   else if (endListLength < startListLength)
-    end.interpolableValue = createIdentityInterpolableValue();
+    end.interpolableValue = createScaleIdentity();
 
   return PairwiseInterpolationValue(
       std::move(start.interpolableValue), std::move(end.interpolableValue),
       CSSScaleNonInterpolableValue::merge(
           toCSSScaleNonInterpolableValue(*start.nonInterpolableValue),
           toCSSScaleNonInterpolableValue(*end.nonInterpolableValue)));
 }
 
 InterpolationValue
 CSSScaleInterpolationType::maybeConvertStandardPropertyUnderlyingValue(
     const ComputedStyle& style) const {
   return Scale(style.scale()).createInterpolationValue();
 }
 
 void CSSScaleInterpolationType::composite(
     UnderlyingValueOwner& underlyingValueOwner,
     double underlyingFraction,
     const InterpolationValue& value,
     double interpolationFraction) const {
   if (toInterpolableList(*underlyingValueOwner.mutableValue().interpolableValue)
           .length() == 0) {
     underlyingValueOwner.mutableValue().interpolableValue =
-        createIdentityInterpolableValue();
+        createScaleIdentity();
   }
 
   const CSSScaleNonInterpolableValue& metadata =
       toCSSScaleNonInterpolableValue(*value.nonInterpolableValue);
   DCHECK(metadata.isStartAdditive() || metadata.isEndAdditive());
 
   InterpolableList& underlyingList = toInterpolableList(
       *underlyingValueOwner.mutableValue().interpolableValue);
   for (size_t i = 0; i < 3; i++) {
     InterpolableNumber& underlying =
@@ skipping 15 matching lines @@
   if (scale.isNone) {
     state.style()->setScale(nullptr);
     return;
   }
   state.style()->setScale(ScaleTransformOperation::create(
       scale.array[0], scale.array[1], scale.array[2],
       TransformOperation::Scale3D));
 }
 
 }  // namespace blink