chromium/src/third_party/blink/renderer/core/animation/css_filter_list_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_filter_list_interpolation_type.h"

 #include <memory>
 #include <utility>

 #include "base/memory/ptr_util.h"
 #include "third_party/blink/renderer/core/animation/interpolable_filter.h"
 #include "third_party/blink/renderer/core/animation/list_interpolation_functions.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_value_list.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 {

 const FilterOperations& GetFilterList(const CSSProperty& property,
                                       const ComputedStyle& style) {
   switch (property.PropertyID()) {
     default:
       NOTREACHED();
       FALLTHROUGH;
     case CSSPropertyID::kBackdropFilter:
       return style.BackdropFilter();
     case CSSPropertyID::kFilter:
       return style.Filter();
   }
 }

 void SetFilterList(const CSSProperty& property,
                    ComputedStyle& style,
                    const FilterOperations& filter_operations) {
   switch (property.PropertyID()) {
     case CSSPropertyID::kBackdropFilter:
       style.SetBackdropFilter(filter_operations);
       break;
     case CSSPropertyID::kFilter:
       style.SetFilter(filter_operations);
       break;
     default:
       NOTREACHED();
       break;
   }
 }

 class UnderlyingFilterListChecker
     : public CSSInterpolationType::CSSConversionChecker {
  public:
   UnderlyingFilterListChecker(const InterpolableList* interpolable_list) {
     wtf_size_t length = interpolable_list->length();
     types_.ReserveInitialCapacity(length);
     for (wtf_size_t i = 0; i < length; i++) {
       types_.push_back(
           To<InterpolableFilter>(interpolable_list->Get(i))->GetType());
     }
   }

   bool IsValid(const StyleResolverState&,
                const InterpolationValue& underlying) const final {
     const auto& underlying_list =
         To<InterpolableList>(*underlying.interpolable_value);
     if (underlying_list.length() != types_.size())
       return false;
     for (wtf_size_t i = 0; i < types_.size(); i++) {
       FilterOperation::OperationType other_type =
           To<InterpolableFilter>(underlying_list.Get(i))->GetType();
       if (types_[i] != other_type)
         return false;
     }
     return true;
   }

  private:
   Vector<FilterOperation::OperationType> types_;
 };

 class InheritedFilterListChecker
     : public CSSInterpolationType::CSSConversionChecker {
  public:
   InheritedFilterListChecker(const CSSProperty& property,
                              const FilterOperations& filter_operations)
       : property_(property),
         filter_operations_wrapper_(
             MakeGarbageCollected<FilterOperationsWrapper>(filter_operations)) {}

   bool IsValid(const StyleResolverState& state,
                const InterpolationValue&) const final {
     const FilterOperations& filter_operations =
         filter_operations_wrapper_->Operations();
     return filter_operations == GetFilterList(property_, *state.ParentStyle());
   }

  private:
   const CSSProperty& property_;
   Persistent<FilterOperationsWrapper> filter_operations_wrapper_;
 };

 InterpolationValue ConvertFilterList(const FilterOperations& filter_operations,
                                      double zoom) {
   wtf_size_t length = filter_operations.size();
   auto interpolable_list = std::make_unique<InterpolableList>(length);
   for (wtf_size_t i = 0; i < length; i++) {
     std::unique_ptr<InterpolableFilter> result =
         InterpolableFilter::MaybeCreate(*filter_operations.Operations()[i],
                                         zoom);
     if (!result)
       return nullptr;
     interpolable_list->Set(i, std::move(result));
   }
   return InterpolationValue(std::move(interpolable_list));
 }

 class AlwaysInvalidateChecker
     : public CSSInterpolationType::CSSConversionChecker {
  public:
   bool IsValid(const StyleResolverState& state,
                const InterpolationValue& underlying) const final {
     return false;
   }
 };
 }  // namespace

 InterpolationValue CSSFilterListInterpolationType::MaybeConvertNeutral(
     const InterpolationValue& underlying,
     ConversionCheckers& conversion_checkers) const {
   const auto* interpolable_list =
       To<InterpolableList>(underlying.interpolable_value.get());
   conversion_checkers.push_back(
       std::make_unique<UnderlyingFilterListChecker>(interpolable_list));
   // The neutral value for composition for a filter list is the empty list, as
   // the additive operator is concatenation, so concat(underlying, []) ==
   // underlying.
   return InterpolationValue(std::make_unique<InterpolableList>(0));
 }

 InterpolationValue CSSFilterListInterpolationType::MaybeConvertInitial(
     const StyleResolverState&,
     ConversionCheckers& conversion_checkers) const {
   return ConvertFilterList(
       GetFilterList(CssProperty(), ComputedStyle::InitialStyle()), 1);
 }

 InterpolationValue CSSFilterListInterpolationType::MaybeConvertInherit(
     const StyleResolverState& state,
     ConversionCheckers& conversion_checkers) const {
   const FilterOperations& inherited_filter_operations =
       GetFilterList(CssProperty(), *state.ParentStyle());
   conversion_checkers.push_back(std::make_unique<InheritedFilterListChecker>(
       CssProperty(), inherited_filter_operations));
   return ConvertFilterList(inherited_filter_operations,
                            state.Style()->EffectiveZoom());
 }

 InterpolationValue CSSFilterListInterpolationType::MaybeConvertValue(
     const CSSValue& value,
     const StyleResolverState*,
     ConversionCheckers&) const {
   auto* identifier_value = DynamicTo<CSSIdentifierValue>(value);
   if (identifier_value && identifier_value->GetValueID() == CSSValueID::kNone)
     return InterpolationValue(std::make_unique<InterpolableList>(0));

   if (!value.IsBaseValueList())
     return nullptr;

   const auto& list = To<CSSValueList>(value);
   wtf_size_t length = list.length();
   auto interpolable_list = std::make_unique<InterpolableList>(length);
   for (wtf_size_t i = 0; i < length; i++) {
     std::unique_ptr<InterpolableFilter> result =
         InterpolableFilter::MaybeConvertCSSValue(list.Item(i));
     if (!result)
       return nullptr;
     interpolable_list->Set(i, std::move(result));
   }
   return InterpolationValue(std::move(interpolable_list));
 }

 InterpolationValue
 CSSFilterListInterpolationType::MaybeConvertStandardPropertyUnderlyingValue(
     const ComputedStyle& style) const {
   return ConvertFilterList(GetFilterList(CssProperty(), style),
                            style.EffectiveZoom());
 }

 PairwiseInterpolationValue CSSFilterListInterpolationType::MaybeMergeSingles(
     InterpolationValue&& start,
     InterpolationValue&& end) const {
   auto& start_interpolable_list =
       To<InterpolableList>(*start.interpolable_value);
   auto& end_interpolable_list = To<InterpolableList>(*end.interpolable_value);
   wtf_size_t start_length = start_interpolable_list.length();
   wtf_size_t end_length = end_interpolable_list.length();

   for (wtf_size_t i = 0; i < start_length && i < end_length; i++) {
     if (To<InterpolableFilter>(start_interpolable_list.Get(i))->GetType() !=
         To<InterpolableFilter>(end_interpolable_list.Get(i))->GetType())
       return nullptr;
   }

   if (start_length == end_length) {
     return PairwiseInterpolationValue(std::move(start.interpolable_value),
                                       std::move(end.interpolable_value));
   }

   // Extend the shorter InterpolableList with neutral values that are compatible
   // with corresponding filters in the longer list.
   InterpolationValue& shorter = start_length < end_length ? start : end;
   wtf_size_t shorter_length = std::min(start_length, end_length);
   wtf_size_t longer_length = std::max(start_length, end_length);
   InterpolableList& shorter_interpolable_list = start_length < end_length
                                                     ? start_interpolable_list
                                                     : end_interpolable_list;
   const InterpolableList& longer_interpolable_list =
       start_length < end_length ? end_interpolable_list
                                 : start_interpolable_list;
   auto extended_interpolable_list =
       std::make_unique<InterpolableList>(longer_length);
   for (wtf_size_t i = 0; i < longer_length; i++) {
     if (i < shorter_length)
       extended_interpolable_list->Set(
           i, std::move(shorter_interpolable_list.GetMutable(i)));
     else
       extended_interpolable_list->Set(
           i, InterpolableFilter::CreateInitialValue(
                  To<InterpolableFilter>(longer_interpolable_list.Get(i))
                      ->GetType()));
   }
   shorter.interpolable_value = std::move(extended_interpolable_list);

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

 void CSSFilterListInterpolationType::Composite(
     UnderlyingValueOwner& underlying_value_owner,
     double underlying_fraction,
     const InterpolationValue& value,
     double interpolation_fraction) const {
   // We do our compositing behavior in |PreInterpolationCompositeIfNeeded|; see
   // the documentation on that method.
   underlying_value_owner.Set(*this, value);
 }

 void CSSFilterListInterpolationType::ApplyStandardPropertyValue(
     const InterpolableValue& interpolable_value,
     const NonInterpolableValue* non_interpolable_value,
     StyleResolverState& state) const {
   const auto& interpolable_list = To<InterpolableList>(interpolable_value);
   wtf_size_t length = interpolable_list.length();

   FilterOperations filter_operations;
   filter_operations.Operations().ReserveCapacity(length);
   for (wtf_size_t i = 0; i < length; i++) {
     filter_operations.Operations().push_back(
         To<InterpolableFilter>(interpolable_list.Get(i))
             ->CreateFilterOperation(state));
   }
   SetFilterList(CssProperty(), *state.Style(), std::move(filter_operations));
 }

 InterpolationValue
 CSSFilterListInterpolationType::PreInterpolationCompositeIfNeeded(
     InterpolationValue value,
     const InterpolationValue& underlying,
     EffectModel::CompositeOperation composite,
     ConversionCheckers& conversion_checkers) const {
   DCHECK(!value.non_interpolable_value);
   DCHECK(!underlying.non_interpolable_value);

   // Due to the post-interpolation composite optimization, the interpolation
   // stack aggressively caches interpolated values. When we are doing
   // pre-interpolation compositing, this can cause us to bake-in the composited
   // result even when the underlying value is changing. This checker is a hack
   // to disable that caching in this case.
   // TODO(crbug.com/1009230): Remove this once our interpolation code isn't
   // caching composited values.
   conversion_checkers.push_back(std::make_unique<AlwaysInvalidateChecker>());

   // The underlying value can be nullptr, most commonly if it contains a url().
   // TODO(crbug.com/1009229): Properly handle url() in filter composite.
   if (!underlying.interpolable_value)
     return nullptr;

   auto interpolable_list = std::unique_ptr<InterpolableList>(
       To<InterpolableList>(value.interpolable_value.release()));
   const auto& underlying_list =
       To<InterpolableList>(*underlying.interpolable_value);

   if (composite == EffectModel::CompositeOperation::kCompositeAdd) {
     return PerformAdditiveComposition(std::move(interpolable_list),
                                       underlying_list);
   }
   DCHECK_EQ(composite, EffectModel::CompositeOperation::kCompositeAccumulate);
   return PerformAccumulativeComposition(std::move(interpolable_list),
                                         underlying_list);
 }

 InterpolationValue CSSFilterListInterpolationType::PerformAdditiveComposition(
     std::unique_ptr<InterpolableList> interpolable_list,
     const InterpolableList& underlying_list) const {
   // Per the spec, addition of filter lists is defined as concatenation.
   // https://drafts.fxtf.org/filter-effects-1/#addition
   auto composited_list = std::make_unique<InterpolableList>(
       underlying_list.length() + interpolable_list->length());
   for (wtf_size_t i = 0; i < composited_list->length(); i++) {
     if (i < underlying_list.length()) {
       composited_list->Set(i, underlying_list.Get(i)->Clone());
     } else {
       composited_list->Set(
           i, interpolable_list->Get(i - underlying_list.length())->Clone());
     }
   }
   return InterpolationValue(std::move(composited_list));
 }

 InterpolationValue
 CSSFilterListInterpolationType::PerformAccumulativeComposition(
     std::unique_ptr<InterpolableList> interpolable_list,
     const InterpolableList& underlying_list) const {
   // Per the spec, accumulation of filter lists operates on pairwise addition of
   // the underlying components.
   // https://drafts.fxtf.org/filter-effects-1/#accumulation
   wtf_size_t length = interpolable_list->length();
   wtf_size_t underlying_length = underlying_list.length();

   // If any of the types don't match, fallback to replace behavior.
   for (wtf_size_t i = 0; i < underlying_length && i < length; i++) {
     if (To<InterpolableFilter>(underlying_list.Get(i))->GetType() !=
         To<InterpolableFilter>(interpolable_list->Get(i))->GetType())
       return InterpolationValue(std::move(interpolable_list));
   }

   // Otherwise, arithmetically combine the matching prefix of the lists then
   // concatenate the remainder of the longer one.
   wtf_size_t max_length = std::max(length, underlying_length);
   auto composited_list = std::make_unique<InterpolableList>(max_length);
   for (wtf_size_t i = 0; i < max_length; i++) {
     if (i < underlying_length) {
       composited_list->Set(i, underlying_list.Get(i)->Clone());
       if (i < length)
         composited_list->GetMutable(i)->Add(*interpolable_list->Get(i));
     } else {
       composited_list->Set(i, interpolable_list->Get(i)->Clone());
     }
   }

   return InterpolationValue(std::move(composited_list));
 }

 }  // 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_filter_list_interpolation_type.h"

	#include <memory>
	#include <utility>

	#include "base/memory/ptr_util.h"
	#include "third_party/blink/renderer/core/animation/interpolable_filter.h"
	#include "third_party/blink/renderer/core/animation/list_interpolation_functions.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_value_list.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 {

	const FilterOperations& GetFilterList(const CSSProperty& property,
	const ComputedStyle& style) {
	switch (property.PropertyID()) {
	default:
	NOTREACHED();
	FALLTHROUGH;
	case CSSPropertyID::kBackdropFilter:
	return style.BackdropFilter();
	case CSSPropertyID::kFilter:
	return style.Filter();
	}
	}

	void SetFilterList(const CSSProperty& property,
	ComputedStyle& style,
	const FilterOperations& filter_operations) {
	switch (property.PropertyID()) {
	case CSSPropertyID::kBackdropFilter:
	style.SetBackdropFilter(filter_operations);
	break;
	case CSSPropertyID::kFilter:
	style.SetFilter(filter_operations);
	break;
	default:
	NOTREACHED();
	break;
	}
	}

	class UnderlyingFilterListChecker
	: public CSSInterpolationType::CSSConversionChecker {
	public:
	UnderlyingFilterListChecker(const InterpolableList* interpolable_list) {
	wtf_size_t length = interpolable_list->length();
	types_.ReserveInitialCapacity(length);
	for (wtf_size_t i = 0; i < length; i++) {
	types_.push_back(
	To<InterpolableFilter>(interpolable_list->Get(i))->GetType());
	}
	}

	bool IsValid(const StyleResolverState&,
	const InterpolationValue& underlying) const final {
	const auto& underlying_list =
	To<InterpolableList>(*underlying.interpolable_value);
	if (underlying_list.length() != types_.size())
	return false;
	for (wtf_size_t i = 0; i < types_.size(); i++) {
	FilterOperation::OperationType other_type =
	To<InterpolableFilter>(underlying_list.Get(i))->GetType();
	if (types_[i] != other_type)
	return false;
	}
	return true;
	}

	private:
	Vector<FilterOperation::OperationType> types_;
	};

	class InheritedFilterListChecker
	: public CSSInterpolationType::CSSConversionChecker {
	public:
	InheritedFilterListChecker(const CSSProperty& property,
	const FilterOperations& filter_operations)
	: property_(property),
	filter_operations_wrapper_(
	MakeGarbageCollected<FilterOperationsWrapper>(filter_operations)) {}

	bool IsValid(const StyleResolverState& state,
	const InterpolationValue&) const final {
	const FilterOperations& filter_operations =
	filter_operations_wrapper_->Operations();
	return filter_operations == GetFilterList(property_, *state.ParentStyle());
	}

	private:
	const CSSProperty& property_;
	Persistent<FilterOperationsWrapper> filter_operations_wrapper_;
	};

	InterpolationValue ConvertFilterList(const FilterOperations& filter_operations,
	double zoom) {
	wtf_size_t length = filter_operations.size();
	auto interpolable_list = std::make_unique<InterpolableList>(length);
	for (wtf_size_t i = 0; i < length; i++) {
	std::unique_ptr<InterpolableFilter> result =
	InterpolableFilter::MaybeCreate(*filter_operations.Operations()[i],
	zoom);
	if (!result)
	return nullptr;
	interpolable_list->Set(i, std::move(result));
	}
	return InterpolationValue(std::move(interpolable_list));
	}

	class AlwaysInvalidateChecker
	: public CSSInterpolationType::CSSConversionChecker {
	public:
	bool IsValid(const StyleResolverState& state,
	const InterpolationValue& underlying) const final {
	return false;
	}
	};
	} // namespace

	InterpolationValue CSSFilterListInterpolationType::MaybeConvertNeutral(
	const InterpolationValue& underlying,
	ConversionCheckers& conversion_checkers) const {
	const auto* interpolable_list =
	To<InterpolableList>(underlying.interpolable_value.get());
	conversion_checkers.push_back(
	std::make_unique<UnderlyingFilterListChecker>(interpolable_list));
	// The neutral value for composition for a filter list is the empty list, as
	// the additive operator is concatenation, so concat(underlying, []) ==
	// underlying.
	return InterpolationValue(std::make_unique<InterpolableList>(0));
	}

	InterpolationValue CSSFilterListInterpolationType::MaybeConvertInitial(
	const StyleResolverState&,
	ConversionCheckers& conversion_checkers) const {
	return ConvertFilterList(
	GetFilterList(CssProperty(), ComputedStyle::InitialStyle()), 1);
	}

	InterpolationValue CSSFilterListInterpolationType::MaybeConvertInherit(
	const StyleResolverState& state,
	ConversionCheckers& conversion_checkers) const {
	const FilterOperations& inherited_filter_operations =
	GetFilterList(CssProperty(), *state.ParentStyle());
	conversion_checkers.push_back(std::make_unique<InheritedFilterListChecker>(
	CssProperty(), inherited_filter_operations));
	return ConvertFilterList(inherited_filter_operations,
	state.Style()->EffectiveZoom());
	}

	InterpolationValue CSSFilterListInterpolationType::MaybeConvertValue(
	const CSSValue& value,
	const StyleResolverState*,
	ConversionCheckers&) const {
	auto* identifier_value = DynamicTo<CSSIdentifierValue>(value);
	if (identifier_value && identifier_value->GetValueID() == CSSValueID::kNone)
	return InterpolationValue(std::make_unique<InterpolableList>(0));

	if (!value.IsBaseValueList())
	return nullptr;

	const auto& list = To<CSSValueList>(value);
	wtf_size_t length = list.length();
	auto interpolable_list = std::make_unique<InterpolableList>(length);
	for (wtf_size_t i = 0; i < length; i++) {
	std::unique_ptr<InterpolableFilter> result =
	InterpolableFilter::MaybeConvertCSSValue(list.Item(i));
	if (!result)
	return nullptr;
	interpolable_list->Set(i, std::move(result));
	}
	return InterpolationValue(std::move(interpolable_list));
	}

	InterpolationValue
	CSSFilterListInterpolationType::MaybeConvertStandardPropertyUnderlyingValue(
	const ComputedStyle& style) const {
	return ConvertFilterList(GetFilterList(CssProperty(), style),
	style.EffectiveZoom());
	}

	PairwiseInterpolationValue CSSFilterListInterpolationType::MaybeMergeSingles(
	InterpolationValue&& start,
	InterpolationValue&& end) const {
	auto& start_interpolable_list =
	To<InterpolableList>(*start.interpolable_value);
	auto& end_interpolable_list = To<InterpolableList>(*end.interpolable_value);
	wtf_size_t start_length = start_interpolable_list.length();
	wtf_size_t end_length = end_interpolable_list.length();

	for (wtf_size_t i = 0; i < start_length && i < end_length; i++) {
	if (To<InterpolableFilter>(start_interpolable_list.Get(i))->GetType() !=
	To<InterpolableFilter>(end_interpolable_list.Get(i))->GetType())
	return nullptr;
	}

	if (start_length == end_length) {
	return PairwiseInterpolationValue(std::move(start.interpolable_value),
	std::move(end.interpolable_value));
	}

	// Extend the shorter InterpolableList with neutral values that are compatible
	// with corresponding filters in the longer list.
	InterpolationValue& shorter = start_length < end_length ? start : end;
	wtf_size_t shorter_length = std::min(start_length, end_length);
	wtf_size_t longer_length = std::max(start_length, end_length);
	InterpolableList& shorter_interpolable_list = start_length < end_length
	? start_interpolable_list
	: end_interpolable_list;
	const InterpolableList& longer_interpolable_list =
	start_length < end_length ? end_interpolable_list
	: start_interpolable_list;
	auto extended_interpolable_list =
	std::make_unique<InterpolableList>(longer_length);
	for (wtf_size_t i = 0; i < longer_length; i++) {
	if (i < shorter_length)
	extended_interpolable_list->Set(
	i, std::move(shorter_interpolable_list.GetMutable(i)));
	else
	extended_interpolable_list->Set(
	i, InterpolableFilter::CreateInitialValue(
	To<InterpolableFilter>(longer_interpolable_list.Get(i))
	->GetType()));
	}
	shorter.interpolable_value = std::move(extended_interpolable_list);

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

	void CSSFilterListInterpolationType::Composite(
	UnderlyingValueOwner& underlying_value_owner,
	double underlying_fraction,
	const InterpolationValue& value,
	double interpolation_fraction) const {
	// We do our compositing behavior in \|PreInterpolationCompositeIfNeeded\|; see
	// the documentation on that method.
	underlying_value_owner.Set(*this, value);
	}

	void CSSFilterListInterpolationType::ApplyStandardPropertyValue(
	const InterpolableValue& interpolable_value,
	const NonInterpolableValue* non_interpolable_value,
	StyleResolverState& state) const {
	const auto& interpolable_list = To<InterpolableList>(interpolable_value);
	wtf_size_t length = interpolable_list.length();

	FilterOperations filter_operations;
	filter_operations.Operations().ReserveCapacity(length);
	for (wtf_size_t i = 0; i < length; i++) {
	filter_operations.Operations().push_back(
	To<InterpolableFilter>(interpolable_list.Get(i))
	->CreateFilterOperation(state));
	}
	SetFilterList(CssProperty(), *state.Style(), std::move(filter_operations));
	}

	InterpolationValue
	CSSFilterListInterpolationType::PreInterpolationCompositeIfNeeded(
	InterpolationValue value,
	const InterpolationValue& underlying,
	EffectModel::CompositeOperation composite,
	ConversionCheckers& conversion_checkers) const {
	DCHECK(!value.non_interpolable_value);
	DCHECK(!underlying.non_interpolable_value);

	// Due to the post-interpolation composite optimization, the interpolation
	// stack aggressively caches interpolated values. When we are doing
	// pre-interpolation compositing, this can cause us to bake-in the composited
	// result even when the underlying value is changing. This checker is a hack
	// to disable that caching in this case.
	// TODO(crbug.com/1009230): Remove this once our interpolation code isn't
	// caching composited values.
	conversion_checkers.push_back(std::make_unique<AlwaysInvalidateChecker>());

	// The underlying value can be nullptr, most commonly if it contains a url().
	// TODO(crbug.com/1009229): Properly handle url() in filter composite.
	if (!underlying.interpolable_value)
	return nullptr;

	auto interpolable_list = std::unique_ptr<InterpolableList>(
	To<InterpolableList>(value.interpolable_value.release()));
	const auto& underlying_list =
	To<InterpolableList>(*underlying.interpolable_value);

	if (composite == EffectModel::CompositeOperation::kCompositeAdd) {
	return PerformAdditiveComposition(std::move(interpolable_list),
	underlying_list);
	}
	DCHECK_EQ(composite, EffectModel::CompositeOperation::kCompositeAccumulate);
	return PerformAccumulativeComposition(std::move(interpolable_list),
	underlying_list);
	}

	InterpolationValue CSSFilterListInterpolationType::PerformAdditiveComposition(
	std::unique_ptr<InterpolableList> interpolable_list,
	const InterpolableList& underlying_list) const {
	// Per the spec, addition of filter lists is defined as concatenation.
	// https://drafts.fxtf.org/filter-effects-1/#addition
	auto composited_list = std::make_unique<InterpolableList>(
	underlying_list.length() + interpolable_list->length());
	for (wtf_size_t i = 0; i < composited_list->length(); i++) {
	if (i < underlying_list.length()) {
	composited_list->Set(i, underlying_list.Get(i)->Clone());
	} else {
	composited_list->Set(
	i, interpolable_list->Get(i - underlying_list.length())->Clone());
	}
	}
	return InterpolationValue(std::move(composited_list));
	}

	InterpolationValue
	CSSFilterListInterpolationType::PerformAccumulativeComposition(
	std::unique_ptr<InterpolableList> interpolable_list,
	const InterpolableList& underlying_list) const {
	// Per the spec, accumulation of filter lists operates on pairwise addition of
	// the underlying components.
	// https://drafts.fxtf.org/filter-effects-1/#accumulation
	wtf_size_t length = interpolable_list->length();
	wtf_size_t underlying_length = underlying_list.length();

	// If any of the types don't match, fallback to replace behavior.
	for (wtf_size_t i = 0; i < underlying_length && i < length; i++) {
	if (To<InterpolableFilter>(underlying_list.Get(i))->GetType() !=
	To<InterpolableFilter>(interpolable_list->Get(i))->GetType())
	return InterpolationValue(std::move(interpolable_list));
	}

	// Otherwise, arithmetically combine the matching prefix of the lists then
	// concatenate the remainder of the longer one.
	wtf_size_t max_length = std::max(length, underlying_length);
	auto composited_list = std::make_unique<InterpolableList>(max_length);
	for (wtf_size_t i = 0; i < max_length; i++) {
	if (i < underlying_length) {
	composited_list->Set(i, underlying_list.Get(i)->Clone());
	if (i < length)
	composited_list->GetMutable(i)->Add(*interpolable_list->Get(i));
	} else {
	composited_list->Set(i, interpolable_list->Get(i)->Clone());
	}
	}

	return InterpolationValue(std::move(composited_list));
	}

	} // namespace blink