chromium/src/third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.cc - manifest_repos/chromium_src - Git at Google

 // 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 "third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.h"

 #include <memory>
 #include <utility>

 #include "base/memory/ptr_util.h"
 #include "third_party/blink/renderer/core/animation/interpolable_length.h"
 #include "third_party/blink/renderer/core/animation/list_interpolation_functions.h"
 #include "third_party/blink/renderer/core/animation/side_index.h"
 #include "third_party/blink/renderer/core/css/css_identifier_value.h"
 #include "third_party/blink/renderer/core/css/css_property_names.h"
 #include "third_party/blink/renderer/core/css/css_quad_value.h"
 #include "third_party/blink/renderer/core/css/resolver/style_resolver_state.h"
 #include "third_party/blink/renderer/core/style/computed_style.h"

 namespace blink {

 namespace {

 enum class SideType {
   kNumber,
   kAuto,
   kLength,
 };

 const BorderImageLengthBox& GetBorderImageLengthBox(
     const CSSProperty& property,
     const ComputedStyle& style) {
   switch (property.PropertyID()) {
     case CSSPropertyID::kBorderImageOutset:
       return style.BorderImageOutset();
     case CSSPropertyID::kBorderImageWidth:
       return style.BorderImageWidth();
     case CSSPropertyID::kWebkitMaskBoxImageOutset:
       return style.MaskBoxImageOutset();
     case CSSPropertyID::kWebkitMaskBoxImageWidth:
       return style.MaskBoxImageWidth();
     default:
       NOTREACHED();
       return GetBorderImageLengthBox(
           CSSProperty::Get(CSSPropertyID::kBorderImageOutset),
           ComputedStyle::InitialStyle());
   }
 }

 void SetBorderImageLengthBox(const CSSProperty& property,
                              ComputedStyle& style,
                              const BorderImageLengthBox& box) {
   switch (property.PropertyID()) {
     case CSSPropertyID::kBorderImageOutset:
       style.SetBorderImageOutset(box);
       break;
     case CSSPropertyID::kWebkitMaskBoxImageOutset:
       style.SetMaskBoxImageOutset(box);
       break;
     case CSSPropertyID::kBorderImageWidth:
       style.SetBorderImageWidth(box);
       break;
     case CSSPropertyID::kWebkitMaskBoxImageWidth:
       style.SetMaskBoxImageWidth(box);
       break;
     default:
       NOTREACHED();
       break;
   }
 }

 }  // namespace

 // The NonInterpolableValue for the CSSBorderImageLengthBoxInterpolationType
 // as a whole is a NonInterpolableList with kSideIndexCount items. Each entry
 // in that list is either an instance of this class, or it's the
 // NonInterpolableValue returned by LengthInterpolationFunctions.
 class CSSBorderImageLengthBoxSideNonInterpolableValue
     : public NonInterpolableValue {
  public:
   static scoped_refptr<CSSBorderImageLengthBoxSideNonInterpolableValue> Create(
       SideType side_type) {
     DCHECK_NE(SideType::kLength, side_type);
     return base::AdoptRef(
         new CSSBorderImageLengthBoxSideNonInterpolableValue(side_type));
   }

   SideType GetSideType() const { return side_type_; }

   DECLARE_NON_INTERPOLABLE_VALUE_TYPE();

  private:
   CSSBorderImageLengthBoxSideNonInterpolableValue(const SideType side_type)
       : side_type_(side_type) {}

   const SideType side_type_;
 };

 DEFINE_NON_INTERPOLABLE_VALUE_TYPE(
     CSSBorderImageLengthBoxSideNonInterpolableValue);
 template <>
 struct DowncastTraits<CSSBorderImageLengthBoxSideNonInterpolableValue> {
   static bool AllowFrom(const NonInterpolableValue* value) {
     return value && AllowFrom(*value);
   }
   static bool AllowFrom(const NonInterpolableValue& value) {
     return value.GetType() ==
            CSSBorderImageLengthBoxSideNonInterpolableValue::static_type_;
   }
 };

 namespace {

 SideType GetSideType(const BorderImageLength& side) {
   if (side.IsNumber()) {
     return SideType::kNumber;
   }
   if (side.length().IsAuto()) {
     return SideType::kAuto;
   }
   DCHECK(side.length().IsSpecified());
   return SideType::kLength;
 }

 SideType GetSideType(const CSSValue& side) {
   auto* side_primitive_value = DynamicTo<CSSPrimitiveValue>(side);
   if (side_primitive_value && side_primitive_value->IsNumber()) {
     return SideType::kNumber;
   }
   auto* side_identifier_value = DynamicTo<CSSIdentifierValue>(side);
   if (side_identifier_value &&
       side_identifier_value->GetValueID() == CSSValueID::kAuto) {
     return SideType::kAuto;
   }
   return SideType::kLength;
 }

 SideType GetSideType(const NonInterpolableValue* side) {
   // We interpret nullptr as kLength, because LengthInterpolationFunctions
   // returns a nullptr NonInterpolableValue if there is no percent unit.
   //
   // In cases where LengthInterpolationFunctions is not used to convert the
   // value (kAuto, kNumber), we will always have a non-interpolable value of
   // type CSSBorderImageLengthBoxSideNonInterpolableValue.
   auto* non_interpolable =
       DynamicTo<CSSBorderImageLengthBoxSideNonInterpolableValue>(side);
   if (!side || !non_interpolable)
     return SideType::kLength;
   return non_interpolable->GetSideType();
 }

 struct SideTypes {
   explicit SideTypes(const BorderImageLengthBox& box) {
     type[kSideTop] = GetSideType(box.Top());
     type[kSideRight] = GetSideType(box.Right());
     type[kSideBottom] = GetSideType(box.Bottom());
     type[kSideLeft] = GetSideType(box.Left());
   }
   explicit SideTypes(const CSSQuadValue& quad) {
     type[kSideTop] = GetSideType(*quad.Top());
     type[kSideRight] = GetSideType(*quad.Right());
     type[kSideBottom] = GetSideType(*quad.Bottom());
     type[kSideLeft] = GetSideType(*quad.Left());
   }
   explicit SideTypes(const InterpolationValue& underlying) {
     const auto& non_interpolable_list =
         To<NonInterpolableList>(*underlying.non_interpolable_value);
     DCHECK_EQ(kSideIndexCount, non_interpolable_list.length());
     type[kSideTop] = GetSideType(non_interpolable_list.Get(0));
     type[kSideRight] = GetSideType(non_interpolable_list.Get(1));
     type[kSideBottom] = GetSideType(non_interpolable_list.Get(2));
     type[kSideLeft] = GetSideType(non_interpolable_list.Get(3));
   }

   bool operator==(const SideTypes& other) const {
     for (size_t i = 0; i < kSideIndexCount; i++) {
       if (type[i] != other.type[i])
         return false;
     }
     return true;
   }
   bool operator!=(const SideTypes& other) const { return !(*this == other); }

   SideType type[kSideIndexCount];
 };

 class UnderlyingSideTypesChecker
     : public CSSInterpolationType::CSSConversionChecker {
  public:

   explicit UnderlyingSideTypesChecker(const SideTypes& underlying_side_types)
       : underlying_side_types_(underlying_side_types) {}

  private:
   bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     return underlying_side_types_ == SideTypes(underlying);
   }

   const SideTypes underlying_side_types_;
 };

 class InheritedSideTypesChecker
     : public CSSInterpolationType::CSSConversionChecker {
  public:
   InheritedSideTypesChecker(const CSSProperty& property,
                             const SideTypes& inherited_side_types)
       : property_(property), inherited_side_types_(inherited_side_types) {}

  private:
   bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
     return inherited_side_types_ ==
            SideTypes(GetBorderImageLengthBox(property_, *state.ParentStyle()));
   }

   const CSSProperty& property_;
   const SideTypes inherited_side_types_;
 };

 InterpolationValue ConvertBorderImageNumberSide(double number) {
   return InterpolationValue(
       std::make_unique<InterpolableNumber>(number),
       CSSBorderImageLengthBoxSideNonInterpolableValue::Create(
           SideType::kNumber));
 }

 InterpolationValue ConvertBorderImageAutoSide() {
   return InterpolationValue(
       std::make_unique<InterpolableList>(0),
       CSSBorderImageLengthBoxSideNonInterpolableValue::Create(SideType::kAuto));
 }

 InterpolationValue ConvertBorderImageLengthBox(const BorderImageLengthBox& box,
                                                double zoom) {
   auto list = std::make_unique<InterpolableList>(kSideIndexCount);
   Vector<scoped_refptr<const NonInterpolableValue>> non_interpolable_values(
       kSideIndexCount);
   const BorderImageLength* sides[kSideIndexCount] = {};
   sides[kSideTop] = &box.Top();
   sides[kSideRight] = &box.Right();
   sides[kSideBottom] = &box.Bottom();
   sides[kSideLeft] = &box.Left();

   return ListInterpolationFunctions::CreateList(
       kSideIndexCount, [&sides, zoom](wtf_size_t index) {
         const BorderImageLength& side = *sides[index];
         if (side.IsNumber())
           return ConvertBorderImageNumberSide(side.Number());
         if (side.length().IsAuto())
           return ConvertBorderImageAutoSide();
         return InterpolationValue(
             InterpolableLength::MaybeConvertLength(side.length(), zoom));
       });
 }

 void CompositeSide(UnderlyingValue& underlying_value,
                    double underlying_fraction,
                    const InterpolableValue& interpolable_value,
                    const NonInterpolableValue* non_interpolable_value) {
   switch (GetSideType(non_interpolable_value)) {
     case SideType::kNumber:
     case SideType::kLength:
       underlying_value.MutableInterpolableValue().ScaleAndAdd(
           underlying_fraction, interpolable_value);
       break;
     case SideType::kAuto:
       break;
     default:
       NOTREACHED();
       break;
   }
 }

 bool NonInterpolableSidesAreCompatible(const NonInterpolableValue* a,
                                        const NonInterpolableValue* b) {
   return GetSideType(a) == GetSideType(b);
 }

 }  // namespace

 InterpolationValue
 CSSBorderImageLengthBoxInterpolationType::MaybeConvertNeutral(
     const InterpolationValue& underlying,
     ConversionCheckers& conversion_checkers) const {
   SideTypes underlying_side_types(underlying);
   conversion_checkers.push_back(
       std::make_unique<UnderlyingSideTypesChecker>(underlying_side_types));
   return InterpolationValue(underlying.interpolable_value->CloneAndZero(),
                             underlying.non_interpolable_value);
 }

 InterpolationValue
 CSSBorderImageLengthBoxInterpolationType::MaybeConvertInitial(
     const StyleResolverState&,
     ConversionCheckers&) const {
   return ConvertBorderImageLengthBox(
       GetBorderImageLengthBox(CssProperty(), ComputedStyle::InitialStyle()), 1);
 }

 InterpolationValue
 CSSBorderImageLengthBoxInterpolationType::MaybeConvertInherit(
     const StyleResolverState& state,
     ConversionCheckers& conversion_checkers) const {
   const BorderImageLengthBox& inherited =
       GetBorderImageLengthBox(CssProperty(), *state.ParentStyle());
   conversion_checkers.push_back(std::make_unique<InheritedSideTypesChecker>(
       CssProperty(), SideTypes(inherited)));
   return ConvertBorderImageLengthBox(inherited,
                                      state.ParentStyle()->EffectiveZoom());
 }

 InterpolationValue CSSBorderImageLengthBoxInterpolationType::MaybeConvertValue(
     const CSSValue& value,
     const StyleResolverState*,
     ConversionCheckers&) const {
   const auto* quad = DynamicTo<CSSQuadValue>(value);
   if (!quad)
     return nullptr;

   auto list = std::make_unique<InterpolableList>(kSideIndexCount);
   Vector<scoped_refptr<const NonInterpolableValue>> non_interpolable_values(
       kSideIndexCount);
   const CSSValue* sides[kSideIndexCount] = {};
   sides[kSideTop] = quad->Top();
   sides[kSideRight] = quad->Right();
   sides[kSideBottom] = quad->Bottom();
   sides[kSideLeft] = quad->Left();

   return ListInterpolationFunctions::CreateList(
       kSideIndexCount, [&sides](wtf_size_t index) {
         const CSSValue& side = *sides[index];

         auto* side_primitive_value = DynamicTo<CSSPrimitiveValue>(side);
         if (side_primitive_value && side_primitive_value->IsNumber()) {
           return ConvertBorderImageNumberSide(
               side_primitive_value->GetDoubleValue());
         }

         auto* side_identifier_value = DynamicTo<CSSIdentifierValue>(side);
         if (side_identifier_value &&
             side_identifier_value->GetValueID() == CSSValueID::kAuto) {
           return ConvertBorderImageAutoSide();
         }

         return InterpolationValue(
             InterpolableLength::MaybeConvertCSSValue(side));
       });
 }

 InterpolationValue CSSBorderImageLengthBoxInterpolationType::
     MaybeConvertStandardPropertyUnderlyingValue(
         const ComputedStyle& style) const {
   return ConvertBorderImageLengthBox(
       GetBorderImageLengthBox(CssProperty(), style), style.EffectiveZoom());
 }

 PairwiseInterpolationValue
 CSSBorderImageLengthBoxInterpolationType::MaybeMergeSingles(
     InterpolationValue&& start,
     InterpolationValue&& end) const {
   if (SideTypes(start) != SideTypes(end))
     return nullptr;

   return PairwiseInterpolationValue(std::move(start.interpolable_value),
                                     std::move(end.interpolable_value),
                                     std::move(start.non_interpolable_value));
 }

 void CSSBorderImageLengthBoxInterpolationType::Composite(
     UnderlyingValueOwner& underlying_value_owner,
     double underlying_fraction,
     const InterpolationValue& value,
     double interpolation_fraction) const {
   ListInterpolationFunctions::Composite(
       underlying_value_owner, underlying_fraction, *this, value,
       ListInterpolationFunctions::LengthMatchingStrategy::kEqual,
       WTF::BindRepeating(
           ListInterpolationFunctions::InterpolableValuesKnownCompatible),
       WTF::BindRepeating(NonInterpolableSidesAreCompatible),
       WTF::BindRepeating(CompositeSide));
 }

 void CSSBorderImageLengthBoxInterpolationType::ApplyStandardPropertyValue(
     const InterpolableValue& interpolable_value,
     const NonInterpolableValue* non_interpolable_value,
     StyleResolverState& state) const {
   const auto& list = To<InterpolableList>(interpolable_value);
   const auto& non_interpolable_list =
       To<NonInterpolableList>(*non_interpolable_value);
   const auto& convert_side = [&list, &non_interpolable_list,
                               &state](wtf_size_t index) -> BorderImageLength {
     switch (GetSideType(non_interpolable_list.Get(index))) {
       case SideType::kNumber:
         return clampTo<double>(To<InterpolableNumber>(list.Get(index))->Value(),
                                0);
       case SideType::kAuto:
         return Length::Auto();
       case SideType::kLength:
         return To<InterpolableLength>(*list.Get(index))
             .CreateLength(state.CssToLengthConversionData(),
                           kValueRangeNonNegative);
       default:
         NOTREACHED();
         return Length::Auto();
     }
   };
   BorderImageLengthBox box(convert_side(kSideTop), convert_side(kSideRight),
                            convert_side(kSideBottom), convert_side(kSideLeft));
   SetBorderImageLengthBox(CssProperty(), *state.Style(), box);
 }

 }  // namespace blink
	// 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 "third_party/blink/renderer/core/animation/css_border_image_length_box_interpolation_type.h"

	#include <memory>
	#include <utility>

	#include "base/memory/ptr_util.h"
	#include "third_party/blink/renderer/core/animation/interpolable_length.h"
	#include "third_party/blink/renderer/core/animation/list_interpolation_functions.h"
	#include "third_party/blink/renderer/core/animation/side_index.h"
	#include "third_party/blink/renderer/core/css/css_identifier_value.h"
	#include "third_party/blink/renderer/core/css/css_property_names.h"
	#include "third_party/blink/renderer/core/css/css_quad_value.h"
	#include "third_party/blink/renderer/core/css/resolver/style_resolver_state.h"
	#include "third_party/blink/renderer/core/style/computed_style.h"

	namespace blink {

	namespace {

	enum class SideType {
	kNumber,
	kAuto,
	kLength,
	};

	const BorderImageLengthBox& GetBorderImageLengthBox(
	const CSSProperty& property,
	const ComputedStyle& style) {
	switch (property.PropertyID()) {
	case CSSPropertyID::kBorderImageOutset:
	return style.BorderImageOutset();
	case CSSPropertyID::kBorderImageWidth:
	return style.BorderImageWidth();
	case CSSPropertyID::kWebkitMaskBoxImageOutset:
	return style.MaskBoxImageOutset();
	case CSSPropertyID::kWebkitMaskBoxImageWidth:
	return style.MaskBoxImageWidth();
	default:
	NOTREACHED();
	return GetBorderImageLengthBox(
	CSSProperty::Get(CSSPropertyID::kBorderImageOutset),
	ComputedStyle::InitialStyle());
	}
	}

	void SetBorderImageLengthBox(const CSSProperty& property,
	ComputedStyle& style,
	const BorderImageLengthBox& box) {
	switch (property.PropertyID()) {
	case CSSPropertyID::kBorderImageOutset:
	style.SetBorderImageOutset(box);
	break;
	case CSSPropertyID::kWebkitMaskBoxImageOutset:
	style.SetMaskBoxImageOutset(box);
	break;
	case CSSPropertyID::kBorderImageWidth:
	style.SetBorderImageWidth(box);
	break;
	case CSSPropertyID::kWebkitMaskBoxImageWidth:
	style.SetMaskBoxImageWidth(box);
	break;
	default:
	NOTREACHED();
	break;
	}
	}

	} // namespace

	// The NonInterpolableValue for the CSSBorderImageLengthBoxInterpolationType
	// as a whole is a NonInterpolableList with kSideIndexCount items. Each entry
	// in that list is either an instance of this class, or it's the
	// NonInterpolableValue returned by LengthInterpolationFunctions.
	class CSSBorderImageLengthBoxSideNonInterpolableValue
	: public NonInterpolableValue {
	public:
	static scoped_refptr<CSSBorderImageLengthBoxSideNonInterpolableValue> Create(
	SideType side_type) {
	DCHECK_NE(SideType::kLength, side_type);
	return base::AdoptRef(
	new CSSBorderImageLengthBoxSideNonInterpolableValue(side_type));
	}

	SideType GetSideType() const { return side_type_; }

	DECLARE_NON_INTERPOLABLE_VALUE_TYPE();

	private:
	CSSBorderImageLengthBoxSideNonInterpolableValue(const SideType side_type)
	: side_type_(side_type) {}

	const SideType side_type_;
	};

	DEFINE_NON_INTERPOLABLE_VALUE_TYPE(
	CSSBorderImageLengthBoxSideNonInterpolableValue);
	template <>
	struct DowncastTraits<CSSBorderImageLengthBoxSideNonInterpolableValue> {
	static bool AllowFrom(const NonInterpolableValue* value) {
	return value && AllowFrom(*value);
	}
	static bool AllowFrom(const NonInterpolableValue& value) {
	return value.GetType() ==
	CSSBorderImageLengthBoxSideNonInterpolableValue::static_type_;
	}
	};

	namespace {

	SideType GetSideType(const BorderImageLength& side) {
	if (side.IsNumber()) {
	return SideType::kNumber;
	}
	if (side.length().IsAuto()) {
	return SideType::kAuto;
	}
	DCHECK(side.length().IsSpecified());
	return SideType::kLength;
	}

	SideType GetSideType(const CSSValue& side) {
	auto* side_primitive_value = DynamicTo<CSSPrimitiveValue>(side);
	if (side_primitive_value && side_primitive_value->IsNumber()) {
	return SideType::kNumber;
	}
	auto* side_identifier_value = DynamicTo<CSSIdentifierValue>(side);
	if (side_identifier_value &&
	side_identifier_value->GetValueID() == CSSValueID::kAuto) {
	return SideType::kAuto;
	}
	return SideType::kLength;
	}

	SideType GetSideType(const NonInterpolableValue* side) {
	// We interpret nullptr as kLength, because LengthInterpolationFunctions
	// returns a nullptr NonInterpolableValue if there is no percent unit.
	//
	// In cases where LengthInterpolationFunctions is not used to convert the
	// value (kAuto, kNumber), we will always have a non-interpolable value of
	// type CSSBorderImageLengthBoxSideNonInterpolableValue.
	auto* non_interpolable =
	DynamicTo<CSSBorderImageLengthBoxSideNonInterpolableValue>(side);
	if (!side \|\| !non_interpolable)
	return SideType::kLength;
	return non_interpolable->GetSideType();
	}

	struct SideTypes {
	explicit SideTypes(const BorderImageLengthBox& box) {
	type[kSideTop] = GetSideType(box.Top());
	type[kSideRight] = GetSideType(box.Right());
	type[kSideBottom] = GetSideType(box.Bottom());
	type[kSideLeft] = GetSideType(box.Left());
	}
	explicit SideTypes(const CSSQuadValue& quad) {
	type[kSideTop] = GetSideType(*quad.Top());
	type[kSideRight] = GetSideType(*quad.Right());
	type[kSideBottom] = GetSideType(*quad.Bottom());
	type[kSideLeft] = GetSideType(*quad.Left());
	}
	explicit SideTypes(const InterpolationValue& underlying) {
	const auto& non_interpolable_list =
	To<NonInterpolableList>(*underlying.non_interpolable_value);
	DCHECK_EQ(kSideIndexCount, non_interpolable_list.length());
	type[kSideTop] = GetSideType(non_interpolable_list.Get(0));
	type[kSideRight] = GetSideType(non_interpolable_list.Get(1));
	type[kSideBottom] = GetSideType(non_interpolable_list.Get(2));
	type[kSideLeft] = GetSideType(non_interpolable_list.Get(3));
	}

	bool operator==(const SideTypes& other) const {
	for (size_t i = 0; i < kSideIndexCount; i++) {
	if (type[i] != other.type[i])
	return false;
	}
	return true;
	}
	bool operator!=(const SideTypes& other) const { return !(*this == other); }

	SideType type[kSideIndexCount];
	};

	class UnderlyingSideTypesChecker
	: public CSSInterpolationType::CSSConversionChecker {
	public:

	explicit UnderlyingSideTypesChecker(const SideTypes& underlying_side_types)
	: underlying_side_types_(underlying_side_types) {}

	private:
	bool IsValid(const StyleResolverState&,
	const InterpolationValue& underlying) const final {
	return underlying_side_types_ == SideTypes(underlying);
	}

	const SideTypes underlying_side_types_;
	};

	class InheritedSideTypesChecker
	: public CSSInterpolationType::CSSConversionChecker {
	public:
	InheritedSideTypesChecker(const CSSProperty& property,
	const SideTypes& inherited_side_types)
	: property_(property), inherited_side_types_(inherited_side_types) {}

	private:
	bool IsValid(const StyleResolverState& state,
	const InterpolationValue& underlying) const final {
	return inherited_side_types_ ==
	SideTypes(GetBorderImageLengthBox(property_, *state.ParentStyle()));
	}

	const CSSProperty& property_;
	const SideTypes inherited_side_types_;
	};

	InterpolationValue ConvertBorderImageNumberSide(double number) {
	return InterpolationValue(
	std::make_unique<InterpolableNumber>(number),
	CSSBorderImageLengthBoxSideNonInterpolableValue::Create(
	SideType::kNumber));
	}

	InterpolationValue ConvertBorderImageAutoSide() {
	return InterpolationValue(
	std::make_unique<InterpolableList>(0),
	CSSBorderImageLengthBoxSideNonInterpolableValue::Create(SideType::kAuto));
	}

	InterpolationValue ConvertBorderImageLengthBox(const BorderImageLengthBox& box,
	double zoom) {
	auto list = std::make_unique<InterpolableList>(kSideIndexCount);
	Vector<scoped_refptr<const NonInterpolableValue>> non_interpolable_values(
	kSideIndexCount);
	const BorderImageLength* sides[kSideIndexCount] = {};
	sides[kSideTop] = &box.Top();
	sides[kSideRight] = &box.Right();
	sides[kSideBottom] = &box.Bottom();
	sides[kSideLeft] = &box.Left();

	return ListInterpolationFunctions::CreateList(
	kSideIndexCount, [&sides, zoom](wtf_size_t index) {
	const BorderImageLength& side = *sides[index];
	if (side.IsNumber())
	return ConvertBorderImageNumberSide(side.Number());
	if (side.length().IsAuto())
	return ConvertBorderImageAutoSide();
	return InterpolationValue(
	InterpolableLength::MaybeConvertLength(side.length(), zoom));
	});
	}

	void CompositeSide(UnderlyingValue& underlying_value,
	double underlying_fraction,
	const InterpolableValue& interpolable_value,
	const NonInterpolableValue* non_interpolable_value) {
	switch (GetSideType(non_interpolable_value)) {
	case SideType::kNumber:
	case SideType::kLength:
	underlying_value.MutableInterpolableValue().ScaleAndAdd(
	underlying_fraction, interpolable_value);
	break;
	case SideType::kAuto:
	break;
	default:
	NOTREACHED();
	break;
	}
	}

	bool NonInterpolableSidesAreCompatible(const NonInterpolableValue* a,
	const NonInterpolableValue* b) {
	return GetSideType(a) == GetSideType(b);
	}

	} // namespace

	InterpolationValue
	CSSBorderImageLengthBoxInterpolationType::MaybeConvertNeutral(
	const InterpolationValue& underlying,
	ConversionCheckers& conversion_checkers) const {
	SideTypes underlying_side_types(underlying);
	conversion_checkers.push_back(
	std::make_unique<UnderlyingSideTypesChecker>(underlying_side_types));
	return InterpolationValue(underlying.interpolable_value->CloneAndZero(),
	underlying.non_interpolable_value);
	}

	InterpolationValue
	CSSBorderImageLengthBoxInterpolationType::MaybeConvertInitial(
	const StyleResolverState&,
	ConversionCheckers&) const {
	return ConvertBorderImageLengthBox(
	GetBorderImageLengthBox(CssProperty(), ComputedStyle::InitialStyle()), 1);
	}

	InterpolationValue
	CSSBorderImageLengthBoxInterpolationType::MaybeConvertInherit(
	const StyleResolverState& state,
	ConversionCheckers& conversion_checkers) const {
	const BorderImageLengthBox& inherited =
	GetBorderImageLengthBox(CssProperty(), *state.ParentStyle());
	conversion_checkers.push_back(std::make_unique<InheritedSideTypesChecker>(
	CssProperty(), SideTypes(inherited)));
	return ConvertBorderImageLengthBox(inherited,
	state.ParentStyle()->EffectiveZoom());
	}

	InterpolationValue CSSBorderImageLengthBoxInterpolationType::MaybeConvertValue(
	const CSSValue& value,
	const StyleResolverState*,
	ConversionCheckers&) const {
	const auto* quad = DynamicTo<CSSQuadValue>(value);
	if (!quad)
	return nullptr;

	auto list = std::make_unique<InterpolableList>(kSideIndexCount);
	Vector<scoped_refptr<const NonInterpolableValue>> non_interpolable_values(
	kSideIndexCount);
	const CSSValue* sides[kSideIndexCount] = {};
	sides[kSideTop] = quad->Top();
	sides[kSideRight] = quad->Right();
	sides[kSideBottom] = quad->Bottom();
	sides[kSideLeft] = quad->Left();

	return ListInterpolationFunctions::CreateList(
	kSideIndexCount, [&sides](wtf_size_t index) {
	const CSSValue& side = *sides[index];

	auto* side_primitive_value = DynamicTo<CSSPrimitiveValue>(side);
	if (side_primitive_value && side_primitive_value->IsNumber()) {
	return ConvertBorderImageNumberSide(
	side_primitive_value->GetDoubleValue());
	}

	auto* side_identifier_value = DynamicTo<CSSIdentifierValue>(side);
	if (side_identifier_value &&
	side_identifier_value->GetValueID() == CSSValueID::kAuto) {
	return ConvertBorderImageAutoSide();
	}

	return InterpolationValue(
	InterpolableLength::MaybeConvertCSSValue(side));
	});
	}

	InterpolationValue CSSBorderImageLengthBoxInterpolationType::
	MaybeConvertStandardPropertyUnderlyingValue(
	const ComputedStyle& style) const {
	return ConvertBorderImageLengthBox(
	GetBorderImageLengthBox(CssProperty(), style), style.EffectiveZoom());
	}

	PairwiseInterpolationValue
	CSSBorderImageLengthBoxInterpolationType::MaybeMergeSingles(
	InterpolationValue&& start,
	InterpolationValue&& end) const {
	if (SideTypes(start) != SideTypes(end))
	return nullptr;

	return PairwiseInterpolationValue(std::move(start.interpolable_value),
	std::move(end.interpolable_value),
	std::move(start.non_interpolable_value));
	}

	void CSSBorderImageLengthBoxInterpolationType::Composite(
	UnderlyingValueOwner& underlying_value_owner,
	double underlying_fraction,
	const InterpolationValue& value,
	double interpolation_fraction) const {
	ListInterpolationFunctions::Composite(
	underlying_value_owner, underlying_fraction, *this, value,
	ListInterpolationFunctions::LengthMatchingStrategy::kEqual,
	WTF::BindRepeating(
	ListInterpolationFunctions::InterpolableValuesKnownCompatible),
	WTF::BindRepeating(NonInterpolableSidesAreCompatible),
	WTF::BindRepeating(CompositeSide));
	}

	void CSSBorderImageLengthBoxInterpolationType::ApplyStandardPropertyValue(
	const InterpolableValue& interpolable_value,
	const NonInterpolableValue* non_interpolable_value,
	StyleResolverState& state) const {
	const auto& list = To<InterpolableList>(interpolable_value);
	const auto& non_interpolable_list =
	To<NonInterpolableList>(*non_interpolable_value);
	const auto& convert_side = [&list, &non_interpolable_list,
	&state](wtf_size_t index) -> BorderImageLength {
	switch (GetSideType(non_interpolable_list.Get(index))) {
	case SideType::kNumber:
	return clampTo<double>(To<InterpolableNumber>(list.Get(index))->Value(),
	0);
	case SideType::kAuto:
	return Length::Auto();
	case SideType::kLength:
	return To<InterpolableLength>(*list.Get(index))
	.CreateLength(state.CssToLengthConversionData(),
	kValueRangeNonNegative);
	default:
	NOTREACHED();
	return Length::Auto();
	}
	};
	BorderImageLengthBox box(convert_side(kSideTop), convert_side(kSideRight),
	convert_side(kSideBottom), convert_side(kSideLeft));
	SetBorderImageLengthBox(CssProperty(), *state.Style(), box);
	}

	} // namespace blink