PassOwnPtr<InterpolationValue> CSSImageListInterpolationType::maybeConvertNeutral(const UnderlyingValue& underlyingValue, ConversionCheckers& conversionCheckers) const
{
if (!underlyingValue) {
conversionCheckers.append(UnderlyingImageListChecker::create(*this, nullptr));
return nullptr;
}
conversionCheckers.append(UnderlyingImageListChecker::create(*this, underlyingValue->clone()));
return underlyingValue->clone();
}
InterpolationValue CSSPaintInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
if (!state.parentStyle())
return nullptr;
StyleColor parentColor;
if (!PaintPropertyFunctions::getColor(cssProperty(), *state.parentStyle(), parentColor)) {
conversionCheckers.append(ParentPaintChecker::create(cssProperty()));
return nullptr;
}
conversionCheckers.append(ParentPaintChecker::create(cssProperty(), parentColor));
return InterpolationValue(CSSColorInterpolationType::createInterpolableColor(parentColor));
}
InterpolationValue CSSInterpolationType::maybeConvertSingle(
const PropertySpecificKeyframe& keyframe,
const InterpolationEnvironment& environment,
const InterpolationValue& underlying,
ConversionCheckers& conversionCheckers) const {
const CSSValue* value = toCSSPropertySpecificKeyframe(keyframe).value();
if (!value)
return maybeConvertNeutral(underlying, conversionCheckers);
if (value->isVariableReferenceValue() ||
value->isPendingSubstitutionValue()) {
bool omitAnimationTainted = false;
const CSSValue* resolvedValue =
CSSVariableResolver::resolveVariableReferences(
environment.state(), cssProperty(), *value, omitAnimationTainted);
conversionCheckers.push_back(
ResolvedVariableChecker::create(cssProperty(), value, resolvedValue));
value = resolvedValue;
}
if (value->isInitialValue() ||
(value->isUnsetValue() &&
!CSSPropertyMetadata::isInheritedProperty(cssProperty())))
return maybeConvertInitial(environment.state(), conversionCheckers);
if (value->isInheritedValue() ||
(value->isUnsetValue() &&
CSSPropertyMetadata::isInheritedProperty(cssProperty())))
return maybeConvertInherit(environment.state(), conversionCheckers);
return maybeConvertValue(*value, environment.state(), conversionCheckers);
}
InterpolationValue CSSBasicShapeInterpolationType::maybeConvertNeutral(const InterpolationValue& underlying, ConversionCheckers& conversionCheckers) const
{
// const_cast is for taking refs.
NonInterpolableValue* nonInterpolableValue = const_cast<NonInterpolableValue*>(underlying.nonInterpolableValue.get());
conversionCheckers.append(UnderlyingCompatibilityChecker::create(nonInterpolableValue));
return InterpolationValue(BasicShapeInterpolationFunctions::createNeutralValue(*underlying.nonInterpolableValue), nonInterpolableValue);
}
InterpolationValue CSSScaleInterpolationType::maybeConvertInherit(
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
Scale parentScale(state.parentStyle()->scale());
conversionCheckers.append(ParentScaleChecker::create(parentScale));
return InterpolationValue(parentScale.createInterpolableValue());
}
InterpolationValue CSSBasicShapeInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
const BasicShape* shape = BasicShapePropertyFunctions::getBasicShape(cssProperty(), *state.parentStyle());
// const_cast to take a ref.
conversionCheckers.append(InheritedShapeChecker::create(cssProperty(), const_cast<BasicShape*>(shape)));
return BasicShapeInterpolationFunctions::maybeConvertBasicShape(shape, state.parentStyle()->effectiveZoom());
}
InterpolationValue CSSTransformInterpolationType::maybeConvertValue(
const CSSValue& value,
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
if (value.isValueList()) {
CSSLengthArray lengthArray;
for (const CSSValue* item : toCSSValueList(value)) {
const CSSFunctionValue& transformFunction = toCSSFunctionValue(*item);
if (transformFunction.functionType() == CSSValueMatrix ||
transformFunction.functionType() == CSSValueMatrix3d) {
lengthArray.typeFlags.set(CSSPrimitiveValue::UnitTypePixels);
continue;
}
for (const CSSValue* argument : transformFunction) {
const CSSPrimitiveValue& primitiveValue =
toCSSPrimitiveValue(*argument);
if (!primitiveValue.isLength())
continue;
primitiveValue.accumulateLengthArray(lengthArray);
}
}
std::unique_ptr<InterpolationType::ConversionChecker> lengthUnitsChecker =
LengthUnitsChecker::maybeCreate(std::move(lengthArray), state);
if (lengthUnitsChecker)
conversionCheckers.append(std::move(lengthUnitsChecker));
}
TransformOperations transform;
TransformBuilder::createTransformOperations(
value, state.cssToLengthConversionData(), transform);
return convertTransform(std::move(transform));
}
InterpolationValue CSSClipInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
ClipAutos parentAutos = getClipAutos(*state.parentStyle());
conversionCheckers.append(ParentAutosChecker::create(parentAutos));
if (parentAutos.isAuto)
return nullptr;
return createClipValue(state.parentStyle()->clip(), state.parentStyle()->effectiveZoom());
}
PassOwnPtr<InterpolationValue> CSSShadowListInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
if (!state.parentStyle())
return nullptr;
const ShadowList* parentShadowList = ShadowListPropertyFunctions::getShadowList(cssProperty(), *state.parentStyle());
conversionCheckers.append(ParentShadowListChecker::create(*this, cssProperty(), const_cast<ShadowList*>(parentShadowList))); // Take ref.
return convertShadowList(parentShadowList, state.parentStyle()->effectiveZoom());
}
void InvalidatableInterpolation::addConversionCheckers(
const InterpolationType& type,
ConversionCheckers& conversionCheckers) const {
for (size_t i = 0; i < conversionCheckers.size(); i++) {
conversionCheckers[i]->setType(type);
m_conversionCheckers.append(std::move(conversionCheckers[i]));
}
}
InterpolationValue CSSRotateInterpolationType::maybeConvertInherit(
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
Rotation inheritedRotation = getRotation(*state.parentStyle());
conversionCheckers.push_back(
InheritedRotationChecker::create(inheritedRotation));
return convertRotation(inheritedRotation);
}
InterpolationValue CSSTransformInterpolationType::maybeConvertInherit(
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
const TransformOperations& inheritedTransform =
state.parentStyle()->transform();
conversionCheckers.append(
InheritedTransformChecker::create(inheritedTransform));
return convertTransform(inheritedTransform);
}
PassOwnPtr<InterpolationValue> SVGPathInterpolationType::maybeConvertNeutral(const UnderlyingValue& underlyingValue, ConversionCheckers& conversionCheckers) const
{
conversionCheckers.append(UnderlyingPathSegTypesChecker::create(*this, underlyingValue));
OwnPtr<InterpolableList> result = InterpolableList::create(PathComponentIndexCount);
result->set(PathArgsIndex, toInterpolableList(underlyingValue->interpolableValue()).get(PathArgsIndex)->cloneAndZero());
result->set(PathNeutralIndex, InterpolableNumber::create(1));
return InterpolationValue::create(*this, result.release(),
const_cast<NonInterpolableValue*>(underlyingValue->nonInterpolableValue())); // Take ref.
}
InterpolationValue CSSColorInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
if (!state.parentStyle())
return nullptr;
// Visited color can never explicitly inherit from parent visited color so only use the unvisited color.
const StyleColor inheritedColor = ColorPropertyFunctions::getUnvisitedColor(cssProperty(), *state.parentStyle());
conversionCheckers.append(ParentColorChecker::create(cssProperty(), inheritedColor));
return convertStyleColorPair(inheritedColor, inheritedColor);
}
InterpolationValue CSSLengthListInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
Vector<Length> inheritedLengthList;
bool success = LengthListPropertyFunctions::getLengthList(cssProperty(), *state.parentStyle(), inheritedLengthList);
conversionCheckers.append(ParentLengthListChecker::create(cssProperty(), inheritedLengthList));
if (!success)
return nullptr;
return maybeConvertLengthList(inheritedLengthList, state.parentStyle()->effectiveZoom());
}
PassOwnPtr<InterpolationValue> SVGTransformListInterpolationType::maybeConvertNeutral(const UnderlyingValue& underlyingValue, ConversionCheckers& conversionCheckers) const
{
Vector<SVGTransformType> underlyingTypes(toSVGTransformNonInterpolableValue(underlyingValue->nonInterpolableValue())->transformTypes());
conversionCheckers.append(UnderlyingTypesChecker::create(*this, underlyingTypes));
if (underlyingTypes.isEmpty())
return nullptr;
OwnPtr<InterpolationValue> result = underlyingValue->clone();
result->mutableComponent().interpolableValue = result->interpolableValue().cloneAndZero();
return result.release();
}
InterpolationValue CSSNumberInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
if (!state.parentStyle())
return nullptr;
double inheritedNumber;
if (!NumberPropertyFunctions::getNumber(cssProperty(), *state.parentStyle(), inheritedNumber))
return nullptr;
conversionCheckers.append(ParentNumberChecker::create(cssProperty(), inheritedNumber));
return createNumberValue(inheritedNumber);
}
PassOwnPtr<InterpolationValue> CSSImageListInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
if (!state.parentStyle())
return nullptr;
StyleImageList inheritedImageList;
ImageListPropertyFunctions::getImageList(cssProperty(), *state.parentStyle(), inheritedImageList);
conversionCheckers.append(ParentImageListChecker::create(*this, cssProperty(), inheritedImageList));
return maybeConvertStyleImageList(inheritedImageList);
}
PassOwnPtr<InterpolationValue> CSSLengthInterpolationType::maybeConvertInherit(const StyleResolverState& state, ConversionCheckers& conversionCheckers) const
{
if (!state.parentStyle())
return nullptr;
Length inheritedLength;
if (!LengthPropertyFunctions::getLength(cssProperty(), *state.parentStyle(), inheritedLength))
return nullptr;
conversionCheckers.append(ParentLengthChecker::create(*this, cssProperty(), inheritedLength));
return maybeConvertLength(inheritedLength, effectiveZoom(*state.parentStyle()));
}
InterpolationValue CSSImageSliceInterpolationType::maybeConvertNeutral(const InterpolationValue& underlying, ConversionCheckers& conversionCheckers) const
{
SliceTypes underlyingTypes = UnderlyingSliceTypesChecker::getUnderlyingSliceTypes(underlying);
conversionCheckers.append(UnderlyingSliceTypesChecker::create(underlyingTypes));
LengthBox zeroBox(
Length(0, underlyingTypes.isNumber[SideTop] ? Fixed : Percent),
Length(0, underlyingTypes.isNumber[SideRight] ? Fixed : Percent),
Length(0, underlyingTypes.isNumber[SideBottom] ? Fixed : Percent),
Length(0, underlyingTypes.isNumber[SideLeft] ? Fixed : Percent));
return convertImageSlice(ImageSlice(zeroBox, underlyingTypes.fill), 1);
}
InterpolationValue CSSImageSliceInterpolationType::maybeConvertInherit(
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
const ImageSlice& inheritedImageSlice =
ImageSlicePropertyFunctions::getImageSlice(cssProperty(),
*state.parentStyle());
conversionCheckers.push_back(InheritedSliceTypesChecker::create(
cssProperty(), SliceTypes(inheritedImageSlice)));
return convertImageSlice(inheritedImageSlice,
state.parentStyle()->effectiveZoom());
}
InterpolationValue CSSFilterListInterpolationType::maybeConvertNeutral(
const InterpolationValue& underlying,
ConversionCheckers& conversionCheckers) const {
// const_cast for taking refs.
NonInterpolableList& nonInterpolableList = const_cast<NonInterpolableList&>(
toNonInterpolableList(*underlying.nonInterpolableValue));
conversionCheckers.push_back(
UnderlyingFilterListChecker::create(&nonInterpolableList));
return InterpolationValue(underlying.interpolableValue->cloneAndZero(),
&nonInterpolableList);
}
InterpolationValue CSSFilterListInterpolationType::maybeConvertInherit(
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
const FilterOperations& inheritedFilterOperations =
FilterListPropertyFunctions::getFilterList(cssProperty(),
*state.parentStyle());
conversionCheckers.push_back(InheritedFilterListChecker::create(
cssProperty(), inheritedFilterOperations));
return convertFilterList(inheritedFilterOperations,
state.style()->effectiveZoom());
}
InterpolationValue
CSSBorderImageLengthBoxInterpolationType::maybeConvertInherit(
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
const BorderImageLengthBox& inherited =
BorderImageLengthBoxPropertyFunctions::getBorderImageLengthBox(
cssProperty(), *state.parentStyle());
conversionCheckers.append(InheritedSideNumbersChecker::create(
cssProperty(), SideNumbers(inherited)));
return convertBorderImageLengthBox(inherited,
state.parentStyle()->effectiveZoom());
}
InterpolationValue CSSLengthListInterpolationType::maybeConvertNeutral(const InterpolationValue& underlying, ConversionCheckers& conversionCheckers) const
{
size_t underlyingLength = UnderlyingLengthChecker::getUnderlyingLength(underlying);
conversionCheckers.append(UnderlyingLengthChecker::create(underlyingLength));
if (underlyingLength == 0)
return nullptr;
return ListInterpolationFunctions::createList(underlyingLength, [](size_t) {
return InterpolationValue(CSSLengthInterpolationType::createNeutralInterpolableValue());
});
}
InterpolationValue CSSImageInterpolationType::maybeConvertInherit(
const StyleResolverState& state,
ConversionCheckers& conversionCheckers) const {
if (!state.parentStyle())
return nullptr;
const StyleImage* inheritedImage = ImagePropertyFunctions::getStyleImage(
cssProperty(), *state.parentStyle());
StyleImage* refableImage = const_cast<StyleImage*>(inheritedImage);
conversionCheckers.append(
InheritedImageChecker::create(cssProperty(), refableImage));
return maybeConvertStyleImage(inheritedImage, true);
}
InterpolationValue CSSClipInterpolationType::maybeConvertNeutral(const InterpolationValue& underlying, ConversionCheckers& conversionCheckers) const
{
ClipAutos underlyingAutos = UnderlyingAutosChecker::getUnderlyingAutos(underlying);
conversionCheckers.append(UnderlyingAutosChecker::create(underlyingAutos));
if (underlyingAutos.isAuto)
return nullptr;
LengthBox neutralBox(
underlyingAutos.isTopAuto ? Length(Auto) : Length(0, Fixed),
underlyingAutos.isRightAuto ? Length(Auto) : Length(0, Fixed),
underlyingAutos.isBottomAuto ? Length(Auto) : Length(0, Fixed),
underlyingAutos.isLeftAuto ? Length(Auto) : Length(0, Fixed));
return createClipValue(neutralBox, 1);
}
PassOwnPtr<InterpolationValue> SVGNumberListInterpolationType::maybeConvertNeutral(const UnderlyingValue& underlyingValue, ConversionCheckers& conversionCheckers) const
{
size_t underlyingLength = UnderlyingLengthChecker::getUnderlyingLength(underlyingValue);
conversionCheckers.append(UnderlyingLengthChecker::create(*this, underlyingLength));
if (underlyingLength == 0)
return nullptr;
OwnPtr<InterpolableList> result = InterpolableList::create(underlyingLength);
for (size_t i = 0; i < underlyingLength; i++)
result->set(i, InterpolableNumber::create(0));
return InterpolationValue::create(*this, result.release());
}
InterpolationValue SVGPointListInterpolationType::maybeConvertNeutral(
const InterpolationValue& underlying,
ConversionCheckers& conversionCheckers) const {
size_t underlyingLength =
UnderlyingLengthChecker::getUnderlyingLength(underlying);
conversionCheckers.append(UnderlyingLengthChecker::create(underlyingLength));
if (underlyingLength == 0)
return nullptr;
std::unique_ptr<InterpolableList> result =
InterpolableList::create(underlyingLength);
for (size_t i = 0; i < underlyingLength; i++)
result->set(i, InterpolableNumber::create(0));
return InterpolationValue(std::move(result));
}
InterpolationValue
CSSBorderImageLengthBoxInterpolationType::maybeConvertNeutral(
const InterpolationValue& underlying,
ConversionCheckers& conversionCheckers) const {
SideNumbers underlyingSideNumbers =
UnderlyingSideNumbersChecker::getUnderlyingSideNumbers(underlying);
conversionCheckers.append(
UnderlyingSideNumbersChecker::create(underlyingSideNumbers));
const auto& zero = [&underlyingSideNumbers](size_t index) {
return underlyingSideNumbers.isNumber[index]
? BorderImageLength(0)
: BorderImageLength(Length(0, Fixed));
};
BorderImageLengthBox zeroBox(zero(SideTop), zero(SideRight), zero(SideBottom),
zero(SideLeft));
return convertBorderImageLengthBox(zeroBox, 1);
}
