void CSSToStyleMap::mapFillMaskSourceType(StyleResolverState&, FillLayer* layer, const CSSValue& value)
{
EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer->type());
if (value.isInitialValue()) {
layer->setMaskSourceType(type);
return;
}
if (!value.isPrimitiveValue())
return;
switch (toCSSPrimitiveValue(value).getValueID()) {
case CSSValueAlpha:
type = MaskAlpha;
break;
case CSSValueLuminance:
type = MaskLuminance;
break;
case CSSValueAuto:
break;
default:
ASSERT_NOT_REACHED();
}
layer->setMaskSourceType(type);
}
void CSSToStyleMap::mapFillSize(CSSPropertyID, FillLayer& layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer.setSize(FillLayer::initialFillSize(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
FillSize fillSize;
switch (primitiveValue.getValueID()) {
case CSSValueContain:
fillSize.type = Contain;
break;
case CSSValueCover:
fillSize.type = Cover;
break;
default:
ASSERT(fillSize.type == SizeLength);
if (!convertToLengthSize(primitiveValue, m_resolver->state().cssToLengthConversionData(), fillSize.size))
return;
break;
}
layer.setSize(fillSize);
}
void CSSToStyleMap::mapFillAttachment(StyleResolverState&, FillLayer* layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer->setAttachment(FillLayer::initialFillAttachment(layer->type()));
return;
}
if (!value.isPrimitiveValue())
return;
const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
switch (primitiveValue.getValueID()) {
case CSSValueFixed:
layer->setAttachment(FixedBackgroundAttachment);
break;
case CSSValueScroll:
layer->setAttachment(ScrollBackgroundAttachment);
break;
case CSSValueLocal:
layer->setAttachment(LocalBackgroundAttachment);
break;
default:
return;
}
}
void CSSToStyleMap::mapAnimationFillMode(Animation& layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer.setFillMode(Animation::initialFillMode());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueNone:
layer.setFillMode(AnimationFillModeNone);
break;
case CSSValueForwards:
layer.setFillMode(AnimationFillModeForwards);
break;
case CSSValueBackwards:
layer.setFillMode(AnimationFillModeBackwards);
break;
case CSSValueBoth:
layer.setFillMode(AnimationFillModeBoth);
break;
default:
break;
}
}
void CSSToStyleMap::mapAnimationDirection(Animation& layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer.setDirection(Animation::initialDirection());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueNormal:
layer.setDirection(Animation::AnimationDirectionNormal);
break;
case CSSValueAlternate:
layer.setDirection(Animation::AnimationDirectionAlternate);
break;
case CSSValueReverse:
layer.setDirection(Animation::AnimationDirectionReverse);
break;
case CSSValueAlternateReverse:
layer.setDirection(Animation::AnimationDirectionAlternateReverse);
break;
default:
break;
}
}
void CSSToStyleMap::mapFillMaskSourceType(CSSPropertyID, FillLayer& layer, const CSSValue& value)
{
EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer.type());
if (value.isInitialValue()) {
layer.setMaskSourceType(type);
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueAlpha:
type = EMaskSourceType::MaskAlpha;
break;
case CSSValueLuminance:
type = EMaskSourceType::MaskLuminance;
break;
case CSSValueAuto:
break;
default:
ASSERT_NOT_REACHED();
}
layer.setMaskSourceType(type);
}
void CSSToStyleMap::mapFillYPosition(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer.setYPosition(FillLayer::initialFillYPosition(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto* primitiveValue = &downcast<CSSPrimitiveValue>(value);
Pair* pair = primitiveValue->getPairValue();
if (pair) {
ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPositionY || propertyID == CSSPropertyWebkitMaskPositionY);
primitiveValue = pair->second();
}
Length length;
if (primitiveValue->isLength())
length = primitiveValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
else if (primitiveValue->isPercentage())
length = Length(primitiveValue->getDoubleValue(), Percent);
else if (primitiveValue->isCalculatedPercentageWithLength())
length = Length(primitiveValue->cssCalcValue()->createCalculationValue(m_resolver->state().cssToLengthConversionData()));
else
return;
layer.setYPosition(length);
if (pair)
layer.setBackgroundYOrigin(*pair->first());
}
void CSSToStyleMap::mapAnimationTrigger(Animation& animation, const CSSValue& value)
{
if (value.isInitialValue()) {
animation.setTrigger(Animation::initialTrigger());
return;
}
if (value.isPrimitiveValue()) {
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueAuto)
animation.setTrigger(AutoAnimationTrigger::create());
return;
}
if (value.isAnimationTriggerScrollValue()) {
auto& scrollTrigger = downcast<CSSAnimationTriggerScrollValue>(value);
const CSSPrimitiveValue* startValue = downcast<CSSPrimitiveValue>(scrollTrigger.startValue());
Length startLength = startValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
Length endLength;
if (scrollTrigger.hasEndValue()) {
const CSSPrimitiveValue* endValue = downcast<CSSPrimitiveValue>(scrollTrigger.endValue());
endLength = endValue->computeLength<Length>(m_resolver->state().cssToLengthConversionData());
}
animation.setTrigger(ScrollAnimationTrigger::create(startLength, endLength));
}
}
MutableStylePropertySet* CanvasFontCache::parseFont(const String& fontString)
{
MutableStylePropertySet* parsedStyle;
MutableStylePropertyMap::iterator i = m_fetchedFonts.find(fontString);
if (i != m_fetchedFonts.end()) {
ASSERT(m_fontLRUList.contains(fontString));
parsedStyle = i->value;
m_fontLRUList.remove(fontString);
m_fontLRUList.add(fontString);
} else {
parsedStyle = MutableStylePropertySet::create(HTMLStandardMode);
CSSParser::parseValue(parsedStyle, CSSPropertyFont, fontString, true, 0);
if (parsedStyle->isEmpty())
return nullptr;
// According to http://lists.w3.org/Archives/Public/public-html/2009Jul/0947.html,
// the "inherit" and "initial" values must be ignored.
CSSValue* fontValue = parsedStyle->getPropertyCSSValue(CSSPropertyFontSize);
if (fontValue && (fontValue->isInitialValue() || fontValue->isInheritedValue()))
return nullptr;
m_fetchedFonts.add(fontString, parsedStyle);
m_fontLRUList.add(fontString);
// Hard limit is applied here, on the fly, while the soft limit is
// applied at the end of the task.
if (m_fetchedFonts.size() > hardMaxFonts()) {
ASSERT(m_fetchedFonts.size() == hardMaxFonts() + 1);
ASSERT(m_fontLRUList.size() == hardMaxFonts() + 1);
m_fetchedFonts.remove(m_fontLRUList.first());
m_fontsResolvedUsingDefaultStyle.remove(m_fontLRUList.first());
m_fontLRUList.removeFirst();
}
}
schedulePruningIfNeeded();
return parsedStyle;
}
void CSSToStyleMap::mapFillImage(CSSPropertyID property, FillLayer& layer, CSSValue& value)
{
if (value.isInitialValue()) {
layer.setImage(FillLayer::initialFillImage(layer.type()));
return;
}
layer.setImage(styleImage(property, value));
}
EAnimPlayState CSSToStyleMap::mapAnimationPlayState(const CSSValue& value)
{
if (value.isInitialValue())
return CSSAnimationData::initialPlayState();
if (toCSSPrimitiveValue(value).getValueID() == CSSValuePaused)
return AnimPlayStatePaused;
ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueRunning);
return AnimPlayStatePlaying;
}
double CSSToStyleMap::mapAnimationIterationCount(const CSSValue& value)
{
if (value.isInitialValue())
return CSSAnimationData::initialIterationCount();
const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
if (primitiveValue.getValueID() == CSSValueInfinite)
return std::numeric_limits<double>::infinity();
return primitiveValue.getFloatValue();
}
AtomicString CSSToStyleMap::mapAnimationName(const CSSValue& value)
{
if (value.isInitialValue())
return CSSAnimationData::initialName();
if (value.isCustomIdentValue())
return AtomicString(toCSSCustomIdentValue(value).value());
ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
return CSSAnimationData::initialName();
}
void CSSToStyleMap::mapFillImage(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer->setImage(FillLayer::initialFillImage(layer->type()));
return;
}
CSSPropertyID property = layer->type() == BackgroundFillLayer ? CSSPropertyBackgroundImage : CSSPropertyWebkitMaskImage;
layer->setImage(state.styleImage(property, value));
}
static void appendBackgroundRepeatValue(StringBuilder& builder, const CSSValue& repeatXCSSValue, const CSSValue& repeatYCSSValue)
{
// FIXME: Ensure initial values do not appear in CSS_VALUE_LISTS.
DEFINE_STATIC_REF_WILL_BE_PERSISTENT(CSSPrimitiveValue, initialRepeatValue, (CSSPrimitiveValue::create(CSSValueRepeat)));
const CSSPrimitiveValue& repeatX = repeatXCSSValue.isInitialValue() ? *initialRepeatValue : toCSSPrimitiveValue(repeatXCSSValue);
const CSSPrimitiveValue& repeatY = repeatYCSSValue.isInitialValue() ? *initialRepeatValue : toCSSPrimitiveValue(repeatYCSSValue);
CSSValueID repeatXValueId = repeatX.getValueID();
CSSValueID repeatYValueId = repeatY.getValueID();
if (repeatXValueId == repeatYValueId) {
builder.append(repeatX.cssText());
} else if (repeatXValueId == CSSValueNoRepeat && repeatYValueId == CSSValueRepeat) {
builder.appendLiteral("repeat-y");
} else if (repeatXValueId == CSSValueRepeat && repeatYValueId == CSSValueNoRepeat) {
builder.appendLiteral("repeat-x");
} else {
builder.append(repeatX.cssText());
builder.appendLiteral(" ");
builder.append(repeatY.cssText());
}
}
void CSSToStyleMap::mapFillClip(CSSPropertyID, FillLayer& layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer.setClip(FillLayer::initialFillClip(layer.type()));
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
layer.setClip(downcast<CSSPrimitiveValue>(value));
}
void CSSToStyleMap::mapAnimationDuration(Animation& animation, const CSSValue& value)
{
if (value.isInitialValue()) {
animation.setDuration(Animation::initialDuration());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
animation.setDuration(downcast<CSSPrimitiveValue>(value).computeTime<double, CSSPrimitiveValue::Seconds>());
}
CSSTransitionData::TransitionProperty CSSToStyleMap::mapAnimationProperty(const CSSValue& value)
{
if (value.isInitialValue())
return CSSTransitionData::initialProperty();
if (value.isCustomIdentValue()) {
const CSSCustomIdentValue& customIdentValue = toCSSCustomIdentValue(value);
if (customIdentValue.isKnownPropertyID())
return CSSTransitionData::TransitionProperty(customIdentValue.valueAsPropertyID());
return CSSTransitionData::TransitionProperty(customIdentValue.value());
}
ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
return CSSTransitionData::TransitionProperty(CSSTransitionData::TransitionNone);
}
void CSSToStyleMap::mapFillComposite(StyleResolverState&, FillLayer* layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer->setComposite(FillLayer::initialFillComposite(layer->type()));
return;
}
if (!value.isPrimitiveValue())
return;
const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
layer->setComposite(primitiveValue);
}
void CSSToStyleMap::mapFillClip(StyleResolverState&, FillLayer* layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer->setClip(FillLayer::initialFillClip(layer->type()));
return;
}
if (!value.isPrimitiveValue())
return;
const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
layer->setClip(primitiveValue.convertTo<EFillBox>());
}
void CSSToStyleMap::mapAnimationPlayState(Animation& layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer.setPlayState(Animation::initialPlayState());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
EAnimPlayState playState = (downcast<CSSPrimitiveValue>(value).getValueID() == CSSValuePaused) ? AnimPlayStatePaused : AnimPlayStatePlaying;
layer.setPlayState(playState);
}
void CSSToStyleMap::mapAnimationIterationCount(Animation& animation, const CSSValue& value)
{
if (value.isInitialValue()) {
animation.setIterationCount(Animation::initialIterationCount());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueInfinite)
animation.setIterationCount(Animation::IterationCountInfinite);
else
animation.setIterationCount(primitiveValue.getFloatValue());
}
void CSSToStyleMap::mapAnimationName(Animation& layer, const CSSValue& value)
{
if (value.isInitialValue()) {
layer.setName(Animation::initialName());
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueNone)
layer.setIsNoneAnimation(true);
else
layer.setName(primitiveValue.getStringValue());
}
PassRefPtr<TimingFunction> CSSToStyleMap::mapAnimationTimingFunction(const CSSValue& value, bool allowStepMiddle)
{
// FIXME: We should probably only call into this function with a valid
// single timing function value which isn't initial or inherit. We can
// currently get into here with initial since the parser expands unset
// properties in shorthands to initial.
if (value.isPrimitiveValue()) {
const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
switch (primitiveValue.getValueID()) {
case CSSValueLinear:
return LinearTimingFunction::shared();
case CSSValueEase:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
case CSSValueEaseIn:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
case CSSValueEaseOut:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
case CSSValueEaseInOut:
return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut);
case CSSValueStepStart:
return StepsTimingFunction::preset(StepsTimingFunction::Start);
case CSSValueStepMiddle:
if (allowStepMiddle)
return StepsTimingFunction::preset(StepsTimingFunction::Middle);
return CSSTimingData::initialTimingFunction();
case CSSValueStepEnd:
return StepsTimingFunction::preset(StepsTimingFunction::End);
default:
ASSERT_NOT_REACHED();
return CSSTimingData::initialTimingFunction();
}
}
if (value.isCubicBezierTimingFunctionValue()) {
const CSSCubicBezierTimingFunctionValue& cubicTimingFunction = toCSSCubicBezierTimingFunctionValue(value);
return CubicBezierTimingFunction::create(cubicTimingFunction.x1(), cubicTimingFunction.y1(), cubicTimingFunction.x2(), cubicTimingFunction.y2());
}
if (value.isInitialValue())
return CSSTimingData::initialTimingFunction();
const CSSStepsTimingFunctionValue& stepsTimingFunction = toCSSStepsTimingFunctionValue(value);
if (stepsTimingFunction.stepAtPosition() == StepsTimingFunction::Middle && !allowStepMiddle)
return CSSTimingData::initialTimingFunction();
return StepsTimingFunction::create(stepsTimingFunction.numberOfSteps(), stepsTimingFunction.stepAtPosition());
}
void CSSToStyleMap::mapAnimationTimingFunction(Animation& animation, const CSSValue& value)
{
if (value.isInitialValue()) {
animation.setTimingFunction(Animation::initialTimingFunction());
return;
}
if (is<CSSPrimitiveValue>(value)) {
switch (downcast<CSSPrimitiveValue>(value).getValueID()) {
case CSSValueLinear:
animation.setTimingFunction(LinearTimingFunction::create());
break;
case CSSValueEase:
animation.setTimingFunction(CubicBezierTimingFunction::create());
break;
case CSSValueEaseIn:
animation.setTimingFunction(CubicBezierTimingFunction::create(CubicBezierTimingFunction::EaseIn));
break;
case CSSValueEaseOut:
animation.setTimingFunction(CubicBezierTimingFunction::create(CubicBezierTimingFunction::EaseOut));
break;
case CSSValueEaseInOut:
animation.setTimingFunction(CubicBezierTimingFunction::create(CubicBezierTimingFunction::EaseInOut));
break;
case CSSValueStepStart:
animation.setTimingFunction(StepsTimingFunction::create(1, true));
break;
case CSSValueStepEnd:
animation.setTimingFunction(StepsTimingFunction::create(1, false));
break;
default:
break;
}
return;
}
if (is<CSSCubicBezierTimingFunctionValue>(value)) {
auto& cubicTimingFunction = downcast<CSSCubicBezierTimingFunctionValue>(value);
animation.setTimingFunction(CubicBezierTimingFunction::create(cubicTimingFunction.x1(), cubicTimingFunction.y1(), cubicTimingFunction.x2(), cubicTimingFunction.y2()));
} else if (is<CSSStepsTimingFunctionValue>(value)) {
auto& stepsTimingFunction = downcast<CSSStepsTimingFunctionValue>(value);
animation.setTimingFunction(StepsTimingFunction::create(stepsTimingFunction.numberOfSteps(), stepsTimingFunction.stepAtStart()));
}
}
Timing::PlaybackDirection CSSToStyleMap::mapAnimationDirection(const CSSValue& value)
{
if (value.isInitialValue())
return CSSAnimationData::initialDirection();
switch (toCSSPrimitiveValue(value).getValueID()) {
case CSSValueNormal:
return Timing::PlaybackDirectionNormal;
case CSSValueAlternate:
return Timing::PlaybackDirectionAlternate;
case CSSValueReverse:
return Timing::PlaybackDirectionReverse;
case CSSValueAlternateReverse:
return Timing::PlaybackDirectionAlternateReverse;
default:
ASSERT_NOT_REACHED();
return CSSAnimationData::initialDirection();
}
}
Timing::FillMode CSSToStyleMap::mapAnimationFillMode(const CSSValue& value)
{
if (value.isInitialValue())
return CSSAnimationData::initialFillMode();
switch (toCSSPrimitiveValue(value).getValueID()) {
case CSSValueNone:
return Timing::FillModeNone;
case CSSValueForwards:
return Timing::FillModeForwards;
case CSSValueBackwards:
return Timing::FillModeBackwards;
case CSSValueBoth:
return Timing::FillModeBoth;
default:
ASSERT_NOT_REACHED();
return CSSAnimationData::initialFillMode();
}
}
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::mapAnimationProperty(Animation& animation, const CSSValue& value)
{
if (value.isInitialValue()) {
animation.setAnimationMode(Animation::AnimateAll);
animation.setProperty(CSSPropertyInvalid);
return;
}
if (!is<CSSPrimitiveValue>(value))
return;
auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
if (primitiveValue.getValueID() == CSSValueAll) {
animation.setAnimationMode(Animation::AnimateAll);
animation.setProperty(CSSPropertyInvalid);
} else if (primitiveValue.getValueID() == CSSValueNone) {
animation.setAnimationMode(Animation::AnimateNone);
animation.setProperty(CSSPropertyInvalid);
} else {
animation.setAnimationMode(Animation::AnimateSingleProperty);
animation.setProperty(primitiveValue.getPropertyID());
}
}
