Move static methods out of CSSLengthInterpolationType to LengthInterpolationFunctions

third_party/WebKit/Source/core/animation/CSSBorderImageLengthBoxInterpolationType.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/CSSBorderImageLengthBoxInterpolationType.h"
 
 #include "core/animation/BorderImageLengthBoxPropertyFunctions.h"
-#include "core/animation/CSSLengthInterpolationType.h"
+#include "core/animation/LengthInterpolationFunctions.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 enum SideIndex : unsigned {
@@ skipping 120 matching lines @@
     sides[SideTop] = &box.top();
     sides[SideRight] = &box.right();
     sides[SideBottom] = &box.bottom();
     sides[SideLeft] = &box.left();
 
     for (size_t i = 0; i < SideIndexCount; i++) {
         const BorderImageLength& side = *sides[i];
         if (side.isNumber()) {
             list->set(i, InterpolableNumber::create(side.number()));
         } else {
-            InterpolationValue convertedSide = CSSLengthInterpolationType::maybeConvertLength(side.length(), zoom);
+            InterpolationValue convertedSide = LengthInterpolationFunctions::maybeConvertLength(side.length(), zoom);
             if (!convertedSide)
                 return nullptr;
             list->set(i, std::move(convertedSide.interpolableValue));
             nonInterpolableValues[i] = convertedSide.nonInterpolableValue.release();
         }
     }
 
     return InterpolationValue(std::move(list), CSSBorderImageLengthBoxNonInterpolableValue::create(SideNumbers(box), std::move(nonInterpolableValues)));
 }
 
@@ skipping 39 matching lines @@
     sides[SideTop] = quad.top();
     sides[SideRight] = quad.right();
     sides[SideBottom] = quad.bottom();
     sides[SideLeft] = quad.left();
 
     for (size_t i = 0; i < SideIndexCount; i++) {
         const CSSPrimitiveValue& side = *sides[i];
         if (side.isNumber()) {
             list->set(i, InterpolableNumber::create(side.getDoubleValue()));
         } else {
-            InterpolationValue convertedSide = CSSLengthInterpolationType::maybeConvertCSSValue(side);
+            InterpolationValue convertedSide = LengthInterpolationFunctions::maybeConvertCSSValue(side);
             if (!convertedSide)
                 return nullptr;
             list->set(i, std::move(convertedSide.interpolableValue));
             nonInterpolableValues[i] = convertedSide.nonInterpolableValue.release();
         }
     }
 
     return InterpolationValue(std::move(list), CSSBorderImageLengthBoxNonInterpolableValue::create(SideNumbers(quad), std::move(nonInterpolableValues)));
 }
 
@@ skipping 28 matching lines @@
     InterpolationValue& underlyingValue = underlyingValueOwner.mutableValue();
     InterpolableList& underlyingList = toInterpolableList(*underlyingValue.interpolableValue);
     Vector<RefPtr<NonInterpolableValue>>& underlyingSideNonInterpolableValues = toCSSBorderImageLengthBoxNonInterpolableValue(*underlyingValue.nonInterpolableValue).sideNonInterpolableValues();
     const InterpolableList& list = toInterpolableList(*value.interpolableValue);
     const Vector<RefPtr<NonInterpolableValue>>& sideNonInterpolableValues = nonInterpolableValue.sideNonInterpolableValues();
 
     for (size_t i = 0; i < SideIndexCount; i++) {
         if (sideNumbers.isNumber[i])
             underlyingList.getMutable(i)->scaleAndAdd(underlyingFraction, *list.get(i));
         else
-            CSSLengthInterpolationType::composite(underlyingList.getMutable(i), underlyingSideNonInterpolableValues[i], underlyingFraction, *list.get(i), sideNonInterpolableValues[i].get());
+            LengthInterpolationFunctions::composite(underlyingList.getMutable(i), underlyingSideNonInterpolableValues[i], underlyingFraction, *list.get(i), sideNonInterpolableValues[i].get());
     }
 }
 
 void CSSBorderImageLengthBoxInterpolationType::apply(const InterpolableValue& interpolableValue, const NonInterpolableValue* nonInterpolableValue, InterpolationEnvironment& environment) const
 {
     const SideNumbers& sideNumbers = toCSSBorderImageLengthBoxNonInterpolableValue(nonInterpolableValue)->sideNumbers();
     const Vector<RefPtr<NonInterpolableValue>>& nonInterpolableValues = toCSSBorderImageLengthBoxNonInterpolableValue(nonInterpolableValue)->sideNonInterpolableValues();
     const InterpolableList& list = toInterpolableList(interpolableValue);
     const auto& convertSide = [&sideNumbers, &list, &environment, &nonInterpolableValues](size_t index) -> BorderImageLength {
         if (sideNumbers.isNumber[index])
             return clampTo<double>(toInterpolableNumber(list.get(index))->value(), 0);
-        return CSSLengthInterpolationType::createLength(*list.get(index), nonInterpolableValues[index].get(), environment.state().cssToLengthConversionData(), ValueRangeNonNegative);
+        return LengthInterpolationFunctions::createLength(*list.get(index), nonInterpolableValues[index].get(), environment.state().cssToLengthConversionData(), ValueRangeNonNegative);
     };
     BorderImageLengthBox box(
         convertSide(SideTop),
         convertSide(SideRight),
         convertSide(SideBottom),
         convertSide(SideLeft));
     BorderImageLengthBoxPropertyFunctions::setBorderImageLengthBox(cssProperty(), *environment.state().style(), box);
 }
 
 } // namespace blink