bool DeferredLegacyStyleInterpolation::interpolationRequiresStyleResolve(const CSSValue& value)
{
// FIXME: should not require resolving styles for inherit/initial/unset.
if (value.isCSSWideKeyword())
return true;
if (value.isBasicShapeCircleValue())
return interpolationRequiresStyleResolve(toCSSBasicShapeCircleValue(value));
if (value.isBasicShapeEllipseValue())
return interpolationRequiresStyleResolve(toCSSBasicShapeEllipseValue(value));
if (value.isBasicShapePolygonValue())
return interpolationRequiresStyleResolve(toCSSBasicShapePolygonValue(value));
if (value.isBasicShapeInsetValue())
return interpolationRequiresStyleResolve(toCSSBasicShapeInsetValue(value));
if (value.isPrimitiveValue())
return interpolationRequiresStyleResolve(toCSSPrimitiveValue(value));
if (value.isQuadValue())
return interpolationRequiresStyleResolve(toCSSQuadValue(value));
if (value.isValueList())
return interpolationRequiresStyleResolve(toCSSValueList(value));
if (value.isValuePair())
return interpolationRequiresStyleResolve(toCSSValuePair(value));
if (value.isImageValue())
return interpolationRequiresStyleResolve(toCSSImageValue(value));
if (value.isShadowValue())
return interpolationRequiresStyleResolve(toCSSShadowValue(value));
if (value.isSVGDocumentValue())
return interpolationRequiresStyleResolve(toCSSSVGDocumentValue(value));
// FIXME: consider other custom types.
return true;
}
InterpolationValue
CSSPositionAxisListInterpolationType::convertPositionAxisCSSValue(
const CSSValue& value) {
if (value.isValuePair()) {
const CSSValuePair& pair = toCSSValuePair(value);
InterpolationValue result =
LengthInterpolationFunctions::maybeConvertCSSValue(pair.second());
CSSValueID side = toCSSIdentifierValue(pair.first()).getValueID();
if (side == CSSValueRight || side == CSSValueBottom)
LengthInterpolationFunctions::subtractFromOneHundredPercent(result);
return result;
}
if (value.isPrimitiveValue())
return LengthInterpolationFunctions::maybeConvertCSSValue(value);
if (!value.isIdentifierValue())
return nullptr;
const CSSIdentifierValue& ident = toCSSIdentifierValue(value);
switch (ident.getValueID()) {
case CSSValueLeft:
case CSSValueTop:
return LengthInterpolationFunctions::createInterpolablePercent(0);
case CSSValueRight:
case CSSValueBottom:
return LengthInterpolationFunctions::createInterpolablePercent(100);
case CSSValueCenter:
return LengthInterpolationFunctions::createInterpolablePercent(50);
default:
NOTREACHED();
return nullptr;
}
}
void CSSToStyleMap::mapFillSize(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer->setSizeType(FillLayer::initialFillSizeType(layer->type()));
layer->setSizeLength(FillLayer::initialFillSizeLength(layer->type()));
return;
}
if (!value.isPrimitiveValue() && !value.isValuePair())
return;
if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueContain)
layer->setSizeType(Contain);
else if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueCover)
layer->setSizeType(Cover);
else
layer->setSizeType(SizeLength);
LengthSize b = FillLayer::initialFillSizeLength(layer->type());
if (value.isPrimitiveValue() && (toCSSPrimitiveValue(value).getValueID() == CSSValueContain || toCSSPrimitiveValue(value).getValueID() == CSSValueCover)) {
layer->setSizeLength(b);
return;
}
Length firstLength;
Length secondLength;
if (value.isValuePair()) {
const CSSValuePair& pair = toCSSValuePair(value);
firstLength = StyleBuilderConverter::convertLengthOrAuto(state, pair.first());
secondLength = StyleBuilderConverter::convertLengthOrAuto(state, pair.second());
} else {
ASSERT(value.isPrimitiveValue());
firstLength = StyleBuilderConverter::convertLengthOrAuto(state, value);
secondLength = Length();
}
b.setWidth(firstLength);
b.setHeight(secondLength);
layer->setSizeLength(b);
}
void CSSToStyleMap::mapFillYPosition(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer->setYPosition(FillLayer::initialFillYPosition(layer->type()));
return;
}
if (!value.isPrimitiveValue() && !value.isValuePair())
return;
Length length;
if (value.isValuePair())
length = toCSSPrimitiveValue(toCSSValuePair(value).second()).convertToLength(state.cssToLengthConversionData());
else
length = toCSSPrimitiveValue(value).convertToLength(state.cssToLengthConversionData());
layer->setYPosition(length);
if (value.isValuePair())
layer->setBackgroundYOrigin(toCSSPrimitiveValue(toCSSValuePair(value).first()));
}
void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, const CSSValue& value, NinePieceImage& image)
{
if (!value.isValuePair())
return;
const CSSValuePair& pair = toCSSValuePair(value);
CSSValueID firstIdentifier = toCSSPrimitiveValue(pair.first()).getValueID();
CSSValueID secondIdentifier = toCSSPrimitiveValue(pair.second()).getValueID();
ENinePieceImageRule horizontalRule;
switch (firstIdentifier) {
case CSSValueStretch:
horizontalRule = StretchImageRule;
break;
case CSSValueRound:
horizontalRule = RoundImageRule;
break;
case CSSValueSpace:
horizontalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
horizontalRule = RepeatImageRule;
break;
}
image.setHorizontalRule(horizontalRule);
ENinePieceImageRule verticalRule;
switch (secondIdentifier) {
case CSSValueStretch:
verticalRule = StretchImageRule;
break;
case CSSValueRound:
verticalRule = RoundImageRule;
break;
case CSSValueSpace:
verticalRule = SpaceImageRule;
break;
default: // CSSValueRepeat
verticalRule = RepeatImageRule;
break;
}
image.setVerticalRule(verticalRule);
}
InterpolationValue SizeInterpolationFunctions::maybeConvertCSSSizeSide(
const CSSValue& value,
bool convertWidth) {
if (value.isValuePair()) {
const CSSValuePair& pair = toCSSValuePair(value);
const CSSValue& side = convertWidth ? pair.first() : pair.second();
if (side.isIdentifierValue() &&
toCSSIdentifierValue(side).getValueID() == CSSValueAuto)
return convertKeyword(CSSValueAuto);
return wrapConvertedLength(
LengthInterpolationFunctions::maybeConvertCSSValue(side));
}
if (!value.isIdentifierValue() && !value.isPrimitiveValue())
return nullptr;
if (value.isIdentifierValue())
return convertKeyword(toCSSIdentifierValue(value).getValueID());
// A single length is equivalent to "<length> auto".
if (convertWidth)
return wrapConvertedLength(
LengthInterpolationFunctions::maybeConvertCSSValue(value));
return convertKeyword(CSSValueAuto);
}
bool LengthPairStyleInterpolation::canCreateFrom(const CSSValue& value)
{
return value.isValuePair();
}
