テキスト比較

2 つのテキストファイルの違いを見つける

リアルタイムdiff

統一diff

行を折りたたむ

変更をハイライト

シンタックスハイライト

ツール

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 8 years agoDiff never expires

行
合計
削除

単語
合計
削除

この機能を引き続き使用するには、アップグレードしてください Diffchecker Pro 価格を見る

568 行

行
合計
追加

単語
合計
追加

この機能を引き続き使用するには、アップグレードしてください Diffchecker Pro 価格を見る

558 行

// Generated from template:

// templates/StyleBuilderFunctions.cpp.tmpl

// and input files:

// ../../third_party/WebKit/Source/core/css/ComputedStyleFieldAliases.json5

// ../../third_party/WebKit/Source/core/css/CSSProperties.json5

#include "StyleBuilderFunctions.h"

#include "CSSValueKeywords.h"

#include "core/animation/css/CSSAnimationData.h"

#include "core/css/BasicShapeFunctions.h"

#include "core/css/CSSContentDistributionValue.h"

#include "core/css/CSSCustomIdentValue.h"

#include "core/css/CSSPrimitiveValueMappings.h"

#include "core/css/CSSURIValue.h"

#include "core/css/CSSValuePair.h"

#include "core/css/resolver/StyleResolverState.h"

#include "core/style/ComputedStyle.h"

namespace blink {

void StyleBuilderFunctions::applyInitialCSSPropertyDirection(StyleResolverState& state) {

state.Style()->SetDirection(ComputedStyle::InitialDirection());

state.Style()->SetDirection(ComputedStyleInitialFunctions::InitialDirection());

}

void StyleBuilderFunctions::applyInheritCSSPropertyDirection(StyleResolverState& state) {

state.Style()->SetDirection(state.ParentStyle()->Direction());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFontKerning(StyleResolverState& state) {

state.GetFontBuilder().SetKerning(FontBuilder::InitialKerning());

}

void StyleBuilderFunctions::applyInheritCSSPropertyFontKerning(StyleResolverState& state) {

state.GetFontBuilder().SetKerning(state.ParentFontDescription().GetKerning());

}

void StyleBuilderFunctions::applyValueCSSPropertyFontKerning(StyleResolverState& state, const CSSValue& value) {

state.GetFontBuilder().SetKerning(ToCSSIdentifierValue(value).ConvertTo<FontDescription::Kerning>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOrientation(StyleResolverState& state) {

state.Style()->SetTextOrientation(ComputedStyle::InitialTextOrientation());

state.Style()->SetTextOrientation(ComputedStyleInitialFunctions::InitialTextOrientation());

}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOrientation(StyleResolverState& state) {

state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextRendering(StyleResolverState& state) {

state.GetFontBuilder().SetTextRendering(FontBuilder::InitialTextRendering());

}

void StyleBuilderFunctions::applyInheritCSSPropertyTextRendering(StyleResolverState& state) {

state.GetFontBuilder().SetTextRendering(state.ParentFontDescription().TextRendering());

}

void StyleBuilderFunctions::applyValueCSSPropertyTextRendering(StyleResolverState& state, const CSSValue& value) {

state.GetFontBuilder().SetTextRendering(ToCSSIdentifierValue(value).ConvertTo<TextRenderingMode>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {

state.GetFontBuilder().SetFontSmoothing(FontBuilder::InitialFontSmoothing());

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {

state.GetFontBuilder().SetFontSmoothing(state.ParentFontDescription().FontSmoothing());

}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitFontSmoothing(StyleResolverState& state, const CSSValue& value) {

state.GetFontBuilder().SetFontSmoothing(ToCSSIdentifierValue(value).ConvertTo<FontSmoothingMode>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLocale(StyleResolverState& state) {

state.GetFontBuilder().SetLocale(FontBuilder::InitialLocale());

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLocale(StyleResolverState& state) {

state.GetFontBuilder().SetLocale(state.ParentFontDescription().Locale());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextOrientation(StyleResolverState& state) {

state.Style()->SetTextOrientation(ComputedStyle::InitialTextOrientation());

state.Style()->SetTextOrientation(ComputedStyleInitialFunctions::InitialTextOrientation());

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextOrientation(StyleResolverState& state) {

state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitWritingMode(StyleResolverState& state) {

state.Style()->SetWritingMode(ComputedStyle::InitialWritingMode());

state.Style()->SetWritingMode(ComputedStyleInitialFunctions::InitialWritingMode());

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitWritingMode(StyleResolverState& state) {

state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWritingMode(StyleResolverState& state) {

state.Style()->SetWritingMode(ComputedStyle::InitialWritingMode());

state.Style()->SetWritingMode(ComputedStyleInitialFunctions::InitialWritingMode());

}

void StyleBuilderFunctions::applyInheritCSSPropertyWritingMode(StyleResolverState& state) {

state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());

}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignContent(StyleResolverState& state) {

state.Style()->SetAlignContent(ComputedStyle::InitialAlignContent());

state.Style()->SetAlignContent(ComputedStyleInitialFunctions::InitialAlignContent());

}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignContent(StyleResolverState& state) {

state.Style()->SetAlignContent(state.ParentStyle()->AlignContent());

}

void StyleBuilderFunctions::applyValueCSSPropertyAlignContent(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetAlignContent(StyleBuilderConverter::ConvertContentAlignmentData(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignmentBaseline(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetAlignmentBaseline(SVGComputedStyle::InitialAlignmentBaseline());

}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignmentBaseline(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetAlignmentBaseline(state.ParentStyle()->SvgStyle().AlignmentBaseline());

}

void StyleBuilderFunctions::applyValueCSSPropertyAlignmentBaseline(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetAlignmentBaseline(ToCSSIdentifierValue(value).ConvertTo<EAlignmentBaseline>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBackfaceVisibility(StyleResolverState& state) {

state.Style()->SetBackfaceVisibility(ComputedStyle::InitialBackfaceVisibility());

state.Style()->SetBackfaceVisibility(ComputedStyleInitialFunctions::InitialBackfaceVisibility());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBackfaceVisibility(StyleResolverState& state) {

state.Style()->SetBackfaceVisibility(state.ParentStyle()->BackfaceVisibility());

}

void StyleBuilderFunctions::applyValueCSSPropertyBackfaceVisibility(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBackfaceVisibility(ToCSSIdentifierValue(value).ConvertTo<EBackfaceVisibility>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBaselineShift(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetBaselineShift(SVGComputedStyle::InitialBaselineShift());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {

state.Style()->SetBorderBottomLeftRadius(ComputedStyle::InitialBorderBottomLeftRadius());

state.Style()->SetBorderBottomLeftRadius(ComputedStyleInitialFunctions::InitialBorderBottomLeftRadius());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {

state.Style()->SetBorderBottomLeftRadius(state.ParentStyle()->BorderBottomLeftRadius());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomLeftRadius(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderBottomLeftRadius(StyleBuilderConverter::ConvertRadius(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {

state.Style()->SetBorderBottomRightRadius(ComputedStyle::InitialBorderBottomRightRadius());

state.Style()->SetBorderBottomRightRadius(ComputedStyleInitialFunctions::InitialBorderBottomRightRadius());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {

state.Style()->SetBorderBottomRightRadius(state.ParentStyle()->BorderBottomRightRadius());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomRightRadius(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderBottomRightRadius(StyleBuilderConverter::ConvertRadius(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomStyle(StyleResolverState& state) {

state.Style()->SetBorderBottomStyle(ComputedStyle::InitialBorderBottomStyle());

state.Style()->SetBorderBottomStyle(ComputedStyleInitialFunctions::InitialBorderBottomStyle());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomStyle(StyleResolverState& state) {

state.Style()->SetBorderBottomStyle(state.ParentStyle()->BorderBottomStyle());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomStyle(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderBottomStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomWidth(StyleResolverState& state) {

state.Style()->SetBorderBottomWidth(ComputedStyle::InitialBorderBottomWidth());

state.Style()->SetBorderBottomWidth(ComputedStyleInitialFunctions::InitialBorderBottomWidth());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomWidth(StyleResolverState& state) {

state.Style()->SetBorderBottomWidth(state.ParentStyle()->BorderBottomWidth());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomWidth(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderBottomWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderCollapse(StyleResolverState& state) {

state.Style()->SetBorderCollapse(ComputedStyle::InitialBorderCollapse());

state.Style()->SetBorderCollapse(ComputedStyleInitialFunctions::InitialBorderCollapse());

state.Style()->SetBorderCollapseIsInherited

(false);

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderCollapse(StyleResolverState& state) {

state.Style()->SetBorderCollapse(state.ParentStyle()->BorderCollapse());

state.Style()->SetBorderCollapseIsInherited

(true);

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderCollapse(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderCollapse(ToCSSIdentifierValue(value).ConvertTo<EBorderCollapse>());

state.Style()->SetBorderCollapseIsInherited

(false);

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageSource(StyleResolverState& state) {

state.Style()->SetBorderImageSource(ComputedStyle::InitialBorderImageSource());

state.Style()->SetBorderImageSource(ComputedStyleInitialFunctions::InitialBorderImageSource());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageSource(StyleResolverState& state) {

state.Style()->SetBorderImageSource(state.ParentStyle()->BorderImageSource());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftStyle(StyleResolverState& state) {

state.Style()->SetBorderLeftStyle(ComputedStyle::InitialBorderLeftStyle());

state.Style()->SetBorderLeftStyle(ComputedStyleInitialFunctions::InitialBorderLeftStyle());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftStyle(StyleResolverState& state) {

state.Style()->SetBorderLeftStyle(state.ParentStyle()->BorderLeftStyle());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderLeftStyle(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderLeftStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftWidth(StyleResolverState& state) {

state.Style()->SetBorderLeftWidth(ComputedStyle::InitialBorderLeftWidth());

state.Style()->SetBorderLeftWidth(ComputedStyleInitialFunctions::InitialBorderLeftWidth());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftWidth(StyleResolverState& state) {

state.Style()->SetBorderLeftWidth(state.ParentStyle()->BorderLeftWidth());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderLeftWidth(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderLeftWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightStyle(StyleResolverState& state) {

state.Style()->SetBorderRightStyle(ComputedStyle::InitialBorderRightStyle());

state.Style()->SetBorderRightStyle(ComputedStyleInitialFunctions::InitialBorderRightStyle());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightStyle(StyleResolverState& state) {

state.Style()->SetBorderRightStyle(state.ParentStyle()->BorderRightStyle());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderRightStyle(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderRightStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightWidth(StyleResolverState& state) {

state.Style()->SetBorderRightWidth(ComputedStyle::InitialBorderRightWidth());

state.Style()->SetBorderRightWidth(ComputedStyleInitialFunctions::InitialBorderRightWidth());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightWidth(StyleResolverState& state) {

state.Style()->SetBorderRightWidth(state.ParentStyle()->BorderRightWidth());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderRightWidth(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderRightWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {

state.Style()->SetBorderTopLeftRadius(ComputedStyle::InitialBorderTopLeftRadius());

state.Style()->SetBorderTopLeftRadius(ComputedStyleInitialFunctions::InitialBorderTopLeftRadius());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {

state.Style()->SetBorderTopLeftRadius(state.ParentStyle()->BorderTopLeftRadius());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopLeftRadius(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderTopLeftRadius(StyleBuilderConverter::ConvertRadius(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopRightRadius(StyleResolverState& state) {

state.Style()->SetBorderTopRightRadius(ComputedStyle::InitialBorderTopRightRadius());

state.Style()->SetBorderTopRightRadius(ComputedStyleInitialFunctions::InitialBorderTopRightRadius());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopRightRadius(StyleResolverState& state) {

state.Style()->SetBorderTopRightRadius(state.ParentStyle()->BorderTopRightRadius());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopRightRadius(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderTopRightRadius(StyleBuilderConverter::ConvertRadius(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopStyle(StyleResolverState& state) {

state.Style()->SetBorderTopStyle(ComputedStyle::InitialBorderTopStyle());

state.Style()->SetBorderTopStyle(ComputedStyleInitialFunctions::InitialBorderTopStyle());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopStyle(StyleResolverState& state) {

state.Style()->SetBorderTopStyle(state.ParentStyle()->BorderTopStyle());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopStyle(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderTopStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopWidth(StyleResolverState& state) {

state.Style()->SetBorderTopWidth(ComputedStyle::InitialBorderTopWidth());

state.Style()->SetBorderTopWidth(ComputedStyleInitialFunctions::InitialBorderTopWidth());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopWidth(StyleResolverState& state) {

state.Style()->SetBorderTopWidth(state.ParentStyle()->BorderTopWidth());

}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopWidth(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBorderTopWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBottom(StyleResolverState& state) {

state.Style()->SetBottom(ComputedStyle::InitialBottom());

state.Style()->SetBottom(ComputedStyleInitialFunctions::InitialBottom());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBottom(StyleResolverState& state) {

state.Style()->SetBottom(state.ParentStyle()->Bottom());

}

void StyleBuilderFunctions::applyValueCSSPropertyBottom(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBottom(StyleBuilderConverter::ConvertLengthOrAuto(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyBoxSizing(StyleResolverState& state) {

state.Style()->SetBoxSizing(ComputedStyle::InitialBoxSizing());

state.Style()->SetBoxSizing(ComputedStyleInitialFunctions::InitialBoxSizing());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBoxSizing(StyleResolverState& state) {

state.Style()->SetBoxSizing(state.ParentStyle()->BoxSizing());

}

void StyleBuilderFunctions::applyValueCSSPropertyBoxSizing(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBoxSizing(ToCSSIdentifierValue(value).ConvertTo<EBoxSizing>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakAfter(StyleResolverState& state) {

state.Style()->SetBreakAfter(ComputedStyle::InitialBreakAfter());

state.Style()->SetBreakAfter(ComputedStyleInitialFunctions::InitialBreakAfter());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakAfter(StyleResolverState& state) {

state.Style()->SetBreakAfter(state.ParentStyle()->BreakAfter());

}

void StyleBuilderFunctions::applyValueCSSPropertyBreakAfter(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBreakAfter(ToCSSIdentifierValue(value).ConvertTo<EBreakBetween>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakBefore(StyleResolverState& state) {

state.Style()->SetBreakBefore(ComputedStyle::InitialBreakBefore());

state.Style()->SetBreakBefore(ComputedStyleInitialFunctions::InitialBreakBefore());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakBefore(StyleResolverState& state) {

state.Style()->SetBreakBefore(state.ParentStyle()->BreakBefore());

}

void StyleBuilderFunctions::applyValueCSSPropertyBreakBefore(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBreakBefore(ToCSSIdentifierValue(value).ConvertTo<EBreakBetween>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakInside(StyleResolverState& state) {

state.Style()->SetBreakInside(ComputedStyle::InitialBreakInside());

state.Style()->SetBreakInside(ComputedStyleInitialFunctions::InitialBreakInside());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakInside(StyleResolverState& state) {

state.Style()->SetBreakInside(state.ParentStyle()->BreakInside());

}

void StyleBuilderFunctions::applyValueCSSPropertyBreakInside(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetBreakInside(ToCSSIdentifierValue(value).ConvertTo<EBreakInside>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBufferedRendering(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetBufferedRendering(SVGComputedStyle::InitialBufferedRendering());

}

void StyleBuilderFunctions::applyInheritCSSPropertyBufferedRendering(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetBufferedRendering(state.ParentStyle()->SvgStyle().BufferedRendering());

}

void StyleBuilderFunctions::applyValueCSSPropertyBufferedRendering(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetBufferedRendering(ToCSSIdentifierValue(value).ConvertTo<EBufferedRendering>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyCaptionSide(StyleResolverState& state) {

state.Style()->SetCaptionSide(ComputedStyle::InitialCaptionSide());

state.Style()->SetCaptionSide(ComputedStyleInitialFunctions::InitialCaptionSide());

state.Style()->SetCaptionSideIsInherited

(false);

}

void StyleBuilderFunctions::applyInheritCSSPropertyCaptionSide(StyleResolverState& state) {

state.Style()->SetCaptionSide(state.ParentStyle()->CaptionSide());

state.Style()->SetCaptionSideIsInherited

(true);

}

void StyleBuilderFunctions::applyValueCSSPropertyCaptionSide(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetCaptionSide(ToCSSIdentifierValue(value).ConvertTo<ECaptionSide>());

state.Style()->SetCaptionSideIsInherited

(false);

}

void StyleBuilderFunctions::applyInitialCSSPropertyClear(StyleResolverState& state) {

state.Style()->SetClear(ComputedStyle::InitialClear());

state.Style()->SetClear(ComputedStyleInitialFunctions::InitialClear());

}

void StyleBuilderFunctions::applyInheritCSSPropertyClear(StyleResolverState& state) {

state.Style()->SetClear(state.ParentStyle()->Clear());

}

void StyleBuilderFunctions::applyValueCSSPropertyClear(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetClear(ToCSSIdentifierValue(value).ConvertTo<EClear>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyClipRule(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetClipRule(SVGComputedStyle::InitialClipRule());

}

void StyleBuilderFunctions::applyInheritCSSPropertyClipRule(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetClipRule(state.ParentStyle()->SvgStyle().ClipRule());

}

void StyleBuilderFunctions::applyValueCSSPropertyClipRule(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetClipRule(ToCSSIdentifierValue(value).ConvertTo<WindRule>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorInterpolation(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetColorInterpolation(SVGComputedStyle::InitialColorInterpolation());

}

void StyleBuilderFunctions::applyInheritCSSPropertyColorInterpolation(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetColorInterpolation(state.ParentStyle()->SvgStyle().ColorInterpolation());

}

void StyleBuilderFunctions::applyValueCSSPropertyColorInterpolation(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetColorInterpolation(ToCSSIdentifierValue(value).ConvertTo<EColorInterpolation>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorInterpolationFilters(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetColorInterpolationFilters(SVGComputedStyle::InitialColorInterpolationFilters());

}

void StyleBuilderFunctions::applyInheritCSSPropertyColorInterpolationFilters(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetColorInterpolationFilters(state.ParentStyle()->SvgStyle().ColorInterpolationFilters());

}

void StyleBuilderFunctions::applyValueCSSPropertyColorInterpolationFilters(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetColorInterpolationFilters(ToCSSIdentifierValue(value).ConvertTo<EColorInterpolation>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorRendering(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetColorRendering(SVGComputedStyle::InitialColorRendering());

}

void StyleBuilderFunctions::applyInheritCSSPropertyColorRendering(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetColorRendering(state.ParentStyle()->SvgStyle().ColorRendering());

}

void StyleBuilderFunctions::applyValueCSSPropertyColorRendering(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetColorRendering(ToCSSIdentifierValue(value).ConvertTo<EColorRendering>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnFill(StyleResolverState& state) {

state.Style()->SetColumnFill(ComputedStyle::InitialColumnFill());

state.Style()->SetColumnFill(ComputedStyleInitialFunctions::InitialColumnFill());

}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnFill(StyleResolverState& state) {

state.Style()->SetColumnFill(state.ParentStyle()->GetColumnFill());

}

void StyleBuilderFunctions::applyValueCSSPropertyColumnFill(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetColumnFill(ToCSSIdentifierValue(value).ConvertTo<EColumnFill>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnRuleStyle(StyleResolverState& state) {

state.Style()->SetColumnRuleStyle(ComputedStyle::InitialColumnRuleStyle());

state.Style()->SetColumnRuleStyle(ComputedStyleInitialFunctions::InitialColumnRuleStyle());

}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnRuleStyle(StyleResolverState& state) {

state.Style()->SetColumnRuleStyle(state.ParentStyle()->ColumnRuleStyle());

}

void StyleBuilderFunctions::applyValueCSSPropertyColumnRuleStyle(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetColumnRuleStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyCx(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetCx(SVGComputedStyle::InitialCx());

}

void StyleBuilderFunctions::applyInheritCSSPropertyCx(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetCx(state.ParentStyle()->SvgStyle().Cx());

}

void StyleBuilderFunctions::applyValueCSSPropertyCx(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetCx(StyleBuilderConverter::ConvertLength(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyCy(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetCy(SVGComputedStyle::InitialCy());

}

void StyleBuilderFunctions::applyInheritCSSPropertyCy(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetCy(state.ParentStyle()->SvgStyle().Cy());

}

void StyleBuilderFunctions::applyValueCSSPropertyCy(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetCy(StyleBuilderConverter::ConvertLength(state, value));

}

void StyleBuilderFunctions::applyInitialCSSPropertyDisplay(StyleResolverState& state) {

state.Style()->SetDisplay(ComputedStyle::InitialDisplay());

state.Style()->SetDisplay(ComputedStyleInitialFunctions::InitialDisplay());

}

void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state) {

state.Style()->SetDisplay(state.ParentStyle()->Display());

}

void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolverState& state, const CSSValue& value) {

state.Style()->SetDisplay(ToCSSIdentifierValue(value).ConvertTo<EDisplay>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyDominantBaseline(StyleResolverState& state) {

state.Style()->AccessSVGStyle().SetDominantBaseline(SVGComputedStyle::InitialDominantBaseline());

}

void StyleBuilderFunctions::applyInheritCSSPropertyDominantBaseline(StyleResolverState& state) {

void StyleBuilderFunctions::applyInheritCSSPropertyDom

state.Style()->AccessSVGStyle().SetDominantBaseline(state.ParentStyle()->SvgStyle().DominantBaseline());

}

void StyleBuilderFunctions::applyValueCSSPropertyDominantBaseline(StyleResolverState& state, const CSSValue& value) {

state.Style()->AccessSVGStyle().SetDominantBaseline(ToCSSIdentifierValue(value).ConvertTo<EDominantBaseline>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyEmptyCells(StyleResolverState& state) {

state.Style()

保存された差分

原文

ファイルを開く

// Generated from template:
//   templates/StyleBuilderFunctions.cpp.tmpl
// and input files:
//   ../../third_party/WebKit/Source/core/css/ComputedStyleFieldAliases.json5
//   ../../third_party/WebKit/Source/core/css/CSSProperties.json5

#include "StyleBuilderFunctions.h"

#include "CSSValueKeywords.h"
#include "core/animation/css/CSSAnimationData.h"
#include "core/css/BasicShapeFunctions.h"
#include "core/css/CSSContentDistributionValue.h"
#include "core/css/CSSCustomIdentValue.h"
#include "core/css/CSSPrimitiveValueMappings.h"
#include "core/css/CSSURIValue.h"
#include "core/css/CSSValuePair.h"
#include "core/css/resolver/StyleResolverState.h"
#include "core/style/ComputedStyle.h"

namespace blink {

void StyleBuilderFunctions::applyInitialCSSPropertyDirection(StyleResolverState& state) {
  state.Style()->SetDirection(ComputedStyle::InitialDirection());
}

void StyleBuilderFunctions::applyInheritCSSPropertyDirection(StyleResolverState& state) {
  state.Style()->SetDirection(state.ParentStyle()->Direction());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFontKerning(StyleResolverState& state) {
  state.GetFontBuilder().SetKerning(FontBuilder::InitialKerning());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFontKerning(StyleResolverState& state) {
  state.GetFontBuilder().SetKerning(state.ParentFontDescription().GetKerning());
}

void StyleBuilderFunctions::applyValueCSSPropertyFontKerning(StyleResolverState& state, const CSSValue& value) {
  state.GetFontBuilder().SetKerning(ToCSSIdentifierValue(value).ConvertTo<FontDescription::Kerning>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(ComputedStyle::InitialTextOrientation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextRendering(StyleResolverState& state) {
  state.GetFontBuilder().SetTextRendering(FontBuilder::InitialTextRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextRendering(StyleResolverState& state) {
  state.GetFontBuilder().SetTextRendering(state.ParentFontDescription().TextRendering());
}

void StyleBuilderFunctions::applyValueCSSPropertyTextRendering(StyleResolverState& state, const CSSValue& value) {
  state.GetFontBuilder().SetTextRendering(ToCSSIdentifierValue(value).ConvertTo<TextRenderingMode>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {
  state.GetFontBuilder().SetFontSmoothing(FontBuilder::InitialFontSmoothing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {
  state.GetFontBuilder().SetFontSmoothing(state.ParentFontDescription().FontSmoothing());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitFontSmoothing(StyleResolverState& state, const CSSValue& value) {
  state.GetFontBuilder().SetFontSmoothing(ToCSSIdentifierValue(value).ConvertTo<FontSmoothingMode>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLocale(StyleResolverState& state) {
  state.GetFontBuilder().SetLocale(FontBuilder::InitialLocale());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLocale(StyleResolverState& state) {
  state.GetFontBuilder().SetLocale(state.ParentFontDescription().Locale());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(ComputedStyle::InitialTextOrientation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(ComputedStyle::InitialWritingMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(ComputedStyle::InitialWritingMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());
}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignContent(StyleResolverState& state) {
  state.Style()->SetAlignContent(ComputedStyle::InitialAlignContent());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignContent(StyleResolverState& state) {
  state.Style()->SetAlignContent(state.ParentStyle()->AlignContent());
}

void StyleBuilderFunctions::applyValueCSSPropertyAlignContent(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetAlignContent(StyleBuilderConverter::ConvertContentAlignmentData(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignmentBaseline(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetAlignmentBaseline(SVGComputedStyle::InitialAlignmentBaseline());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignmentBaseline(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetAlignmentBaseline(state.ParentStyle()->SvgStyle().AlignmentBaseline());
}

void StyleBuilderFunctions::applyValueCSSPropertyAlignmentBaseline(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetAlignmentBaseline(ToCSSIdentifierValue(value).ConvertTo<EAlignmentBaseline>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBackfaceVisibility(StyleResolverState& state) {
  state.Style()->SetBackfaceVisibility(ComputedStyle::InitialBackfaceVisibility());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackfaceVisibility(StyleResolverState& state) {
  state.Style()->SetBackfaceVisibility(state.ParentStyle()->BackfaceVisibility());
}

void StyleBuilderFunctions::applyValueCSSPropertyBackfaceVisibility(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBackfaceVisibility(ToCSSIdentifierValue(value).ConvertTo<EBackfaceVisibility>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBaselineShift(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetBaselineShift(SVGComputedStyle::InitialBaselineShift());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomLeftRadius(ComputedStyle::InitialBorderBottomLeftRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomLeftRadius(state.ParentStyle()->BorderBottomLeftRadius());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomLeftRadius(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderBottomLeftRadius(StyleBuilderConverter::ConvertRadius(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomRightRadius(ComputedStyle::InitialBorderBottomRightRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomRightRadius(state.ParentStyle()->BorderBottomRightRadius());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomRightRadius(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderBottomRightRadius(StyleBuilderConverter::ConvertRadius(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomStyle(StyleResolverState& state) {
  state.Style()->SetBorderBottomStyle(ComputedStyle::InitialBorderBottomStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomStyle(StyleResolverState& state) {
  state.Style()->SetBorderBottomStyle(state.ParentStyle()->BorderBottomStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomStyle(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderBottomStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomWidth(StyleResolverState& state) {
  state.Style()->SetBorderBottomWidth(ComputedStyle::InitialBorderBottomWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomWidth(StyleResolverState& state) {
  state.Style()->SetBorderBottomWidth(state.ParentStyle()->BorderBottomWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderBottomWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderCollapse(StyleResolverState& state) {
  state.Style()->SetBorderCollapse(ComputedStyle::InitialBorderCollapse());
  state.Style()->SetBorderCollapseIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderCollapse(StyleResolverState& state) {
  state.Style()->SetBorderCollapse(state.ParentStyle()->BorderCollapse());
  state.Style()->SetBorderCollapseIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderCollapse(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderCollapse(ToCSSIdentifierValue(value).ConvertTo<EBorderCollapse>());

state.Style()->SetBorderCollapseIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageSource(StyleResolverState& state) {
  state.Style()->SetBorderImageSource(ComputedStyle::InitialBorderImageSource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageSource(StyleResolverState& state) {
  state.Style()->SetBorderImageSource(state.ParentStyle()->BorderImageSource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftStyle(StyleResolverState& state) {
  state.Style()->SetBorderLeftStyle(ComputedStyle::InitialBorderLeftStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftStyle(StyleResolverState& state) {
  state.Style()->SetBorderLeftStyle(state.ParentStyle()->BorderLeftStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderLeftStyle(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderLeftStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftWidth(StyleResolverState& state) {
  state.Style()->SetBorderLeftWidth(ComputedStyle::InitialBorderLeftWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftWidth(StyleResolverState& state) {
  state.Style()->SetBorderLeftWidth(state.ParentStyle()->BorderLeftWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderLeftWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderLeftWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightStyle(StyleResolverState& state) {
  state.Style()->SetBorderRightStyle(ComputedStyle::InitialBorderRightStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightStyle(StyleResolverState& state) {
  state.Style()->SetBorderRightStyle(state.ParentStyle()->BorderRightStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderRightStyle(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderRightStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightWidth(StyleResolverState& state) {
  state.Style()->SetBorderRightWidth(ComputedStyle::InitialBorderRightWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightWidth(StyleResolverState& state) {
  state.Style()->SetBorderRightWidth(state.ParentStyle()->BorderRightWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderRightWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderRightWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopLeftRadius(ComputedStyle::InitialBorderTopLeftRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopLeftRadius(state.ParentStyle()->BorderTopLeftRadius());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopLeftRadius(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderTopLeftRadius(StyleBuilderConverter::ConvertRadius(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopRightRadius(ComputedStyle::InitialBorderTopRightRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopRightRadius(state.ParentStyle()->BorderTopRightRadius());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopRightRadius(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderTopRightRadius(StyleBuilderConverter::ConvertRadius(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopStyle(StyleResolverState& state) {
  state.Style()->SetBorderTopStyle(ComputedStyle::InitialBorderTopStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopStyle(StyleResolverState& state) {
  state.Style()->SetBorderTopStyle(state.ParentStyle()->BorderTopStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopStyle(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderTopStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopWidth(StyleResolverState& state) {
  state.Style()->SetBorderTopWidth(ComputedStyle::InitialBorderTopWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopWidth(StyleResolverState& state) {
  state.Style()->SetBorderTopWidth(state.ParentStyle()->BorderTopWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderTopWidth(StyleBuilderConverter::ConvertBorderWidth(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBottom(StyleResolverState& state) {
  state.Style()->SetBottom(ComputedStyle::InitialBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBottom(StyleResolverState& state) {
  state.Style()->SetBottom(state.ParentStyle()->Bottom());
}

void StyleBuilderFunctions::applyValueCSSPropertyBottom(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBottom(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBoxSizing(StyleResolverState& state) {
  state.Style()->SetBoxSizing(ComputedStyle::InitialBoxSizing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBoxSizing(StyleResolverState& state) {
  state.Style()->SetBoxSizing(state.ParentStyle()->BoxSizing());
}

void StyleBuilderFunctions::applyValueCSSPropertyBoxSizing(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxSizing(ToCSSIdentifierValue(value).ConvertTo<EBoxSizing>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakAfter(StyleResolverState& state) {
  state.Style()->SetBreakAfter(ComputedStyle::InitialBreakAfter());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakAfter(StyleResolverState& state) {
  state.Style()->SetBreakAfter(state.ParentStyle()->BreakAfter());
}

void StyleBuilderFunctions::applyValueCSSPropertyBreakAfter(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBreakAfter(ToCSSIdentifierValue(value).ConvertTo<EBreakBetween>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakBefore(StyleResolverState& state) {
  state.Style()->SetBreakBefore(ComputedStyle::InitialBreakBefore());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakBefore(StyleResolverState& state) {
  state.Style()->SetBreakBefore(state.ParentStyle()->BreakBefore());
}

void StyleBuilderFunctions::applyValueCSSPropertyBreakBefore(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBreakBefore(ToCSSIdentifierValue(value).ConvertTo<EBreakBetween>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakInside(StyleResolverState& state) {
  state.Style()->SetBreakInside(ComputedStyle::InitialBreakInside());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakInside(StyleResolverState& state) {
  state.Style()->SetBreakInside(state.ParentStyle()->BreakInside());
}

void StyleBuilderFunctions::applyValueCSSPropertyBreakInside(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBreakInside(ToCSSIdentifierValue(value).ConvertTo<EBreakInside>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBufferedRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetBufferedRendering(SVGComputedStyle::InitialBufferedRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBufferedRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetBufferedRendering(state.ParentStyle()->SvgStyle().BufferedRendering());
}

void StyleBuilderFunctions::applyValueCSSPropertyBufferedRendering(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetBufferedRendering(ToCSSIdentifierValue(value).ConvertTo<EBufferedRendering>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyCaptionSide(StyleResolverState& state) {
  state.Style()->SetCaptionSide(ComputedStyle::InitialCaptionSide());
  state.Style()->SetCaptionSideIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyCaptionSide(StyleResolverState& state) {
  state.Style()->SetCaptionSide(state.ParentStyle()->CaptionSide());
  state.Style()->SetCaptionSideIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyCaptionSide(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetCaptionSide(ToCSSIdentifierValue(value).ConvertTo<ECaptionSide>());

state.Style()->SetCaptionSideIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyClear(StyleResolverState& state) {
  state.Style()->SetClear(ComputedStyle::InitialClear());
}

void StyleBuilderFunctions::applyInheritCSSPropertyClear(StyleResolverState& state) {
  state.Style()->SetClear(state.ParentStyle()->Clear());
}

void StyleBuilderFunctions::applyValueCSSPropertyClear(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetClear(ToCSSIdentifierValue(value).ConvertTo<EClear>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyClipRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetClipRule(SVGComputedStyle::InitialClipRule());
}

void StyleBuilderFunctions::applyInheritCSSPropertyClipRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetClipRule(state.ParentStyle()->SvgStyle().ClipRule());
}

void StyleBuilderFunctions::applyValueCSSPropertyClipRule(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetClipRule(ToCSSIdentifierValue(value).ConvertTo<WindRule>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorInterpolation(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorInterpolation(SVGComputedStyle::InitialColorInterpolation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColorInterpolation(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorInterpolation(state.ParentStyle()->SvgStyle().ColorInterpolation());
}

void StyleBuilderFunctions::applyValueCSSPropertyColorInterpolation(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetColorInterpolation(ToCSSIdentifierValue(value).ConvertTo<EColorInterpolation>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorInterpolationFilters(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorInterpolationFilters(SVGComputedStyle::InitialColorInterpolationFilters());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColorInterpolationFilters(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorInterpolationFilters(state.ParentStyle()->SvgStyle().ColorInterpolationFilters());
}

void StyleBuilderFunctions::applyValueCSSPropertyColorInterpolationFilters(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetColorInterpolationFilters(ToCSSIdentifierValue(value).ConvertTo<EColorInterpolation>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorRendering(SVGComputedStyle::InitialColorRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColorRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorRendering(state.ParentStyle()->SvgStyle().ColorRendering());
}

void StyleBuilderFunctions::applyValueCSSPropertyColorRendering(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetColorRendering(ToCSSIdentifierValue(value).ConvertTo<EColorRendering>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnFill(StyleResolverState& state) {
  state.Style()->SetColumnFill(ComputedStyle::InitialColumnFill());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnFill(StyleResolverState& state) {
  state.Style()->SetColumnFill(state.ParentStyle()->GetColumnFill());
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnFill(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetColumnFill(ToCSSIdentifierValue(value).ConvertTo<EColumnFill>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnRuleStyle(StyleResolverState& state) {
  state.Style()->SetColumnRuleStyle(ComputedStyle::InitialColumnRuleStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnRuleStyle(StyleResolverState& state) {
  state.Style()->SetColumnRuleStyle(state.ParentStyle()->ColumnRuleStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnRuleStyle(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetColumnRuleStyle(ToCSSIdentifierValue(value).ConvertTo<EBorderStyle>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyCx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCx(SVGComputedStyle::InitialCx());
}

void StyleBuilderFunctions::applyInheritCSSPropertyCx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCx(state.ParentStyle()->SvgStyle().Cx());
}

void StyleBuilderFunctions::applyValueCSSPropertyCx(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetCx(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyCy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCy(SVGComputedStyle::InitialCy());
}

void StyleBuilderFunctions::applyInheritCSSPropertyCy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCy(state.ParentStyle()->SvgStyle().Cy());
}

void StyleBuilderFunctions::applyValueCSSPropertyCy(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetCy(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyDisplay(StyleResolverState& state) {
  state.Style()->SetDisplay(ComputedStyle::InitialDisplay());
}

void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state) {
  state.Style()->SetDisplay(state.ParentStyle()->Display());
}

void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetDisplay(ToCSSIdentifierValue(value).ConvertTo<EDisplay>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyDominantBaseline(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetDominantBaseline(SVGComputedStyle::InitialDominantBaseline());
}

void StyleBuilderFunctions::applyInheritCSSPropertyDominantBaseline(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetDominantBaseline(state.ParentStyle()->SvgStyle().DominantBaseline());
}

void StyleBuilderFunctions::applyValueCSSPropertyDominantBaseline(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetDominantBaseline(ToCSSIdentifierValue(value).ConvertTo<EDominantBaseline>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyEmptyCells(StyleResolverState& state) {
  state.Style()->SetEmptyCells(ComputedStyle::InitialEmptyCells());
  state.Style()->SetEmptyCellsIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyEmptyCells(StyleResolverState& state) {
  state.Style()->SetEmptyCells(state.ParentStyle()->EmptyCells());
  state.Style()->SetEmptyCellsIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyEmptyCells(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetEmptyCells(ToCSSIdentifierValue(value).ConvertTo<EEmptyCells>());

state.Style()->SetEmptyCellsIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyFillOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillOpacity(SVGComputedStyle::InitialFillOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFillOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillOpacity(state.ParentStyle()->SvgStyle().FillOpacity());
}

void StyleBuilderFunctions::applyValueCSSPropertyFillOpacity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetFillOpacity(StyleBuilderConverter::ConvertNumberOrPercentage(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyFillRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillRule(SVGComputedStyle::InitialFillRule());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFillRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillRule(state.ParentStyle()->SvgStyle().FillRule());
}

void StyleBuilderFunctions::applyValueCSSPropertyFillRule(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetFillRule(ToCSSIdentifierValue(value).ConvertTo<WindRule>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexDirection(StyleResolverState& state) {
  state.Style()->SetFlexDirection(ComputedStyle::InitialFlexDirection());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexDirection(StyleResolverState& state) {
  state.Style()->SetFlexDirection(state.ParentStyle()->FlexDirection());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexDirection(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexDirection(ToCSSIdentifierValue(value).ConvertTo<EFlexDirection>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexGrow(StyleResolverState& state) {
  state.Style()->SetFlexGrow(ComputedStyle::InitialFlexGrow());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexGrow(StyleResolverState& state) {
  state.Style()->SetFlexGrow(state.ParentStyle()->FlexGrow());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexGrow(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexGrow(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexShrink(StyleResolverState& state) {
  state.Style()->SetFlexShrink(ComputedStyle::InitialFlexShrink());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexShrink(StyleResolverState& state) {
  state.Style()->SetFlexShrink(state.ParentStyle()->FlexShrink());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexShrink(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexShrink(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexWrap(StyleResolverState& state) {
  state.Style()->SetFlexWrap(ComputedStyle::InitialFlexWrap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexWrap(StyleResolverState& state) {
  state.Style()->SetFlexWrap(state.ParentStyle()->FlexWrap());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexWrap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexWrap(ToCSSIdentifierValue(value).ConvertTo<EFlexWrap>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFloat(StyleResolverState& state) {
  state.Style()->SetFloating(ComputedStyle::InitialFloating());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloat(StyleResolverState& state) {
  state.Style()->SetFloating(state.ParentStyle()->Floating());
}

void StyleBuilderFunctions::applyValueCSSPropertyFloat(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFloating(ToCSSIdentifierValue(value).ConvertTo<EFloat>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFloodColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodColor(SVGComputedStyle::InitialFloodColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloodColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodColor(state.ParentStyle()->SvgStyle().FloodColor());
}

void StyleBuilderFunctions::applyValueCSSPropertyFloodColor(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetFloodColor(StyleBuilderConverter::ConvertColor(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyFloodOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodOpacity(SVGComputedStyle::InitialFloodOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloodOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodOpacity(state.ParentStyle()->SvgStyle().FloodOpacity());
}

void StyleBuilderFunctions::applyValueCSSPropertyFloodOpacity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetFloodOpacity(StyleBuilderConverter::ConvertNumberOrPercentage(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridAutoColumns(StyleResolverState& state) {
  state.Style()->SetGridAutoColumns(ComputedStyle::InitialGridAutoColumns());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridAutoColumns(StyleResolverState& state) {
  state.Style()->SetGridAutoColumns(state.ParentStyle()->GridAutoColumns());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridAutoColumns(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridAutoColumns(StyleBuilderConverter::ConvertGridTrackSizeList(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridAutoRows(StyleResolverState& state) {
  state.Style()->SetGridAutoRows(ComputedStyle::InitialGridAutoRows());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridAutoRows(StyleResolverState& state) {
  state.Style()->SetGridAutoRows(state.ParentStyle()->GridAutoRows());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridAutoRows(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridAutoRows(StyleBuilderConverter::ConvertGridTrackSizeList(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnEnd(StyleResolverState& state) {
  state.Style()->SetGridColumnEnd(ComputedStyle::InitialGridColumnEnd());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnEnd(StyleResolverState& state) {
  state.Style()->SetGridColumnEnd(state.ParentStyle()->GridColumnEnd());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridColumnEnd(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridColumnEnd(StyleBuilderConverter::ConvertGridPosition(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnGap(StyleResolverState& state) {
  state.Style()->SetGridColumnGap(ComputedStyle::InitialGridColumnGap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnGap(StyleResolverState& state) {
  state.Style()->SetGridColumnGap(state.ParentStyle()->GridColumnGap());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridColumnGap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridColumnGap(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnStart(StyleResolverState& state) {
  state.Style()->SetGridColumnStart(ComputedStyle::InitialGridColumnStart());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnStart(StyleResolverState& state) {
  state.Style()->SetGridColumnStart(state.ParentStyle()->GridColumnStart());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridColumnStart(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridColumnStart(StyleBuilderConverter::ConvertGridPosition(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowEnd(StyleResolverState& state) {
  state.Style()->SetGridRowEnd(ComputedStyle::InitialGridRowEnd());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowEnd(StyleResolverState& state) {
  state.Style()->SetGridRowEnd(state.ParentStyle()->GridRowEnd());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridRowEnd(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridRowEnd(StyleBuilderConverter::ConvertGridPosition(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowGap(StyleResolverState& state) {
  state.Style()->SetGridRowGap(ComputedStyle::InitialGridRowGap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowGap(StyleResolverState& state) {
  state.Style()->SetGridRowGap(state.ParentStyle()->GridRowGap());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridRowGap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridRowGap(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowStart(StyleResolverState& state) {
  state.Style()->SetGridRowStart(ComputedStyle::InitialGridRowStart());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowStart(StyleResolverState& state) {
  state.Style()->SetGridRowStart(state.ParentStyle()->GridRowStart());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridRowStart(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridRowStart(StyleBuilderConverter::ConvertGridPosition(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyHeight(StyleResolverState& state) {
  state.Style()->SetHeight(ComputedStyle::InitialHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyHeight(StyleResolverState& state) {
  state.Style()->SetHeight(state.ParentStyle()->Height());
}

void StyleBuilderFunctions::applyValueCSSPropertyHeight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetHeight(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyImageRendering(StyleResolverState& state) {
  state.Style()->SetImageRendering(ComputedStyle::InitialImageRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyImageRendering(StyleResolverState& state) {
  state.Style()->SetImageRendering(state.ParentStyle()->ImageRendering());
}

void StyleBuilderFunctions::applyValueCSSPropertyImageRendering(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetImageRendering(ToCSSIdentifierValue(value).ConvertTo<EImageRendering>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyIsolation(StyleResolverState& state) {
  state.Style()->SetIsolation(ComputedStyle::InitialIsolation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyIsolation(StyleResolverState& state) {
  state.Style()->SetIsolation(state.ParentStyle()->Isolation());
}

void StyleBuilderFunctions::applyValueCSSPropertyIsolation(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetIsolation(ToCSSIdentifierValue(value).ConvertTo<EIsolation>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyJustifyContent(StyleResolverState& state) {
  state.Style()->SetJustifyContent(ComputedStyle::InitialJustifyContent());
}

void StyleBuilderFunctions::applyInheritCSSPropertyJustifyContent(StyleResolverState& state) {
  state.Style()->SetJustifyContent(state.ParentStyle()->JustifyContent());
}

void StyleBuilderFunctions::applyValueCSSPropertyJustifyContent(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetJustifyContent(StyleBuilderConverter::ConvertContentAlignmentData(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyLeft(StyleResolverState& state) {
  state.Style()->SetLeft(ComputedStyle::InitialLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLeft(StyleResolverState& state) {
  state.Style()->SetLeft(state.ParentStyle()->Left());
}

void StyleBuilderFunctions::applyValueCSSPropertyLeft(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLeft(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyLetterSpacing(StyleResolverState& state) {
  state.Style()->SetLetterSpacing(ComputedStyle::InitialLetterSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLetterSpacing(StyleResolverState& state) {
  state.Style()->SetLetterSpacing(state.ParentStyle()->LetterSpacing());
}

void StyleBuilderFunctions::applyValueCSSPropertyLetterSpacing(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLetterSpacing(StyleBuilderConverter::ConvertSpacing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyLightingColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetLightingColor(SVGComputedStyle::InitialLightingColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLightingColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetLightingColor(state.ParentStyle()->SvgStyle().LightingColor());
}

void StyleBuilderFunctions::applyValueCSSPropertyLightingColor(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetLightingColor(StyleBuilderConverter::ConvertColor(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(ComputedStyle::InitialLineBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(state.ParentStyle()->GetLineBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyLineBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLineBreak(ToCSSIdentifierValue(value).ConvertTo<LineBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyListStyleImage(StyleResolverState& state) {
  state.Style()->SetListStyleImage(ComputedStyle::InitialListStyleImage());
}

void StyleBuilderFunctions::applyInheritCSSPropertyListStyleImage(StyleResolverState& state) {
  state.Style()->SetListStyleImage(state.ParentStyle()->ListStyleImage());
}

void StyleBuilderFunctions::applyInitialCSSPropertyListStylePosition(StyleResolverState& state) {
  state.Style()->SetListStylePosition(ComputedStyle::InitialListStylePosition());
  state.Style()->SetListStylePositionIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyListStylePosition(StyleResolverState& state) {
  state.Style()->SetListStylePosition(state.ParentStyle()->ListStylePosition());
  state.Style()->SetListStylePositionIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyListStylePosition(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetListStylePosition(ToCSSIdentifierValue(value).ConvertTo<EListStylePosition>());

state.Style()->SetListStylePositionIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyListStyleType(StyleResolverState& state) {
  state.Style()->SetListStyleType(ComputedStyle::InitialListStyleType());
}

void StyleBuilderFunctions::applyInheritCSSPropertyListStyleType(StyleResolverState& state) {
  state.Style()->SetListStyleType(state.ParentStyle()->ListStyleType());
}

void StyleBuilderFunctions::applyValueCSSPropertyListStyleType(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetListStyleType(ToCSSIdentifierValue(value).ConvertTo<EListStyleType>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerEnd(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerEndResource(SVGComputedStyle::InitialMarkerEndResource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMarkerEnd(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerEndResource(state.ParentStyle()->SvgStyle().MarkerEndResource());
}

void StyleBuilderFunctions::applyValueCSSPropertyMarkerEnd(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetMarkerEndResource(StyleBuilderConverter::ConvertFragmentIdentifier(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerMid(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerMidResource(SVGComputedStyle::InitialMarkerMidResource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMarkerMid(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerMidResource(state.ParentStyle()->SvgStyle().MarkerMidResource());
}

void StyleBuilderFunctions::applyValueCSSPropertyMarkerMid(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetMarkerMidResource(StyleBuilderConverter::ConvertFragmentIdentifier(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerStart(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerStartResource(SVGComputedStyle::InitialMarkerStartResource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMarkerStart(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerStartResource(state.ParentStyle()->SvgStyle().MarkerStartResource());
}

void StyleBuilderFunctions::applyValueCSSPropertyMarkerStart(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetMarkerStartResource(StyleBuilderConverter::ConvertFragmentIdentifier(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaskType(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMaskType(SVGComputedStyle::InitialMaskType());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaskType(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMaskType(state.ParentStyle()->SvgStyle().MaskType());
}

void StyleBuilderFunctions::applyValueCSSPropertyMaskType(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetMaskType(ToCSSIdentifierValue(value).ConvertTo<EMaskType>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyMaxHeight(StyleResolverState& state) {
  state.Style()->SetMaxHeight(ComputedStyle::InitialMaxHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaxHeight(StyleResolverState& state) {
  state.Style()->SetMaxHeight(state.ParentStyle()->MaxHeight());
}

void StyleBuilderFunctions::applyValueCSSPropertyMaxHeight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMaxHeight(StyleBuilderConverter::ConvertLengthMaxSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaxWidth(StyleResolverState& state) {
  state.Style()->SetMaxWidth(ComputedStyle::InitialMaxWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaxWidth(StyleResolverState& state) {
  state.Style()->SetMaxWidth(state.ParentStyle()->MaxWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyMaxWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMaxWidth(StyleBuilderConverter::ConvertLengthMaxSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMinHeight(StyleResolverState& state) {
  state.Style()->SetMinHeight(ComputedStyle::InitialMinHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMinHeight(StyleResolverState& state) {
  state.Style()->SetMinHeight(state.ParentStyle()->MinHeight());
}

void StyleBuilderFunctions::applyValueCSSPropertyMinHeight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMinHeight(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMinWidth(StyleResolverState& state) {
  state.Style()->SetMinWidth(ComputedStyle::InitialMinWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMinWidth(StyleResolverState& state) {
  state.Style()->SetMinWidth(state.ParentStyle()->MinWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyMinWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMinWidth(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMixBlendMode(StyleResolverState& state) {
  state.Style()->SetBlendMode(ComputedStyle::InitialBlendMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMixBlendMode(StyleResolverState& state) {
  state.Style()->SetBlendMode(state.ParentStyle()->BlendMode());
}

void StyleBuilderFunctions::applyValueCSSPropertyMixBlendMode(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBlendMode(ToCSSIdentifierValue(value).ConvertTo<WebBlendMode>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyObjectFit(StyleResolverState& state) {
  state.Style()->SetObjectFit(ComputedStyle::InitialObjectFit());
}

void StyleBuilderFunctions::applyInheritCSSPropertyObjectFit(StyleResolverState& state) {
  state.Style()->SetObjectFit(state.ParentStyle()->GetObjectFit());
}

void StyleBuilderFunctions::applyValueCSSPropertyObjectFit(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetObjectFit(ToCSSIdentifierValue(value).ConvertTo<EObjectFit>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOpacity(StyleResolverState& state) {
  state.Style()->SetOpacity(ComputedStyle::InitialOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOpacity(StyleResolverState& state) {
  state.Style()->SetOpacity(state.ParentStyle()->Opacity());
}

void StyleBuilderFunctions::applyValueCSSPropertyOpacity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOpacity(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyOrphans(StyleResolverState& state) {
  state.Style()->SetOrphans(ComputedStyle::InitialOrphans());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOrphans(StyleResolverState& state) {
  state.Style()->SetOrphans(state.ParentStyle()->Orphans());
}

void StyleBuilderFunctions::applyValueCSSPropertyOrphans(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOrphans(ToCSSPrimitiveValue(value).ConvertTo<short>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(ComputedStyle::InitialOverflowWrap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(state.ParentStyle()->OverflowWrap());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverflowWrap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowWrap(ToCSSIdentifierValue(value).ConvertTo<EOverflowWrap>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowX(StyleResolverState& state) {
  state.Style()->SetOverflowX(ComputedStyle::InitialOverflowX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowX(StyleResolverState& state) {
  state.Style()->SetOverflowX(state.ParentStyle()->OverflowX());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverflowX(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowX(ToCSSIdentifierValue(value).ConvertTo<EOverflow>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowY(StyleResolverState& state) {
  state.Style()->SetOverflowY(ComputedStyle::InitialOverflowY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowY(StyleResolverState& state) {
  state.Style()->SetOverflowY(state.ParentStyle()->OverflowY());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverflowY(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowY(ToCSSIdentifierValue(value).ConvertTo<EOverflow>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverscrollBehaviorX(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorX(ComputedStyle::InitialOverscrollBehaviorX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverscrollBehaviorX(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorX(state.ParentStyle()->OverscrollBehaviorX());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverscrollBehaviorX(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverscrollBehaviorX(ToCSSIdentifierValue(value).ConvertTo<EScrollBoundaryBehavior>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverscrollBehaviorY(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorY(ComputedStyle::InitialOverscrollBehaviorY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverscrollBehaviorY(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorY(state.ParentStyle()->OverscrollBehaviorY());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverscrollBehaviorY(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverscrollBehaviorY(ToCSSIdentifierValue(value).ConvertTo<EScrollBoundaryBehavior>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyPointerEvents(StyleResolverState& state) {
  state.Style()->SetPointerEvents(ComputedStyle::InitialPointerEvents());
  state.Style()->SetPointerEventsIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyPointerEvents(StyleResolverState& state) {
  state.Style()->SetPointerEvents(state.ParentStyle()->PointerEvents());
  state.Style()->SetPointerEventsIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyPointerEvents(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetPointerEvents(ToCSSIdentifierValue(value).ConvertTo<EPointerEvents>());

state.Style()->SetPointerEventsIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyPosition(StyleResolverState& state) {
  state.Style()->SetPosition(ComputedStyle::InitialPosition());
}

void StyleBuilderFunctions::applyValueCSSPropertyPosition(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetPosition(ToCSSIdentifierValue(value).ConvertTo<EPosition>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyR(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetR(SVGComputedStyle::InitialR());
}

void StyleBuilderFunctions::applyInheritCSSPropertyR(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetR(state.ParentStyle()->SvgStyle().R());
}

void StyleBuilderFunctions::applyValueCSSPropertyR(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetR(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyResize(StyleResolverState& state) {
  state.Style()->SetResize(ComputedStyle::InitialResize());
}

void StyleBuilderFunctions::applyInheritCSSPropertyResize(StyleResolverState& state) {
  state.Style()->SetResize(state.ParentStyle()->Resize());
}

void StyleBuilderFunctions::applyInitialCSSPropertyRight(StyleResolverState& state) {
  state.Style()->SetRight(ComputedStyle::InitialRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRight(StyleResolverState& state) {
  state.Style()->SetRight(state.ParentStyle()->Right());
}

void StyleBuilderFunctions::applyValueCSSPropertyRight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetRight(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyRx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRx(SVGComputedStyle::InitialRx());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRx(state.ParentStyle()->SvgStyle().Rx());
}

void StyleBuilderFunctions::applyValueCSSPropertyRx(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetRx(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyRy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRy(SVGComputedStyle::InitialRy());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRy(state.ParentStyle()->SvgStyle().Ry());
}

void StyleBuilderFunctions::applyValueCSSPropertyRy(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetRy(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingBottom(StyleResolverState& state) {
  state.Style()->SetScrollPaddingBottom(ComputedStyle::InitialScrollPaddingBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingBottom(StyleResolverState& state) {
  state.Style()->SetScrollPaddingBottom(state.ParentStyle()->ScrollPaddingBottom());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollPaddingBottom(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollPaddingBottom(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingLeft(StyleResolverState& state) {
  state.Style()->SetScrollPaddingLeft(ComputedStyle::InitialScrollPaddingLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingLeft(StyleResolverState& state) {
  state.Style()->SetScrollPaddingLeft(state.ParentStyle()->ScrollPaddingLeft());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollPaddingLeft(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollPaddingLeft(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingRight(StyleResolverState& state) {
  state.Style()->SetScrollPaddingRight(ComputedStyle::InitialScrollPaddingRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingRight(StyleResolverState& state) {
  state.Style()->SetScrollPaddingRight(state.ParentStyle()->ScrollPaddingRight());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollPaddingRight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollPaddingRight(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingTop(StyleResolverState& state) {
  state.Style()->SetScrollPaddingTop(ComputedStyle::InitialScrollPaddingTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingTop(StyleResolverState& state) {
  state.Style()->SetScrollPaddingTop(state.ParentStyle()->ScrollPaddingTop());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollPaddingTop(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollPaddingTop(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginBottom(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginBottom(ComputedStyle::InitialScrollSnapMarginBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginBottom(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginBottom(state.ParentStyle()->ScrollSnapMarginBottom());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollSnapMarginBottom(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollSnapMarginBottom(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginLeft(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginLeft(ComputedStyle::InitialScrollSnapMarginLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginLeft(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginLeft(state.ParentStyle()->ScrollSnapMarginLeft());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollSnapMarginLeft(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollSnapMarginLeft(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginRight(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginRight(ComputedStyle::InitialScrollSnapMarginRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginRight(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginRight(state.ParentStyle()->ScrollSnapMarginRight());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollSnapMarginRight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollSnapMarginRight(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginTop(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginTop(ComputedStyle::InitialScrollSnapMarginTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginTop(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginTop(state.ParentStyle()->ScrollSnapMarginTop());
}

void StyleBuilderFunctions::applyValueCSSPropertyScrollSnapMarginTop(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetScrollSnapMarginTop(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyShapeRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetShapeRendering(SVGComputedStyle::InitialShapeRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyShapeRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetShapeRendering(state.ParentStyle()->SvgStyle().ShapeRendering());
}

void StyleBuilderFunctions::applyValueCSSPropertyShapeRendering(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetShapeRendering(ToCSSIdentifierValue(value).ConvertTo<EShapeRendering>());

}

void StyleBuilderFunctions::applyInitialCSSPropertySpeak(StyleResolverState& state) {
  state.Style()->SetSpeak(ComputedStyle::InitialSpeak());
}

void StyleBuilderFunctions::applyInheritCSSPropertySpeak(StyleResolverState& state) {
  state.Style()->SetSpeak(state.ParentStyle()->Speak());
}

void StyleBuilderFunctions::applyValueCSSPropertySpeak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetSpeak(ToCSSIdentifierValue(value).ConvertTo<ESpeak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyStopColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopColor(SVGComputedStyle::InitialStopColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStopColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopColor(state.ParentStyle()->SvgStyle().StopColor());
}

void StyleBuilderFunctions::applyValueCSSPropertyStopColor(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetStopColor(StyleBuilderConverter::ConvertColor(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyStopOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopOpacity(SVGComputedStyle::InitialStopOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStopOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopOpacity(state.ParentStyle()->SvgStyle().StopOpacity());
}

void StyleBuilderFunctions::applyValueCSSPropertyStopOpacity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetStopOpacity(StyleBuilderConverter::ConvertNumberOrPercentage(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeDashoffset(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeDashOffset(SVGComputedStyle::InitialStrokeDashOffset());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeDashoffset(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeDashOffset(state.ParentStyle()->SvgStyle().StrokeDashOffset());
}

void StyleBuilderFunctions::applyValueCSSPropertyStrokeDashoffset(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetStrokeDashOffset(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeLinecap(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCapStyle(SVGComputedStyle::InitialCapStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeLinecap(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCapStyle(state.ParentStyle()->SvgStyle().CapStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyStrokeLinecap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetCapStyle(ToCSSIdentifierValue(value).ConvertTo<LineCap>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeLinejoin(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetJoinStyle(SVGComputedStyle::InitialJoinStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeLinejoin(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetJoinStyle(state.ParentStyle()->SvgStyle().JoinStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyStrokeLinejoin(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetJoinStyle(ToCSSIdentifierValue(value).ConvertTo<LineJoin>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeOpacity(SVGComputedStyle::InitialStrokeOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeOpacity(state.ParentStyle()->SvgStyle().StrokeOpacity());
}

void StyleBuilderFunctions::applyValueCSSPropertyStrokeOpacity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetStrokeOpacity(StyleBuilderConverter::ConvertNumberOrPercentage(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeWidth(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeWidth(SVGComputedStyle::InitialStrokeWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeWidth(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeWidth(state.ParentStyle()->SvgStyle().StrokeWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyStrokeWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetStrokeWidth(StyleBuilderConverter::ConvertUnzoomedLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTableLayout(StyleResolverState& state) {
  state.Style()->SetTableLayout(ComputedStyle::InitialTableLayout());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTableLayout(StyleResolverState& state) {
  state.Style()->SetTableLayout(state.ParentStyle()->TableLayout());
}

void StyleBuilderFunctions::applyValueCSSPropertyTableLayout(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTableLayout(ToCSSIdentifierValue(value).ConvertTo<ETableLayout>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAlign(StyleResolverState& state) {
  state.Style()->SetTextAlign(ComputedStyle::InitialTextAlign());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAlign(StyleResolverState& state) {
  state.Style()->SetTextAlign(state.ParentStyle()->GetTextAlign());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAlignLast(StyleResolverState& state) {
  state.Style()->SetTextAlignLast(ComputedStyle::InitialTextAlignLast());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAlignLast(StyleResolverState& state) {
  state.Style()->SetTextAlignLast(state.ParentStyle()->TextAlignLast());
}

void StyleBuilderFunctions::applyValueCSSPropertyTextAlignLast(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTextAlignLast(ToCSSIdentifierValue(value).ConvertTo<ETextAlignLast>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAnchor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetTextAnchor(SVGComputedStyle::InitialTextAnchor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAnchor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetTextAnchor(state.ParentStyle()->SvgStyle().TextAnchor());
}

void StyleBuilderFunctions::applyValueCSSPropertyTextAnchor(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetTextAnchor(ToCSSIdentifierValue(value).ConvertTo<ETextAnchor>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextCombineUpright(StyleResolverState& state) {
  state.Style()->SetTextCombine(ComputedStyle::InitialTextCombine());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextCombineUpright(StyleResolverState& state) {
  state.Style()->SetTextCombine(state.ParentStyle()->TextCombine());
}

void StyleBuilderFunctions::applyValueCSSPropertyTextCombineUpright(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTextCombine(ToCSSIdentifierValue(value).ConvertTo<ETextCombine>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOverflow(StyleResolverState& state) {
  state.Style()->SetTextOverflow(ComputedStyle::InitialTextOverflow());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOverflow(StyleResolverState& state) {
  state.Style()->SetTextOverflow(state.ParentStyle()->TextOverflow());
}

void StyleBuilderFunctions::applyValueCSSPropertyTextOverflow(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTextOverflow(ToCSSIdentifierValue(value).ConvertTo<ETextOverflow>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextTransform(StyleResolverState& state) {
  state.Style()->SetTextTransform(ComputedStyle::InitialTextTransform());
  state.Style()->SetTextTransformIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextTransform(StyleResolverState& state) {
  state.Style()->SetTextTransform(state.ParentStyle()->TextTransform());
  state.Style()->SetTextTransformIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyTextTransform(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTextTransform(ToCSSIdentifierValue(value).ConvertTo<ETextTransform>());

state.Style()->SetTextTransformIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyTop(StyleResolverState& state) {
  state.Style()->SetTop(ComputedStyle::InitialTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTop(StyleResolverState& state) {
  state.Style()->SetTop(state.ParentStyle()->Top());
}

void StyleBuilderFunctions::applyValueCSSPropertyTop(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTop(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTransformStyle(StyleResolverState& state) {
  state.Style()->SetTransformStyle3D(ComputedStyle::InitialTransformStyle3D());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTransformStyle(StyleResolverState& state) {
  state.Style()->SetTransformStyle3D(state.ParentStyle()->TransformStyle3D());
}

void StyleBuilderFunctions::applyValueCSSPropertyTransformStyle(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTransformStyle3D(ToCSSIdentifierValue(value).ConvertTo<ETransformStyle3D>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyUserSelect(StyleResolverState& state) {
  state.Style()->SetUserSelect(ComputedStyle::InitialUserSelect());
}

void StyleBuilderFunctions::applyInheritCSSPropertyUserSelect(StyleResolverState& state) {
  state.Style()->SetUserSelect(state.ParentStyle()->UserSelect());
}

void StyleBuilderFunctions::applyValueCSSPropertyUserSelect(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetUserSelect(ToCSSIdentifierValue(value).ConvertTo<EUserSelect>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyVectorEffect(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetVectorEffect(SVGComputedStyle::InitialVectorEffect());
}

void StyleBuilderFunctions::applyInheritCSSPropertyVectorEffect(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetVectorEffect(state.ParentStyle()->SvgStyle().VectorEffect());
}

void StyleBuilderFunctions::applyValueCSSPropertyVectorEffect(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetVectorEffect(ToCSSIdentifierValue(value).ConvertTo<EVectorEffect>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyVerticalAlign(StyleResolverState& state) {
  state.Style()->SetVerticalAlign(ComputedStyle::InitialVerticalAlign());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAppearance(StyleResolverState& state) {
  state.Style()->SetAppearance(ComputedStyle::InitialAppearance());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAppearance(StyleResolverState& state) {
  state.Style()->SetAppearance(state.ParentStyle()->Appearance());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitAppearance(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetAppearance(ToCSSIdentifierValue(value).ConvertTo<ControlPart>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBorderHorizontalSpacing(StyleResolverState& state) {
  state.Style()->SetHorizontalBorderSpacing(ComputedStyle::InitialHorizontalBorderSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBorderHorizontalSpacing(StyleResolverState& state) {
  state.Style()->SetHorizontalBorderSpacing(state.ParentStyle()->HorizontalBorderSpacing());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBorderHorizontalSpacing(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetHorizontalBorderSpacing(StyleBuilderConverter::ConvertComputedLength<short>(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBorderImage(StyleResolverState& state) {
  state.Style()->SetBorderImage(ComputedStyle::InitialBorderImage());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBorderImage(StyleResolverState& state) {
  state.Style()->SetBorderImage(state.ParentStyle()->BorderImage());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBorderVerticalSpacing(StyleResolverState& state) {
  state.Style()->SetVerticalBorderSpacing(ComputedStyle::InitialVerticalBorderSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBorderVerticalSpacing(StyleResolverState& state) {
  state.Style()->SetVerticalBorderSpacing(state.ParentStyle()->VerticalBorderSpacing());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBorderVerticalSpacing(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetVerticalBorderSpacing(StyleBuilderConverter::ConvertComputedLength<short>(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxAlign(StyleResolverState& state) {
  state.Style()->SetBoxAlign(ComputedStyle::InitialBoxAlign());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxAlign(StyleResolverState& state) {
  state.Style()->SetBoxAlign(state.ParentStyle()->BoxAlign());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxAlign(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxAlign(ToCSSIdentifierValue(value).ConvertTo<EBoxAlignment>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxDecorationBreak(StyleResolverState& state) {
  state.Style()->SetBoxDecorationBreak(ComputedStyle::InitialBoxDecorationBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxDecorationBreak(StyleResolverState& state) {
  state.Style()->SetBoxDecorationBreak(state.ParentStyle()->BoxDecorationBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxDecorationBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxDecorationBreak(ToCSSIdentifierValue(value).ConvertTo<EBoxDecorationBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxDirection(StyleResolverState& state) {
  state.Style()->SetBoxDirection(ComputedStyle::InitialBoxDirection());
  state.Style()->SetBoxDirectionIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxDirection(StyleResolverState& state) {
  state.Style()->SetBoxDirection(state.ParentStyle()->BoxDirection());
  state.Style()->SetBoxDirectionIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxDirection(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxDirection(ToCSSIdentifierValue(value).ConvertTo<EBoxDirection>());

state.Style()->SetBoxDirectionIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxLines(StyleResolverState& state) {
  state.Style()->SetBoxLines(ComputedStyle::InitialBoxLines());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxLines(StyleResolverState& state) {
  state.Style()->SetBoxLines(state.ParentStyle()->BoxLines());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxLines(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxLines(ToCSSIdentifierValue(value).ConvertTo<EBoxLines>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxOrient(StyleResolverState& state) {
  state.Style()->SetBoxOrient(ComputedStyle::InitialBoxOrient());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxOrient(StyleResolverState& state) {
  state.Style()->SetBoxOrient(state.ParentStyle()->BoxOrient());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxOrient(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxOrient(ToCSSIdentifierValue(value).ConvertTo<EBoxOrient>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxPack(StyleResolverState& state) {
  state.Style()->SetBoxPack(ComputedStyle::InitialBoxPack());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxPack(StyleResolverState& state) {
  state.Style()->SetBoxPack(state.ParentStyle()->BoxPack());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxPack(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxPack(ToCSSIdentifierValue(value).ConvertTo<EBoxPack>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitHyphenateCharacter(StyleResolverState& state) {
  state.Style()->SetHyphenationString(ComputedStyle::InitialHyphenationString());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitHyphenateCharacter(StyleResolverState& state) {
  state.Style()->SetHyphenationString(state.ParentStyle()->HyphenationString());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitHyphenateCharacter(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetHyphenationString(StyleBuilderConverter::ConvertString<CSSValueAuto>(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(ComputedStyle::InitialLineBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(state.ParentStyle()->GetLineBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitLineBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLineBreak(ToCSSIdentifierValue(value).ConvertTo<LineBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginAfterCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(ComputedStyle::InitialMarginAfterCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginAfterCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(state.ParentStyle()->MarginAfterCollapse());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarginAfterCollapse(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMarginAfterCollapse(ToCSSIdentifierValue(value).ConvertTo<EMarginCollapse>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginBeforeCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(ComputedStyle::InitialMarginBeforeCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginBeforeCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(state.ParentStyle()->MarginBeforeCollapse());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarginBeforeCollapse(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMarginBeforeCollapse(ToCSSIdentifierValue(value).ConvertTo<EMarginCollapse>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginBottomCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(ComputedStyle::InitialMarginAfterCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginBottomCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(state.ParentStyle()->MarginAfterCollapse());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarginBottomCollapse(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMarginAfterCollapse(ToCSSIdentifierValue(value).ConvertTo<EMarginCollapse>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginTopCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(ComputedStyle::InitialMarginBeforeCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginTopCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(state.ParentStyle()->MarginBeforeCollapse());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarginTopCollapse(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMarginBeforeCollapse(ToCSSIdentifierValue(value).ConvertTo<EMarginCollapse>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskBoxImageSource(StyleResolverState& state) {
  state.Style()->SetMaskBoxImageSource(ComputedStyle::InitialMaskBoxImageSource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskBoxImageSource(StyleResolverState& state) {
  state.Style()->SetMaskBoxImageSource(state.ParentStyle()->MaskBoxImageSource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOriginX(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginX(ComputedStyle::InitialPerspectiveOriginX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOriginX(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginX(state.ParentStyle()->PerspectiveOriginX());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitPerspectiveOriginX(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetPerspectiveOriginX(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOriginY(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginY(ComputedStyle::InitialPerspectiveOriginY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOriginY(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginY(state.ParentStyle()->PerspectiveOriginY());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitPerspectiveOriginY(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetPerspectiveOriginY(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPrintColorAdjust(StyleResolverState& state) {
  state.Style()->SetPrintColorAdjust(ComputedStyle::InitialPrintColorAdjust());
  state.Style()->SetPrintColorAdjustIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPrintColorAdjust(StyleResolverState& state) {
  state.Style()->SetPrintColorAdjust(state.ParentStyle()->PrintColorAdjust());
  state.Style()->SetPrintColorAdjustIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitPrintColorAdjust(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetPrintColorAdjust(ToCSSIdentifierValue(value).ConvertTo<EPrintColorAdjust>());

state.Style()->SetPrintColorAdjustIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitRtlOrdering(StyleResolverState& state) {
  state.Style()->SetRtlOrdering(ComputedStyle::InitialRtlOrdering());
  state.Style()->SetRtlOrderingIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitRtlOrdering(StyleResolverState& state) {
  state.Style()->SetRtlOrdering(state.ParentStyle()->RtlOrdering());
  state.Style()->SetRtlOrderingIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitRtlOrdering(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetRtlOrdering(ToCSSIdentifierValue(value).ConvertTo<EOrder>());

state.Style()->SetRtlOrderingIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitRubyPosition(StyleResolverState& state) {
  state.Style()->SetRubyPosition(ComputedStyle::InitialRubyPosition());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitRubyPosition(StyleResolverState& state) {
  state.Style()->SetRubyPosition(state.ParentStyle()->GetRubyPosition());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitRubyPosition(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetRubyPosition(ToCSSIdentifierValue(value).ConvertTo<RubyPosition>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTapHighlightColor(StyleResolverState& state) {
  state.Style()->SetTapHighlightColor(ComputedStyle::InitialTapHighlightColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTapHighlightColor(StyleResolverState& state) {
  state.Style()->SetTapHighlightColor(state.ParentStyle()->TapHighlightColor());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTapHighlightColor(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTapHighlightColor(StyleBuilderConverter::ConvertColor(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextCombine(StyleResolverState& state) {
  state.Style()->SetTextCombine(ComputedStyle::InitialTextCombine());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextCombine(StyleResolverState& state) {
  state.Style()->SetTextCombine(state.ParentStyle()->TextCombine());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextCombine(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTextCombine(ToCSSIdentifierValue(value).ConvertTo<ETextCombine>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextSecurity(StyleResolverState& state) {
  state.Style()->SetTextSecurity(ComputedStyle::InitialTextSecurity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextSecurity(StyleResolverState& state) {
  state.Style()->SetTextSecurity(state.ParentStyle()->TextSecurity());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextSecurity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTextSecurity(ToCSSIdentifierValue(value).ConvertTo<ETextSecurity>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTransformOriginX(StyleResolverState& state) {
  state.Style()->SetTransformOriginX(ComputedStyle::InitialTransformOriginX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTransformOriginX(StyleResolverState& state) {
  state.Style()->SetTransformOriginX(state.ParentStyle()->TransformOriginX());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTransformOriginX(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTransformOriginX(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTransformOriginY(StyleResolverState& state) {
  state.Style()->SetTransformOriginY(ComputedStyle::InitialTransformOriginY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTransformOriginY(StyleResolverState& state) {
  state.Style()->SetTransformOriginY(state.ParentStyle()->TransformOriginY());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTransformOriginY(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTransformOriginY(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitUserDrag(StyleResolverState& state) {
  state.Style()->SetUserDrag(ComputedStyle::InitialUserDrag());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitUserDrag(StyleResolverState& state) {
  state.Style()->SetUserDrag(state.ParentStyle()->UserDrag());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitUserDrag(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetUserDrag(ToCSSIdentifierValue(value).ConvertTo<EUserDrag>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitUserModify(StyleResolverState& state) {
  state.Style()->SetUserModify(ComputedStyle::InitialUserModify());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitUserModify(StyleResolverState& state) {
  state.Style()->SetUserModify(state.ParentStyle()->UserModify());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitUserModify(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetUserModify(ToCSSIdentifierValue(value).ConvertTo<EUserModify>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWhiteSpace(StyleResolverState& state) {
  state.Style()->SetWhiteSpace(ComputedStyle::InitialWhiteSpace());
  state.Style()->SetWhiteSpaceIsInherited
(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWhiteSpace(StyleResolverState& state) {
  state.Style()->SetWhiteSpace(state.ParentStyle()->WhiteSpace());
  state.Style()->SetWhiteSpaceIsInherited
(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyWhiteSpace(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWhiteSpace(ToCSSIdentifierValue(value).ConvertTo<EWhiteSpace>());

state.Style()->SetWhiteSpaceIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWidows(StyleResolverState& state) {
  state.Style()->SetWidows(ComputedStyle::InitialWidows());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWidows(StyleResolverState& state) {
  state.Style()->SetWidows(state.ParentStyle()->Widows());
}

void StyleBuilderFunctions::applyValueCSSPropertyWidows(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWidows(ToCSSPrimitiveValue(value).ConvertTo<short>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWidth(StyleResolverState& state) {
  state.Style()->SetWidth(ComputedStyle::InitialWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWidth(StyleResolverState& state) {
  state.Style()->SetWidth(state.ParentStyle()->Width());
}

void StyleBuilderFunctions::applyValueCSSPropertyWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWidth(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWordBreak(StyleResolverState& state) {
  state.Style()->SetWordBreak(ComputedStyle::InitialWordBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWordBreak(StyleResolverState& state) {
  state.Style()->SetWordBreak(state.ParentStyle()->WordBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyWordBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWordBreak(ToCSSIdentifierValue(value).ConvertTo<EWordBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWordSpacing(StyleResolverState& state) {
  state.Style()->SetWordSpacing(ComputedStyle::InitialWordSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWordSpacing(StyleResolverState& state) {
  state.Style()->SetWordSpacing(state.ParentStyle()->WordSpacing());
}

void StyleBuilderFunctions::applyValueCSSPropertyWordSpacing(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWordSpacing(StyleBuilderConverter::ConvertSpacing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWordWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(ComputedStyle::InitialOverflowWrap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWordWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(state.ParentStyle()->OverflowWrap());
}

void StyleBuilderFunctions::applyValueCSSPropertyWordWrap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowWrap(ToCSSIdentifierValue(value).ConvertTo<EOverflowWrap>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyX(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetX(SVGComputedStyle::InitialX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyX(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetX(state.ParentStyle()->SvgStyle().X());
}

void StyleBuilderFunctions::applyValueCSSPropertyX(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetX(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyY(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetY(SVGComputedStyle::InitialY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyY(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetY(state.ParentStyle()->SvgStyle().Y());
}

void StyleBuilderFunctions::applyValueCSSPropertyY(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetY(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationDelay(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.DelayList().clear();
  data.DelayList().push_back(CSSAnimationData::InitialDelay());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationDelay(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationDelay(state);
  else
    state.Style()->AccessAnimations().DelayList() = parentData->DelayList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationDelay(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.DelayList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.DelayList().push_back(CSSToStyleMap::MapAnimationDelay(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationDirection(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.DirectionList().clear();
  data.DirectionList().push_back(CSSAnimationData::InitialDirection());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationDirection(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationDirection(state);
  else
    state.Style()->AccessAnimations().DirectionList() = parentData->DirectionList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationDirection(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.DirectionList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.DirectionList().push_back(CSSToStyleMap::MapAnimationDirection(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationDuration(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.DurationList().clear();
  data.DurationList().push_back(CSSAnimationData::InitialDuration());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationDuration(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationDuration(state);
  else
    state.Style()->AccessAnimations().DurationList() = parentData->DurationList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationDuration(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.DurationList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.DurationList().push_back(CSSToStyleMap::MapAnimationDuration(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationFillMode(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.FillModeList().clear();
  data.FillModeList().push_back(CSSAnimationData::InitialFillMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationFillMode(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationFillMode(state);
  else
    state.Style()->AccessAnimations().FillModeList() = parentData->FillModeList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationFillMode(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.FillModeList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.FillModeList().push_back(CSSToStyleMap::MapAnimationFillMode(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationIterationCount(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.IterationCountList().clear();
  data.IterationCountList().push_back(CSSAnimationData::InitialIterationCount());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationIterationCount(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationIterationCount(state);
  else
    state.Style()->AccessAnimations().IterationCountList() = parentData->IterationCountList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationIterationCount(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.IterationCountList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.IterationCountList().push_back(CSSToStyleMap::MapAnimationIterationCount(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationName(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.NameList().clear();
  data.NameList().push_back(CSSAnimationData::InitialName());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationName(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationName(state);
  else
    state.Style()->AccessAnimations().NameList() = parentData->NameList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationName(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.NameList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.NameList().push_back(CSSToStyleMap::MapAnimationName(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationPlayState(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.PlayStateList().clear();
  data.PlayStateList().push_back(CSSAnimationData::InitialPlayState());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationPlayState(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationPlayState(state);
  else
    state.Style()->AccessAnimations().PlayStateList() = parentData->PlayStateList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationPlayState(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.PlayStateList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.PlayStateList().push_back(CSSToStyleMap::MapAnimationPlayState(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyAnimationTimingFunction(StyleResolverState& state) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.TimingFunctionList().clear();
  data.TimingFunctionList().push_back(CSSAnimationData::InitialTimingFunction());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAnimationTimingFunction(StyleResolverState& state) {
  const CSSAnimationData* parentData = state.ParentStyle()->Animations();
  if (!parentData)
    applyInitialCSSPropertyAnimationTimingFunction(state);
  else
    state.Style()->AccessAnimations().TimingFunctionList() = parentData->TimingFunctionList();
}

void StyleBuilderFunctions::applyValueCSSPropertyAnimationTimingFunction(StyleResolverState& state, const CSSValue& value) {
  CSSAnimationData& data = state.Style()->AccessAnimations();
  data.TimingFunctionList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.TimingFunctionList().push_back(CSSToStyleMap::MapAnimationTimingFunction(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTransitionDelay(StyleResolverState& state) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.DelayList().clear();
  data.DelayList().push_back(CSSTransitionData::InitialDelay());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTransitionDelay(StyleResolverState& state) {
  const CSSTransitionData* parentData = state.ParentStyle()->Transitions();
  if (!parentData)
    applyInitialCSSPropertyTransitionDelay(state);
  else
    state.Style()->AccessTransitions().DelayList() = parentData->DelayList();
}

void StyleBuilderFunctions::applyValueCSSPropertyTransitionDelay(StyleResolverState& state, const CSSValue& value) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.DelayList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.DelayList().push_back(CSSToStyleMap::MapAnimationDelay(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTransitionDuration(StyleResolverState& state) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.DurationList().clear();
  data.DurationList().push_back(CSSTransitionData::InitialDuration());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTransitionDuration(StyleResolverState& state) {
  const CSSTransitionData* parentData = state.ParentStyle()->Transitions();
  if (!parentData)
    applyInitialCSSPropertyTransitionDuration(state);
  else
    state.Style()->AccessTransitions().DurationList() = parentData->DurationList();
}

void StyleBuilderFunctions::applyValueCSSPropertyTransitionDuration(StyleResolverState& state, const CSSValue& value) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.DurationList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.DurationList().push_back(CSSToStyleMap::MapAnimationDuration(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTransitionProperty(StyleResolverState& state) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.PropertyList().clear();
  data.PropertyList().push_back(CSSTransitionData::InitialProperty());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTransitionProperty(StyleResolverState& state) {
  const CSSTransitionData* parentData = state.ParentStyle()->Transitions();
  if (!parentData)
    applyInitialCSSPropertyTransitionProperty(state);
  else
    state.Style()->AccessTransitions().PropertyList() = parentData->PropertyList();
}

void StyleBuilderFunctions::applyValueCSSPropertyTransitionProperty(StyleResolverState& state, const CSSValue& value) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.PropertyList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.PropertyList().push_back(CSSToStyleMap::MapAnimationProperty(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTransitionTimingFunction(StyleResolverState& state) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.TimingFunctionList().clear();
  data.TimingFunctionList().push_back(CSSTransitionData::InitialTimingFunction());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTransitionTimingFunction(StyleResolverState& state) {
  const CSSTransitionData* parentData = state.ParentStyle()->Transitions();
  if (!parentData)
    applyInitialCSSPropertyTransitionTimingFunction(state);
  else
    state.Style()->AccessTransitions().TimingFunctionList() = parentData->TimingFunctionList();
}

void StyleBuilderFunctions::applyValueCSSPropertyTransitionTimingFunction(StyleResolverState& state, const CSSValue& value) {
  CSSTransitionData& data = state.Style()->AccessTransitions();
  data.TimingFunctionList().clear();
  for (auto& listValue : ToCSSValueList(value))
    data.TimingFunctionList().push_back(CSSToStyleMap::MapAnimationTimingFunction(*listValue));
}

void StyleBuilderFunctions::applyInitialCSSPropertyClip(StyleResolverState& state) {
  state.Style()->SetHasAutoClip();
}

void StyleBuilderFunctions::applyInheritCSSPropertyClip(StyleResolverState& state) {
  if (state.ParentStyle()->HasAutoClip())
    state.Style()->SetHasAutoClip();
  else
    state.Style()->SetClip(state.ParentStyle()->Clip());
}

void StyleBuilderFunctions::applyValueCSSPropertyClip(StyleResolverState& state, const CSSValue& value) {
  if (value.IsIdentifierValue() && ToCSSIdentifierValue(value).GetValueID() == CSSValueAuto)
    state.Style()->SetHasAutoClip();
  else
    state.Style()->SetClip(StyleBuilderConverter::ConvertClip(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnCount(StyleResolverState& state) {
  state.Style()->SetHasAutoColumnCount();
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnCount(StyleResolverState& state) {
  if (state.ParentStyle()->HasAutoColumnCount())
    state.Style()->SetHasAutoColumnCount();
  else
    state.Style()->SetColumnCount(state.ParentStyle()->ColumnCount());
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnCount(StyleResolverState& state, const CSSValue& value) {
  if (value.IsIdentifierValue() && ToCSSIdentifierValue(value).GetValueID() == CSSValueAuto)
    state.Style()->SetHasAutoColumnCount();
  else
    state.Style()->SetColumnCount(ToCSSPrimitiveValue(value).ConvertTo<unsigned short>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnGap(StyleResolverState& state) {
  state.Style()->SetHasNormalColumnGap();
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnGap(StyleResolverState& state) {
  if (state.ParentStyle()->HasNormalColumnGap())
    state.Style()->SetHasNormalColumnGap();
  else
    state.Style()->SetColumnGap(state.ParentStyle()->ColumnGap());
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnGap(StyleResolverState& state, const CSSValue& value) {
  if (value.IsIdentifierValue() && ToCSSIdentifierValue(value).GetValueID() == CSSValueNormal)
    state.Style()->SetHasNormalColumnGap();
  else
    state.Style()->SetColumnGap(StyleBuilderConverter::ConvertComputedLength<float>(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnWidth(StyleResolverState& state) {
  state.Style()->SetHasAutoColumnWidth();
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnWidth(StyleResolverState& state) {
  if (state.ParentStyle()->HasAutoColumnWidth())
    state.Style()->SetHasAutoColumnWidth();
  else
    state.Style()->SetColumnWidth(state.ParentStyle()->ColumnWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnWidth(StyleResolverState& state, const CSSValue& value) {
  if (value.IsIdentifierValue() && ToCSSIdentifierValue(value).GetValueID() == CSSValueAuto)
    state.Style()->SetHasAutoColumnWidth();
  else
    state.Style()->SetColumnWidth(StyleBuilderConverter::ConvertComputedLength<float>(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyZIndex(StyleResolverState& state) {
  state.Style()->SetHasAutoZIndex();
}

void StyleBuilderFunctions::applyInheritCSSPropertyZIndex(StyleResolverState& state) {
  if (state.ParentStyle()->HasAutoZIndex())
    state.Style()->SetHasAutoZIndex();
  else
    state.Style()->SetZIndex(state.ParentStyle()->ZIndex());
}

void StyleBuilderFunctions::applyValueCSSPropertyZIndex(StyleResolverState& state, const CSSValue& value) {
  if (value.IsIdentifierValue() && ToCSSIdentifierValue(value).GetValueID() == CSSValueAuto)
    state.Style()->SetHasAutoZIndex();
  else
    state.Style()->SetZIndex(ToCSSPrimitiveValue(value).ConvertTo<int>());
}

static bool lengthMatchesAllSides(const LengthBox& lengthBox,
                                  const Length& length) {
  return (lengthBox.Left() == length &&
      lengthBox.Right() == length &&
      lengthBox.Top() == length &&
      lengthBox.Bottom() == length);
}

static bool borderImageLengthMatchesAllSides(
    const BorderImageLengthBox& borderImageLengthBox,
    const BorderImageLength& borderImageLength) {
  return (borderImageLengthBox.Left() == borderImageLength &&
      borderImageLengthBox.Right() == borderImageLength &&
      borderImageLengthBox.Top() == borderImageLength &&
      borderImageLengthBox.Bottom() == borderImageLength);
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageOutset(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->BorderImage();
  if (borderImageLengthMatchesAllSides(currentImage.Outset(),
                                       BorderImageLength(Length(0, kFixed))))
    return;

NinePieceImage image(currentImage);
  image.SetOutset(Length(0, kFixed));
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageOutset(StyleResolverState& state) {
  NinePieceImage image(state.Style()->BorderImage());
  image.CopyOutsetFrom(state.ParentStyle()->BorderImage());
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderImageOutset(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->BorderImage());
  image.SetOutset(CSSToStyleMap::MapNinePieceImageQuad(state, value));
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageRepeat(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->BorderImage();
  if (currentImage.HorizontalRule() == kStretchImageRule &&
      currentImage.VerticalRule() == kStretchImageRule)
    return;

NinePieceImage image(currentImage);
  image.SetHorizontalRule(kStretchImageRule);
  image.SetVerticalRule(kStretchImageRule);
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageRepeat(StyleResolverState& state) {
  NinePieceImage image(state.Style()->BorderImage());
  image.CopyRepeatFrom(state.ParentStyle()->BorderImage());
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderImageRepeat(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->BorderImage());
  CSSToStyleMap::MapNinePieceImageRepeat(state, value, image);
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageSlice(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->BorderImage();
  if (currentImage.Fill() == false &&
      lengthMatchesAllSides(currentImage.ImageSlices(), Length(100, kPercent)))
    return;

NinePieceImage image(currentImage);
  image.SetImageSlices(LengthBox(Length(100, kPercent), Length(100, kPercent), Length(100, kPercent), Length(100, kPercent)));
  image.SetFill(false);
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageSlice(StyleResolverState& state) {
  NinePieceImage image(state.Style()->BorderImage());
  image.CopyImageSlicesFrom(state.ParentStyle()->BorderImage());
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderImageSlice(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->BorderImage());
  CSSToStyleMap::MapNinePieceImageSlice(state, value, image);
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageWidth(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->BorderImage();
  if (borderImageLengthMatchesAllSides(currentImage.BorderSlices(),
                                       BorderImageLength(1.0)))
    return;

NinePieceImage image(currentImage);
  image.SetBorderSlices(1.0);
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageWidth(StyleResolverState& state) {
  NinePieceImage image(state.Style()->BorderImage());
  image.CopyBorderSlicesFrom(state.ParentStyle()->BorderImage());
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderImageWidth(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->BorderImage());
  image.SetBorderSlices(CSSToStyleMap::MapNinePieceImageQuad(state, value));
  state.Style()->SetBorderImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskBoxImageOutset(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->MaskBoxImage();
  if (borderImageLengthMatchesAllSides(currentImage.Outset(),
                                       BorderImageLength(Length(0, kFixed))))
    return;

NinePieceImage image(currentImage);
  image.SetOutset(Length(0, kFixed));
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskBoxImageOutset(StyleResolverState& state) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  image.CopyOutsetFrom(state.ParentStyle()->MaskBoxImage());
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskBoxImageOutset(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  image.SetOutset(CSSToStyleMap::MapNinePieceImageQuad(state, value));
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskBoxImageRepeat(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->MaskBoxImage();
  if (currentImage.HorizontalRule() == kStretchImageRule &&
      currentImage.VerticalRule() == kStretchImageRule)
    return;

NinePieceImage image(currentImage);
  image.SetHorizontalRule(kStretchImageRule);
  image.SetVerticalRule(kStretchImageRule);
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskBoxImageRepeat(StyleResolverState& state) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  image.CopyRepeatFrom(state.ParentStyle()->MaskBoxImage());
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskBoxImageRepeat(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  CSSToStyleMap::MapNinePieceImageRepeat(state, value, image);
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskBoxImageSlice(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->MaskBoxImage();
  // Masks have a different initial value for slices. Preserve the value of 0
  // for backwards compatibility.
  if (currentImage.Fill() == true &&
      lengthMatchesAllSides(currentImage.ImageSlices(), Length(0, kFixed)))
    return;

NinePieceImage image(currentImage);
  image.SetImageSlices(LengthBox(Length(0, kFixed), Length(0, kFixed), Length(0, kFixed), Length(0, kFixed)));
  image.SetFill(true);
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskBoxImageSlice(StyleResolverState& state) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  image.CopyImageSlicesFrom(state.ParentStyle()->MaskBoxImage());
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskBoxImageSlice(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  CSSToStyleMap::MapNinePieceImageSlice(state, value, image);
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskBoxImageWidth(StyleResolverState& state) {
  const NinePieceImage& currentImage = state.Style()->MaskBoxImage();
  // Masks have a different initial value for widths. Preserve the value of
  // 'auto' for backwards compatibility.
  if (borderImageLengthMatchesAllSides(currentImage.BorderSlices(),
                                       BorderImageLength(Length(kAuto))))
    return;

NinePieceImage image(currentImage);
  image.SetBorderSlices(Length(kAuto));
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskBoxImageWidth(StyleResolverState& state) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  image.CopyBorderSlicesFrom(state.ParentStyle()->MaskBoxImage());
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskBoxImageWidth(StyleResolverState& state, const CSSValue& value) {
  NinePieceImage image(state.Style()->MaskBoxImage());
  image.SetBorderSlices(CSSToStyleMap::MapNinePieceImageQuad(state, value));
  state.Style()->SetMaskBoxImage(image);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderImageSource(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBorderImageSource(state.GetStyleImage(CSSPropertyBorderImageSource, value));
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskBoxImageSource(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMaskBoxImageSource(state.GetStyleImage(CSSPropertyWebkitMaskBoxImageSource, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundColor(StyleResolverState& state) {
  StyleColor color = ComputedStyle::InitialBackgroundColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBackgroundColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBackgroundColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->BackgroundColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBackgroundColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBackgroundColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBackgroundColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkBackgroundColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderBottomColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderBottomColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->BorderBottomColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderBottomColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderBottomColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderBottomColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderBottomColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkBorderBottomColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderLeftColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderLeftColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->BorderLeftColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderLeftColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderLeftColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderLeftColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderLeftColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkBorderLeftColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderRightColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderRightColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->BorderRightColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderRightColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderRightColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderRightColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderRightColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkBorderRightColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderTopColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderTopColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->BorderTopColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderTopColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkBorderTopColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyBorderTopColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetBorderTopColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkBorderTopColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyOutlineColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetOutlineColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkOutlineColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyOutlineColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->OutlineColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetOutlineColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkOutlineColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyOutlineColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetOutlineColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkOutlineColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextDecorationColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextDecorationColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextDecorationColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextDecorationColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->TextDecorationColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextDecorationColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextDecorationColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyTextDecorationColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextDecorationColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkTextDecorationColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnRuleColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetColumnRuleColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkColumnRuleColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnRuleColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->ColumnRuleColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetColumnRuleColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkColumnRuleColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnRuleColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetColumnRuleColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkColumnRuleColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextEmphasisColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextEmphasisColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextEmphasisColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextEmphasisColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->TextEmphasisColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextEmphasisColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextEmphasisColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextEmphasisColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkTextEmphasisColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextFillColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextFillColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextFillColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextFillColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->TextFillColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextFillColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextFillColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextFillColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextFillColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkTextFillColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextStrokeColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextStrokeColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextStrokeColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextStrokeColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->TextStrokeColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextStrokeColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextStrokeColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextStrokeColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextStrokeColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkTextStrokeColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyCounterIncrement(StyleResolverState& state) {
  state.Style()->ClearIncrementDirectives();
}

void StyleBuilderFunctions::applyInheritCSSPropertyCounterIncrement(StyleResolverState& state) {
  const CounterDirectiveMap* parentMap = state.ParentStyle()->GetCounterDirectives();
  if (!parentMap)
    return;

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();
  DCHECK(!parentMap->IsEmpty());

typedef CounterDirectiveMap::const_iterator Iterator;
  Iterator end = parentMap->end();
  for (Iterator it = parentMap->begin(); it != end; ++it) {
    CounterDirectives& directives = map.insert(it->key, CounterDirectives()).stored_value->value;
    directives.InheritIncrement(it->value);
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyCounterIncrement(StyleResolverState& state, const CSSValue& value) {
  state.Style()->ClearIncrementDirectives();

if (!value.IsValueList()) {
    DCHECK(value.IsIdentifierValue());
    DCHECK_EQ(ToCSSIdentifierValue(value).GetValueID(), CSSValueNone);
    return;
  }

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();

const CSSValueList& list = ToCSSValueList(value);

for (size_t i = 0; i < list.length(); ++i) {
    const CSSValuePair& pair = ToCSSValuePair(list.Item(i));
    AtomicString identifier(ToCSSCustomIdentValue(pair.First()).Value());
    int value = ToCSSPrimitiveValue(pair.Second()).GetIntValue();
    CounterDirectives& directives =
        map.insert(identifier, CounterDirectives()).stored_value->value;
    directives.AddIncrementValue(value);
  }
  DCHECK(!map.IsEmpty());
}

void StyleBuilderFunctions::applyInitialCSSPropertyCounterReset(StyleResolverState& state) {
  state.Style()->ClearResetDirectives();
}

void StyleBuilderFunctions::applyInheritCSSPropertyCounterReset(StyleResolverState& state) {
  const CounterDirectiveMap* parentMap = state.ParentStyle()->GetCounterDirectives();
  if (!parentMap)
    return;

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();
  DCHECK(!parentMap->IsEmpty());

void StyleBuilderFunctions::applyValueCSSPropertyCounterReset(StyleResolverState& state, const CSSValue& value) {
  state.Style()->ClearResetDirectives();

if (!value.IsValueList()) {
    DCHECK(value.IsIdentifierValue());
    DCHECK_EQ(ToCSSIdentifierValue(value).GetValueID(), CSSValueNone);
    return;
  }

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();

const CSSValueList& list = ToCSSValueList(value);

for (size_t i = 0; i < list.length(); ++i) {
    const CSSValuePair& pair = ToCSSValuePair(list.Item(i));
    AtomicString identifier(ToCSSCustomIdentValue(pair.First()).Value());
    int value = ToCSSPrimitiveValue(pair.Second()).GetIntValue();
    CounterDirectives& directives =
        map.insert(identifier, CounterDirectives()).stored_value->value;
    directives.SetResetValue(value);
  }
  DCHECK(!map.IsEmpty());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundAttachment(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetAttachment(FillLayer::InitialFillAttachment(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearAttachment();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundAttachment(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsAttachmentSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetAttachment(currParent->Attachment());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearAttachment();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundAttachment(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillAttachment(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillAttachment(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearAttachment();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundBlendMode(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetBlendMode(FillLayer::InitialFillBlendMode(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearBlendMode();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundBlendMode(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsBlendModeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetBlendMode(currParent->BlendMode());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearBlendMode();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundBlendMode(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillBlendMode(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillBlendMode(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearBlendMode();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetClip(FillLayer::InitialFillClip(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearClip();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsClipSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetClip(currParent->Clip());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundClip(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillClip(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillClip(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetImage(FillLayer::InitialFillImage(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearImage();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsImageSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetImage(currParent->GetImage());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundImage(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillImage(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillImage(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetOrigin(FillLayer::InitialFillOrigin(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearOrigin();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsOriginSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetOrigin(currParent->Origin());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundOrigin(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillOrigin(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillOrigin(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetXPosition(FillLayer::InitialFillXPosition(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearXPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsXPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetXPosition(currParent->XPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundPositionX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillXPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillXPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetYPosition(FillLayer::InitialFillYPosition(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearYPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsYPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetYPosition(currParent->YPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundPositionY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillYPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillYPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetRepeatX(FillLayer::InitialFillRepeatX(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatX();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsRepeatXSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatX(currParent->RepeatX());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundRepeatX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatX(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatX(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetRepeatY(FillLayer::InitialFillRepeatY(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatY();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsRepeatYSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatY(currParent->RepeatY());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundRepeatY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatY(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatY(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetSize(FillLayer::InitialFillSize(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearSize();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsSizeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetSize(currParent->Size());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundSize(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillSize(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillSize(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaskSourceType(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetMaskSourceType(FillLayer::InitialFillMaskSourceType(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearMaskSourceType();
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaskSourceType(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsMaskSourceTypeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetMaskSourceType(currParent->MaskSourceType());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearMaskSourceType();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyMaskSourceType(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillMaskSourceType(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillMaskSourceType(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearMaskSourceType();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetClip(FillLayer::InitialFillClip(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearClip();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsClipSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetClip(currParent->Clip());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskClip(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillClip(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillClip(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskComposite(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetComposite(FillLayer::InitialFillComposite(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearComposite();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskComposite(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsCompositeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetComposite(currParent->Composite());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearComposite();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskComposite(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillComposite(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillComposite(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearComposite();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetImage(FillLayer::InitialFillImage(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearImage();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsImageSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetImage(currParent->GetImage());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskImage(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillImage(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillImage(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetOrigin(FillLayer::InitialFillOrigin(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearOrigin();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsOriginSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetOrigin(currParent->Origin());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskOrigin(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillOrigin(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillOrigin(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetXPosition(FillLayer::InitialFillXPosition(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearXPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsXPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetXPosition(currParent->XPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskPositionX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillXPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillXPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetYPosition(FillLayer::InitialFillYPosition(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearYPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsYPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetYPosition(currParent->YPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskPositionY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillYPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillYPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetRepeatX(FillLayer::InitialFillRepeatX(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatX();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsRepeatXSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatX(currParent->RepeatX());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskRepeatX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatX(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatX(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetRepeatY(FillLayer::InitialFillRepeatY(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatY();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsRepeatYSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatY(currParent->RepeatY());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskRepeatY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatY(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatY(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetSize(FillLayer::InitialFillSize(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearSize();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsSizeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetSize(currParent->Size());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskSize(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillSize(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillSize(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateColumns(StyleResolverState& state) {
  state.Style()->SetGridTemplateColumns(ComputedStyle::InitialGridTemplateColumns());
  state.Style()->SetNamedGridColumnLines(ComputedStyle::InitialNamedGridColumnLines());
  state.Style()->SetOrderedNamedGridColumnLines(ComputedStyle::InitialOrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumns(ComputedStyle::InitialGridAutoRepeatColumns());
  state.Style()->SetGridAutoRepeatColumnsInsertionPoint(ComputedStyle::InitialGridAutoRepeatColumnsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridColumnLines(ComputedStyle::InitialNamedGridColumnLines());
  state.Style()->SetAutoRepeatOrderedNamedGridColumnLines(ComputedStyle::InitialOrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumnsType(ComputedStyle::InitialGridAutoRepeatColumnsType());

}

void StyleBuilderFunctions::applyInheritCSSPropertyGridTemplateColumns(StyleResolverState& state) {
  state.Style()->SetGridTemplateColumns(state.ParentStyle()->GridTemplateColumns());
  state.Style()->SetNamedGridColumnLines(state.ParentStyle()->NamedGridColumnLines());
  state.Style()->SetOrderedNamedGridColumnLines(state.ParentStyle()->OrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumns(state.ParentStyle()->GridAutoRepeatColumns());
  state.Style()->SetGridAutoRepeatColumnsInsertionPoint(state.ParentStyle()->GridAutoRepeatColumnsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridColumnLines(state.ParentStyle()->AutoRepeatNamedGridColumnLines());
  state.Style()->SetAutoRepeatOrderedNamedGridColumnLines(state.ParentStyle()->AutoRepeatOrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumnsType(state.ParentStyle()->GridAutoRepeatColumnsType());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridTemplateColumns(StyleResolverState& state, const CSSValue& value) {
  Vector<GridTrackSize> trackSizes;
  Vector<GridTrackSize> autoRepeatTrackSizes;
  NamedGridLinesMap namedGridLines;
  OrderedNamedGridLines orderedNamedGridLines;
  NamedGridLinesMap autoRepeatNamedGridLines;
  OrderedNamedGridLines autoRepeatOrderedNamedGridLines;
  AutoRepeatType autoRepeatType = ComputedStyle::InitialGridAutoRepeatType();
  size_t autoRepeatInsertionPoint =
      ComputedStyle::InitialGridAutoRepeatInsertionPoint();
  StyleBuilderConverter::ConvertGridTrackList(
      value, trackSizes, namedGridLines, orderedNamedGridLines,
      autoRepeatTrackSizes, autoRepeatNamedGridLines,
      autoRepeatOrderedNamedGridLines, autoRepeatInsertionPoint,
      autoRepeatType, state);
  const NamedGridAreaMap& namedGridAreas = state.Style()->NamedGridArea();
  if (!namedGridAreas.IsEmpty()) {
    StyleBuilderConverter::CreateImplicitNamedGridLinesFromGridArea(
        namedGridAreas, namedGridLines, kForColumns);
  }
  state.Style()->SetGridTemplateColumns(trackSizes);
  state.Style()->SetNamedGridColumnLines(namedGridLines);
  state.Style()->SetOrderedNamedGridColumnLines(orderedNamedGridLines);
  state.Style()->SetGridAutoRepeatColumns(autoRepeatTrackSizes);
  state.Style()->SetGridAutoRepeatColumnsInsertionPoint(
      autoRepeatInsertionPoint);
  state.Style()->SetAutoRepeatNamedGridColumnLines(autoRepeatNamedGridLines);
  state.Style()->SetAutoRepeatOrderedNamedGridColumnLines(
      autoRepeatOrderedNamedGridLines);
  state.Style()->SetGridAutoRepeatColumnsType(autoRepeatType);
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateRows(StyleResolverState& state) {
  state.Style()->SetGridTemplateRows(ComputedStyle::InitialGridTemplateRows());
  state.Style()->SetNamedGridRowLines(ComputedStyle::InitialNamedGridRowLines());
  state.Style()->SetOrderedNamedGridRowLines(ComputedStyle::InitialOrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRows(ComputedStyle::InitialGridAutoRepeatRows());
  state.Style()->SetGridAutoRepeatRowsInsertionPoint(ComputedStyle::InitialGridAutoRepeatRowsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridRowLines(ComputedStyle::InitialNamedGridRowLines());
  state.Style()->SetAutoRepeatOrderedNamedGridRowLines(ComputedStyle::InitialOrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRowsType(ComputedStyle::InitialGridAutoRepeatRowsType());

}

void StyleBuilderFunctions::applyInheritCSSPropertyGridTemplateRows(StyleResolverState& state) {
  state.Style()->SetGridTemplateRows(state.ParentStyle()->GridTemplateRows());
  state.Style()->SetNamedGridRowLines(state.ParentStyle()->NamedGridRowLines());
  state.Style()->SetOrderedNamedGridRowLines(state.ParentStyle()->OrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRows(state.ParentStyle()->GridAutoRepeatRows());
  state.Style()->SetGridAutoRepeatRowsInsertionPoint(state.ParentStyle()->GridAutoRepeatRowsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridRowLines(state.ParentStyle()->AutoRepeatNamedGridRowLines());
  state.Style()->SetAutoRepeatOrderedNamedGridRowLines(state.ParentStyle()->AutoRepeatOrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRowsType(state.ParentStyle()->GridAutoRepeatRowsType());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridTemplateRows(StyleResolverState& state, const CSSValue& value) {
  Vector<GridTrackSize> trackSizes;
  Vector<GridTrackSize> autoRepeatTrackSizes;
  NamedGridLinesMap namedGridLines;
  OrderedNamedGridLines orderedNamedGridLines;
  NamedGridLinesMap autoRepeatNamedGridLines;
  OrderedNamedGridLines autoRepeatOrderedNamedGridLines;
  AutoRepeatType autoRepeatType = ComputedStyle::InitialGridAutoRepeatType();
  size_t autoRepeatInsertionPoint =
      ComputedStyle::InitialGridAutoRepeatInsertionPoint();
  StyleBuilderConverter::ConvertGridTrackList(
      value, trackSizes, namedGridLines, orderedNamedGridLines,
      autoRepeatTrackSizes, autoRepeatNamedGridLines,
      autoRepeatOrderedNamedGridLines, autoRepeatInsertionPoint,
      autoRepeatType, state);
  const NamedGridAreaMap& namedGridAreas = state.Style()->NamedGridArea();
  if (!namedGridAreas.IsEmpty()) {
    StyleBuilderConverter::CreateImplicitNamedGridLinesFromGridArea(
        namedGridAreas, namedGridLines, kForRows);
  }
  state.Style()->SetGridTemplateRows(trackSizes);
  state.Style()->SetNamedGridRowLines(namedGridLines);
  state.Style()->SetOrderedNamedGridRowLines(orderedNamedGridLines);
  state.Style()->SetGridAutoRepeatRows(autoRepeatTrackSizes);
  state.Style()->SetGridAutoRepeatRowsInsertionPoint(
      autoRepeatInsertionPoint);
  state.Style()->SetAutoRepeatNamedGridRowLines(autoRepeatNamedGridLines);
  state.Style()->SetAutoRepeatOrderedNamedGridRowLines(
      autoRepeatOrderedNamedGridLines);
  state.Style()->SetGridAutoRepeatRowsType(autoRepeatType);
}

void StyleBuilderFunctions::applyInitialCSSPropertyFill(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillPaint(
      SVGComputedStyle::InitialFillPaintType(),
      SVGComputedStyle::InitialFillPaintColor(),
      SVGComputedStyle::InitialFillPaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFill(StyleResolverState& state) {
  const SVGComputedStyle& svgParentStyle = state.ParentStyle()->SvgStyle();
  state.Style()->AccessSVGStyle().SetFillPaint(
      svgParentStyle.FillPaintType(),
      svgParentStyle.FillPaintColor(),
      svgParentStyle.FillPaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyFill(StyleResolverState& state, const CSSValue& value) {
  const CSSValue* localValue = &value;
  String url;
  if (value.IsValueList()) {
    const CSSValueList& list = ToCSSValueList(value);
    DCHECK_EQ(list.length(), 2U);
    url = ToCSSURIValue(list.Item(0)).Value();
    localValue = &list.Item(1);
  }

Color color;
  SVGPaintType paintType = SVG_PAINTTYPE_RGBCOLOR;
  if (localValue->IsURIValue()) {
    paintType = SVG_PAINTTYPE_URI;
    url = ToCSSURIValue(localValue)->Value();
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueNone) {
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_NONE : SVG_PAINTTYPE_URI_NONE;
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueCurrentcolor) {
    color = state.Style()->GetColor();
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_CURRENTCOLOR
    	                      : SVG_PAINTTYPE_URI_CURRENTCOLOR;
  } else {
    color = StyleBuilderConverter::ConvertColor(state, *localValue);
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_RGBCOLOR
    	                      : SVG_PAINTTYPE_URI_RGBCOLOR;
  }
  state.Style()->AccessSVGStyle().SetFillPaint(paintType, color, url,
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStroke(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokePaint(
      SVGComputedStyle::InitialStrokePaintType(),
      SVGComputedStyle::InitialStrokePaintColor(),
      SVGComputedStyle::InitialStrokePaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStroke(StyleResolverState& state) {
  const SVGComputedStyle& svgParentStyle = state.ParentStyle()->SvgStyle();
  state.Style()->AccessSVGStyle().SetStrokePaint(
      svgParentStyle.StrokePaintType(),
      svgParentStyle.StrokePaintColor(),
      svgParentStyle.StrokePaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyStroke(StyleResolverState& state, const CSSValue& value) {
  const CSSValue* localValue = &value;
  String url;
  if (value.IsValueList()) {
    const CSSValueList& list = ToCSSValueList(value);
    DCHECK_EQ(list.length(), 2U);
    url = ToCSSURIValue(list.Item(0)).Value();
    localValue = &list.Item(1);
  }

Color color;
  SVGPaintType paintType = SVG_PAINTTYPE_RGBCOLOR;
  if (localValue->IsURIValue()) {
    paintType = SVG_PAINTTYPE_URI;
    url = ToCSSURIValue(localValue)->Value();
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueNone) {
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_NONE : SVG_PAINTTYPE_URI_NONE;
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueCurrentcolor) {
    color = state.Style()->GetColor();
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_CURRENTCOLOR
    	                      : SVG_PAINTTYPE_URI_CURRENTCOLOR;
  } else {
    color = StyleBuilderConverter::ConvertColor(state, *localValue);
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_RGBCOLOR
    	                      : SVG_PAINTTYPE_URI_RGBCOLOR;
  }
  state.Style()->AccessSVGStyle().SetStrokePaint(paintType, color, url,
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

} // namespace blink

変更されたテキスト

ファイルを開く

#include "StyleBuilderFunctions.h"

namespace blink {

void StyleBuilderFunctions::applyInitialCSSPropertyDirection(StyleResolverState& state) {
  state.Style()->SetDirection(ComputedStyleInitialFunctions::InitialDirection());
}

void StyleBuilderFunctions::applyInheritCSSPropertyDirection(StyleResolverState& state) {
  state.Style()->SetDirection(state.ParentStyle()->Direction());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFontKerning(StyleResolverState& state) {
  state.GetFontBuilder().SetKerning(FontBuilder::InitialKerning());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFontKerning(StyleResolverState& state) {
  state.GetFontBuilder().SetKerning(state.ParentFontDescription().GetKerning());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(ComputedStyleInitialFunctions::InitialTextOrientation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextRendering(StyleResolverState& state) {
  state.GetFontBuilder().SetTextRendering(FontBuilder::InitialTextRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextRendering(StyleResolverState& state) {
  state.GetFontBuilder().SetTextRendering(state.ParentFontDescription().TextRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {
  state.GetFontBuilder().SetFontSmoothing(FontBuilder::InitialFontSmoothing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {
  state.GetFontBuilder().SetFontSmoothing(state.ParentFontDescription().FontSmoothing());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLocale(StyleResolverState& state) {
  state.GetFontBuilder().SetLocale(FontBuilder::InitialLocale());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLocale(StyleResolverState& state) {
  state.GetFontBuilder().SetLocale(state.ParentFontDescription().Locale());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(ComputedStyleInitialFunctions::InitialTextOrientation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(ComputedStyleInitialFunctions::InitialWritingMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(ComputedStyleInitialFunctions::InitialWritingMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());
}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignContent(StyleResolverState& state) {
  state.Style()->SetAlignContent(ComputedStyleInitialFunctions::InitialAlignContent());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignContent(StyleResolverState& state) {
  state.Style()->SetAlignContent(state.ParentStyle()->AlignContent());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBackfaceVisibility(StyleResolverState& state) {
  state.Style()->SetBackfaceVisibility(ComputedStyleInitialFunctions::InitialBackfaceVisibility());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackfaceVisibility(StyleResolverState& state) {
  state.Style()->SetBackfaceVisibility(state.ParentStyle()->BackfaceVisibility());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBaselineShift(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetBaselineShift(SVGComputedStyle::InitialBaselineShift());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomLeftRadius(ComputedStyleInitialFunctions::InitialBorderBottomLeftRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomLeftRadius(state.ParentStyle()->BorderBottomLeftRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomRightRadius(ComputedStyleInitialFunctions::InitialBorderBottomRightRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomRightRadius(state.ParentStyle()->BorderBottomRightRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomStyle(StyleResolverState& state) {
  state.Style()->SetBorderBottomStyle(ComputedStyleInitialFunctions::InitialBorderBottomStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomStyle(StyleResolverState& state) {
  state.Style()->SetBorderBottomStyle(state.ParentStyle()->BorderBottomStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomWidth(StyleResolverState& state) {
  state.Style()->SetBorderBottomWidth(ComputedStyleInitialFunctions::InitialBorderBottomWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomWidth(StyleResolverState& state) {
  state.Style()->SetBorderBottomWidth(state.ParentStyle()->BorderBottomWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderCollapse(StyleResolverState& state) {
  state.Style()->SetBorderCollapse(ComputedStyleInitialFunctions::InitialBorderCollapse());
  state.Style()->SetBorderCollapseIsInherited
(false);
}

state.Style()->SetBorderCollapseIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageSource(StyleResolverState& state) {
  state.Style()->SetBorderImageSource(ComputedStyleInitialFunctions::InitialBorderImageSource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageSource(StyleResolverState& state) {
  state.Style()->SetBorderImageSource(state.ParentStyle()->BorderImageSource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftStyle(StyleResolverState& state) {
  state.Style()->SetBorderLeftStyle(ComputedStyleInitialFunctions::InitialBorderLeftStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftStyle(StyleResolverState& state) {
  state.Style()->SetBorderLeftStyle(state.ParentStyle()->BorderLeftStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftWidth(StyleResolverState& state) {
  state.Style()->SetBorderLeftWidth(ComputedStyleInitialFunctions::InitialBorderLeftWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftWidth(StyleResolverState& state) {
  state.Style()->SetBorderLeftWidth(state.ParentStyle()->BorderLeftWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightStyle(StyleResolverState& state) {
  state.Style()->SetBorderRightStyle(ComputedStyleInitialFunctions::InitialBorderRightStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightStyle(StyleResolverState& state) {
  state.Style()->SetBorderRightStyle(state.ParentStyle()->BorderRightStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightWidth(StyleResolverState& state) {
  state.Style()->SetBorderRightWidth(ComputedStyleInitialFunctions::InitialBorderRightWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightWidth(StyleResolverState& state) {
  state.Style()->SetBorderRightWidth(state.ParentStyle()->BorderRightWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopLeftRadius(ComputedStyleInitialFunctions::InitialBorderTopLeftRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopLeftRadius(state.ParentStyle()->BorderTopLeftRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopRightRadius(ComputedStyleInitialFunctions::InitialBorderTopRightRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopRightRadius(state.ParentStyle()->BorderTopRightRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopStyle(StyleResolverState& state) {
  state.Style()->SetBorderTopStyle(ComputedStyleInitialFunctions::InitialBorderTopStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopStyle(StyleResolverState& state) {
  state.Style()->SetBorderTopStyle(state.ParentStyle()->BorderTopStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopWidth(StyleResolverState& state) {
  state.Style()->SetBorderTopWidth(ComputedStyleInitialFunctions::InitialBorderTopWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopWidth(StyleResolverState& state) {
  state.Style()->SetBorderTopWidth(state.ParentStyle()->BorderTopWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBottom(StyleResolverState& state) {
  state.Style()->SetBottom(ComputedStyleInitialFunctions::InitialBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBottom(StyleResolverState& state) {
  state.Style()->SetBottom(state.ParentStyle()->Bottom());
}

void StyleBuilderFunctions::applyValueCSSPropertyBottom(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBottom(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBoxSizing(StyleResolverState& state) {
  state.Style()->SetBoxSizing(ComputedStyleInitialFunctions::InitialBoxSizing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBoxSizing(StyleResolverState& state) {
  state.Style()->SetBoxSizing(state.ParentStyle()->BoxSizing());
}

void StyleBuilderFunctions::applyValueCSSPropertyBoxSizing(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxSizing(ToCSSIdentifierValue(value).ConvertTo<EBoxSizing>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakAfter(StyleResolverState& state) {
  state.Style()->SetBreakAfter(ComputedStyleInitialFunctions::InitialBreakAfter());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakAfter(StyleResolverState& state) {
  state.Style()->SetBreakAfter(state.ParentStyle()->BreakAfter());
}

void StyleBuilderFunctions::applyValueCSSPropertyBreakAfter(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBreakAfter(ToCSSIdentifierValue(value).ConvertTo<EBreakBetween>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakBefore(StyleResolverState& state) {
  state.Style()->SetBreakBefore(ComputedStyleInitialFunctions::InitialBreakBefore());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakBefore(StyleResolverState& state) {
  state.Style()->SetBreakBefore(state.ParentStyle()->BreakBefore());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakInside(StyleResolverState& state) {
  state.Style()->SetBreakInside(ComputedStyleInitialFunctions::InitialBreakInside());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakInside(StyleResolverState& state) {
  state.Style()->SetBreakInside(state.ParentStyle()->BreakInside());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyCaptionSide(StyleResolverState& state) {
  state.Style()->SetCaptionSide(ComputedStyleInitialFunctions::InitialCaptionSide());
  state.Style()->SetCaptionSideIsInherited
(false);
}

state.Style()->SetCaptionSideIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyClear(StyleResolverState& state) {
  state.Style()->SetClear(ComputedStyleInitialFunctions::InitialClear());
}

void StyleBuilderFunctions::applyInheritCSSPropertyClear(StyleResolverState& state) {
  state.Style()->SetClear(state.ParentStyle()->Clear());
}

void StyleBuilderFunctions::applyValueCSSPropertyClear(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetClear(ToCSSIdentifierValue(value).ConvertTo<EClear>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyClipRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetClipRule(SVGComputedStyle::InitialClipRule());
}

void StyleBuilderFunctions::applyInheritCSSPropertyClipRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetClipRule(state.ParentStyle()->SvgStyle().ClipRule());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorRendering(SVGComputedStyle::InitialColorRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColorRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorRendering(state.ParentStyle()->SvgStyle().ColorRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnFill(StyleResolverState& state) {
  state.Style()->SetColumnFill(ComputedStyleInitialFunctions::InitialColumnFill());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnFill(StyleResolverState& state) {
  state.Style()->SetColumnFill(state.ParentStyle()->GetColumnFill());
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnFill(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetColumnFill(ToCSSIdentifierValue(value).ConvertTo<EColumnFill>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnRuleStyle(StyleResolverState& state) {
  state.Style()->SetColumnRuleStyle(ComputedStyleInitialFunctions::InitialColumnRuleStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnRuleStyle(StyleResolverState& state) {
  state.Style()->SetColumnRuleStyle(state.ParentStyle()->ColumnRuleStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyCx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCx(SVGComputedStyle::InitialCx());
}

void StyleBuilderFunctions::applyInheritCSSPropertyCx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCx(state.ParentStyle()->SvgStyle().Cx());
}

void StyleBuilderFunctions::applyValueCSSPropertyCx(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetCx(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyCy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCy(SVGComputedStyle::InitialCy());
}

void StyleBuilderFunctions::applyInheritCSSPropertyCy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCy(state.ParentStyle()->SvgStyle().Cy());
}

void StyleBuilderFunctions::applyValueCSSPropertyCy(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetCy(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyDisplay(StyleResolverState& state) {
  state.Style()->SetDisplay(ComputedStyleInitialFunctions::InitialDisplay());
}

void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state) {
  state.Style()->SetDisplay(state.ParentStyle()->Display());
}

void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetDisplay(ToCSSIdentifierValue(value).ConvertTo<EDisplay>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyDominantBaseline(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetDominantBaseline(SVGComputedStyle::InitialDominantBaseline());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyEmptyCells(StyleResolverState& state) {
  state.Style()->SetEmptyCells(ComputedStyleInitialFunctions::InitialEmptyCells());
  state.Style()->SetEmptyCellsIsInherited
(false);
}

void StyleBuilderFunctions::applyValueCSSPropertyEmptyCells(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetEmptyCells(ToCSSIdentifierValue(value).ConvertTo<EEmptyCells>());

state.Style()->SetEmptyCellsIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyFillOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillOpacity(SVGComputedStyle::InitialFillOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFillOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillOpacity(state.ParentStyle()->SvgStyle().FillOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFillRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillRule(SVGComputedStyle::InitialFillRule());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFillRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillRule(state.ParentStyle()->SvgStyle().FillRule());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexDirection(StyleResolverState& state) {
  state.Style()->SetFlexDirection(ComputedStyleInitialFunctions::InitialFlexDirection());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexDirection(StyleResolverState& state) {
  state.Style()->SetFlexDirection(state.ParentStyle()->FlexDirection());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexGrow(StyleResolverState& state) {
  state.Style()->SetFlexGrow(ComputedStyleInitialFunctions::InitialFlexGrow());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexGrow(StyleResolverState& state) {
  state.Style()->SetFlexGrow(state.ParentStyle()->FlexGrow());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexGrow(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexGrow(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexShrink(StyleResolverState& state) {
  state.Style()->SetFlexShrink(ComputedStyleInitialFunctions::InitialFlexShrink());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexShrink(StyleResolverState& state) {
  state.Style()->SetFlexShrink(state.ParentStyle()->FlexShrink());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexShrink(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexShrink(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexWrap(StyleResolverState& state) {
  state.Style()->SetFlexWrap(ComputedStyleInitialFunctions::InitialFlexWrap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexWrap(StyleResolverState& state) {
  state.Style()->SetFlexWrap(state.ParentStyle()->FlexWrap());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexWrap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexWrap(ToCSSIdentifierValue(value).ConvertTo<EFlexWrap>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFloat(StyleResolverState& state) {
  state.Style()->SetFloating(ComputedStyleInitialFunctions::InitialFloating());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloat(StyleResolverState& state) {
  state.Style()->SetFloating(state.ParentStyle()->Floating());
}

void StyleBuilderFunctions::applyValueCSSPropertyFloat(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFloating(ToCSSIdentifierValue(value).ConvertTo<EFloat>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFloodColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodColor(SVGComputedStyle::InitialFloodColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloodColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodColor(state.ParentStyle()->SvgStyle().FloodColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFloodOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodOpacity(SVGComputedStyle::InitialFloodOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloodOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodOpacity(state.ParentStyle()->SvgStyle().FloodOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridAutoColumns(StyleResolverState& state) {
  state.Style()->SetGridAutoColumns(ComputedStyleInitialFunctions::InitialGridAutoColumns());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridAutoColumns(StyleResolverState& state) {
  state.Style()->SetGridAutoColumns(state.ParentStyle()->GridAutoColumns());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridAutoRows(StyleResolverState& state) {
  state.Style()->SetGridAutoRows(ComputedStyleInitialFunctions::InitialGridAutoRows());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridAutoRows(StyleResolverState& state) {
  state.Style()->SetGridAutoRows(state.ParentStyle()->GridAutoRows());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnEnd(StyleResolverState& state) {
  state.Style()->SetGridColumnEnd(ComputedStyleInitialFunctions::InitialGridColumnEnd());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnEnd(StyleResolverState& state) {
  state.Style()->SetGridColumnEnd(state.ParentStyle()->GridColumnEnd());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnGap(StyleResolverState& state) {
  state.Style()->SetGridColumnGap(ComputedStyleInitialFunctions::InitialGridColumnGap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnGap(StyleResolverState& state) {
  state.Style()->SetGridColumnGap(state.ParentStyle()->GridColumnGap());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnStart(StyleResolverState& state) {
  state.Style()->SetGridColumnStart(ComputedStyleInitialFunctions::InitialGridColumnStart());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnStart(StyleResolverState& state) {
  state.Style()->SetGridColumnStart(state.ParentStyle()->GridColumnStart());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowEnd(StyleResolverState& state) {
  state.Style()->SetGridRowEnd(ComputedStyleInitialFunctions::InitialGridRowEnd());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowEnd(StyleResolverState& state) {
  state.Style()->SetGridRowEnd(state.ParentStyle()->GridRowEnd());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowGap(StyleResolverState& state) {
  state.Style()->SetGridRowGap(ComputedStyleInitialFunctions::InitialGridRowGap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowGap(StyleResolverState& state) {
  state.Style()->SetGridRowGap(state.ParentStyle()->GridRowGap());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridRowGap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridRowGap(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowStart(StyleResolverState& state) {
  state.Style()->SetGridRowStart(ComputedStyleInitialFunctions::InitialGridRowStart());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowStart(StyleResolverState& state) {
  state.Style()->SetGridRowStart(state.ParentStyle()->GridRowStart());
}

void StyleBuilderFunctions::applyInitialCSSPropertyHeight(StyleResolverState& state) {
  state.Style()->SetHeight(ComputedStyleInitialFunctions::InitialHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyHeight(StyleResolverState& state) {
  state.Style()->SetHeight(state.ParentStyle()->Height());
}

void StyleBuilderFunctions::applyValueCSSPropertyHeight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetHeight(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyImageRendering(StyleResolverState& state) {
  state.Style()->SetImageRendering(ComputedStyleInitialFunctions::InitialImageRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyImageRendering(StyleResolverState& state) {
  state.Style()->SetImageRendering(state.ParentStyle()->ImageRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyIsolation(StyleResolverState& state) {
  state.Style()->SetIsolation(ComputedStyleInitialFunctions::InitialIsolation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyIsolation(StyleResolverState& state) {
  state.Style()->SetIsolation(state.ParentStyle()->Isolation());
}

void StyleBuilderFunctions::applyValueCSSPropertyIsolation(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetIsolation(ToCSSIdentifierValue(value).ConvertTo<EIsolation>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyJustifyContent(StyleResolverState& state) {
  state.Style()->SetJustifyContent(ComputedStyleInitialFunctions::InitialJustifyContent());
}

void StyleBuilderFunctions::applyInheritCSSPropertyJustifyContent(StyleResolverState& state) {
  state.Style()->SetJustifyContent(state.ParentStyle()->JustifyContent());
}

void StyleBuilderFunctions::applyInitialCSSPropertyLeft(StyleResolverState& state) {
  state.Style()->SetLeft(ComputedStyleInitialFunctions::InitialLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLeft(StyleResolverState& state) {
  state.Style()->SetLeft(state.ParentStyle()->Left());
}

void StyleBuilderFunctions::applyValueCSSPropertyLeft(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLeft(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyLetterSpacing(StyleResolverState& state) {
  state.Style()->SetLetterSpacing(ComputedStyleInitialFunctions::InitialLetterSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLetterSpacing(StyleResolverState& state) {
  state.Style()->SetLetterSpacing(state.ParentStyle()->LetterSpacing());
}

void StyleBuilderFunctions::applyInitialCSSPropertyLightingColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetLightingColor(SVGComputedStyle::InitialLightingColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLightingColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetLightingColor(state.ParentStyle()->SvgStyle().LightingColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(ComputedStyleInitialFunctions::InitialLineBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(state.ParentStyle()->GetLineBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyLineBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLineBreak(ToCSSIdentifierValue(value).ConvertTo<LineBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyListStyleImage(StyleResolverState& state) {
  state.Style()->SetListStyleImage(ComputedStyleInitialFunctions::InitialListStyleImage());
}

void StyleBuilderFunctions::applyInheritCSSPropertyListStyleImage(StyleResolverState& state) {
  state.Style()->SetListStyleImage(state.ParentStyle()->ListStyleImage());
}

void StyleBuilderFunctions::applyInitialCSSPropertyListStylePosition(StyleResolverState& state) {
  state.Style()->SetListStylePosition(ComputedStyleInitialFunctions::InitialListStylePosition());
  state.Style()->SetListStylePositionIsInherited
(false);
}

state.Style()->SetListStylePositionIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyListStyleType(StyleResolverState& state) {
  state.Style()->SetListStyleType(ComputedStyleInitialFunctions::InitialListStyleType());
}

void StyleBuilderFunctions::applyInheritCSSPropertyListStyleType(StyleResolverState& state) {
  state.Style()->SetListStyleType(state.ParentStyle()->ListStyleType());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerEnd(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerEndResource(SVGComputedStyle::InitialMarkerEndResource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerMid(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerMidResource(SVGComputedStyle::InitialMarkerMidResource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerStart(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerStartResource(SVGComputedStyle::InitialMarkerStartResource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaskType(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMaskType(SVGComputedStyle::InitialMaskType());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaskType(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMaskType(state.ParentStyle()->SvgStyle().MaskType());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyMaxHeight(StyleResolverState& state) {
  state.Style()->SetMaxHeight(ComputedStyleInitialFunctions::InitialMaxHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaxHeight(StyleResolverState& state) {
  state.Style()->SetMaxHeight(state.ParentStyle()->MaxHeight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaxWidth(StyleResolverState& state) {
  state.Style()->SetMaxWidth(ComputedStyleInitialFunctions::InitialMaxWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaxWidth(StyleResolverState& state) {
  state.Style()->SetMaxWidth(state.ParentStyle()->MaxWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMinHeight(StyleResolverState& state) {
  state.Style()->SetMinHeight(ComputedStyleInitialFunctions::InitialMinHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMinHeight(StyleResolverState& state) {
  state.Style()->SetMinHeight(state.ParentStyle()->MinHeight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMinWidth(StyleResolverState& state) {
  state.Style()->SetMinWidth(ComputedStyleInitialFunctions::InitialMinWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMinWidth(StyleResolverState& state) {
  state.Style()->SetMinWidth(state.ParentStyle()->MinWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyMinWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMinWidth(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMixBlendMode(StyleResolverState& state) {
  state.Style()->SetBlendMode(ComputedStyleInitialFunctions::InitialBlendMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMixBlendMode(StyleResolverState& state) {
  state.Style()->SetBlendMode(state.ParentStyle()->BlendMode());
}

void StyleBuilderFunctions::applyValueCSSPropertyMixBlendMode(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBlendMode(ToCSSIdentifierValue(value).ConvertTo<WebBlendMode>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyObjectFit(StyleResolverState& state) {
  state.Style()->SetObjectFit(ComputedStyleInitialFunctions::InitialObjectFit());
}

void StyleBuilderFunctions::applyInheritCSSPropertyObjectFit(StyleResolverState& state) {
  state.Style()->SetObjectFit(state.ParentStyle()->GetObjectFit());
}

void StyleBuilderFunctions::applyValueCSSPropertyObjectFit(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetObjectFit(ToCSSIdentifierValue(value).ConvertTo<EObjectFit>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOpacity(StyleResolverState& state) {
  state.Style()->SetOpacity(ComputedStyleInitialFunctions::InitialOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOpacity(StyleResolverState& state) {
  state.Style()->SetOpacity(state.ParentStyle()->Opacity());
}

void StyleBuilderFunctions::applyValueCSSPropertyOpacity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOpacity(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyOrphans(StyleResolverState& state) {
  state.Style()->SetOrphans(ComputedStyleInitialFunctions::InitialOrphans());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOrphans(StyleResolverState& state) {
  state.Style()->SetOrphans(state.ParentStyle()->Orphans());
}

void StyleBuilderFunctions::applyValueCSSPropertyOrphans(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOrphans(ToCSSPrimitiveValue(value).ConvertTo<short>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(ComputedStyleInitialFunctions::InitialOverflowWrap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(state.ParentStyle()->OverflowWrap());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowX(StyleResolverState& state) {
  state.Style()->SetOverflowX(ComputedStyleInitialFunctions::InitialOverflowX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowX(StyleResolverState& state) {
  state.Style()->SetOverflowX(state.ParentStyle()->OverflowX());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverflowX(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowX(ToCSSIdentifierValue(value).ConvertTo<EOverflow>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowY(StyleResolverState& state) {
  state.Style()->SetOverflowY(ComputedStyleInitialFunctions::InitialOverflowY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowY(StyleResolverState& state) {
  state.Style()->SetOverflowY(state.ParentStyle()->OverflowY());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverflowY(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowY(ToCSSIdentifierValue(value).ConvertTo<EOverflow>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverscrollBehaviorX(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorX(ComputedStyleInitialFunctions::InitialOverscrollBehaviorX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverscrollBehaviorX(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorX(state.ParentStyle()->OverscrollBehaviorX());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverscrollBehaviorY(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorY(ComputedStyleInitialFunctions::InitialOverscrollBehaviorY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverscrollBehaviorY(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorY(state.ParentStyle()->OverscrollBehaviorY());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyPointerEvents(StyleResolverState& state) {
  state.Style()->SetPointerEvents(ComputedStyleInitialFunctions::InitialPointerEvents());
  state.Style()->SetPointerEventsIsInherited
(false);
}

state.Style()->SetPointerEventsIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyPosition(StyleResolverState& state) {
  state.Style()->SetPosition(ComputedStyleInitialFunctions::InitialPosition());
}

void StyleBuilderFunctions::applyValueCSSPropertyPosition(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetPosition(ToCSSIdentifierValue(value).ConvertTo<EPosition>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyR(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetR(SVGComputedStyle::InitialR());
}

void StyleBuilderFunctions::applyInheritCSSPropertyR(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetR(state.ParentStyle()->SvgStyle().R());
}

void StyleBuilderFunctions::applyValueCSSPropertyR(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetR(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyResize(StyleResolverState& state) {
  state.Style()->SetResize(ComputedStyleInitialFunctions::InitialResize());
}

void StyleBuilderFunctions::applyInheritCSSPropertyResize(StyleResolverState& state) {
  state.Style()->SetResize(state.ParentStyle()->Resize());
}

void StyleBuilderFunctions::applyInitialCSSPropertyRight(StyleResolverState& state) {
  state.Style()->SetRight(ComputedStyleInitialFunctions::InitialRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRight(StyleResolverState& state) {
  state.Style()->SetRight(state.ParentStyle()->Right());
}

void StyleBuilderFunctions::applyValueCSSPropertyRight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetRight(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyRx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRx(SVGComputedStyle::InitialRx());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRx(state.ParentStyle()->SvgStyle().Rx());
}

void StyleBuilderFunctions::applyInitialCSSPropertyRy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRy(SVGComputedStyle::InitialRy());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRy(state.ParentStyle()->SvgStyle().Ry());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingBottom(StyleResolverState& state) {
  state.Style()->SetScrollPaddingBottom(ComputedStyleInitialFunctions::InitialScrollPaddingBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingBottom(StyleResolverState& state) {
  state.Style()->SetScrollPaddingBottom(state.ParentStyle()->ScrollPaddingBottom());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingLeft(StyleResolverState& state) {
  state.Style()->SetScrollPaddingLeft(ComputedStyleInitialFunctions::InitialScrollPaddingLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingLeft(StyleResolverState& state) {
  state.Style()->SetScrollPaddingLeft(state.ParentStyle()->ScrollPaddingLeft());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingRight(StyleResolverState& state) {
  state.Style()->SetScrollPaddingRight(ComputedStyleInitialFunctions::InitialScrollPaddingRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingRight(StyleResolverState& state) {
  state.Style()->SetScrollPaddingRight(state.ParentStyle()->ScrollPaddingRight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingTop(StyleResolverState& state) {
  state.Style()->SetScrollPaddingTop(ComputedStyleInitialFunctions::InitialScrollPaddingTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingTop(StyleResolverState& state) {
  state.Style()->SetScrollPaddingTop(state.ParentStyle()->ScrollPaddingTop());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginBottom(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginBottom(ComputedStyleInitialFunctions::InitialScrollSnapMarginBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginBottom(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginBottom(state.ParentStyle()->ScrollSnapMarginBottom());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginLeft(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginLeft(ComputedStyleInitialFunctions::InitialScrollSnapMarginLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginLeft(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginLeft(state.ParentStyle()->ScrollSnapMarginLeft());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginRight(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginRight(ComputedStyleInitialFunctions::InitialScrollSnapMarginRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginRight(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginRight(state.ParentStyle()->ScrollSnapMarginRight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginTop(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginTop(ComputedStyleInitialFunctions::InitialScrollSnapMarginTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginTop(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginTop(state.ParentStyle()->ScrollSnapMarginTop());
}

void StyleBuilderFunctions::applyInitialCSSPropertyShapeRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetShapeRendering(SVGComputedStyle::InitialShapeRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyShapeRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetShapeRendering(state.ParentStyle()->SvgStyle().ShapeRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertySpeak(StyleResolverState& state) {
  state.Style()->SetSpeak(ComputedStyleInitialFunctions::InitialSpeak());
}

void StyleBuilderFunctions::applyInheritCSSPropertySpeak(StyleResolverState& state) {
  state.Style()->SetSpeak(state.ParentStyle()->Speak());
}

void StyleBuilderFunctions::applyValueCSSPropertySpeak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetSpeak(ToCSSIdentifierValue(value).ConvertTo<ESpeak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyStopColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopColor(SVGComputedStyle::InitialStopColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStopColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopColor(state.ParentStyle()->SvgStyle().StopColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStopOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopOpacity(SVGComputedStyle::InitialStopOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStopOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopOpacity(state.ParentStyle()->SvgStyle().StopOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeDashoffset(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeDashOffset(SVGComputedStyle::InitialStrokeDashOffset());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeLinecap(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCapStyle(SVGComputedStyle::InitialCapStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeLinecap(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCapStyle(state.ParentStyle()->SvgStyle().CapStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeLinejoin(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetJoinStyle(SVGComputedStyle::InitialJoinStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeLinejoin(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetJoinStyle(state.ParentStyle()->SvgStyle().JoinStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeOpacity(SVGComputedStyle::InitialStrokeOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeOpacity(state.ParentStyle()->SvgStyle().StrokeOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeWidth(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeWidth(SVGComputedStyle::InitialStrokeWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeWidth(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeWidth(state.ParentStyle()->SvgStyle().StrokeWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTableLayout(StyleResolverState& state) {
  state.Style()->SetTableLayout(ComputedStyleInitialFunctions::InitialTableLayout());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTableLayout(StyleResolverState& state) {
  state.Style()->SetTableLayout(state.ParentStyle()->TableLayout());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAlign(StyleResolverState& state) {
  state.Style()->SetTextAlign(ComputedStyleInitialFunctions::InitialTextAlign());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAlign(StyleResolverState& state) {
  state.Style()->SetTextAlign(state.ParentStyle()->GetTextAlign());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAlignLast(StyleResolverState& state) {
  state.Style()->SetTextAlignLast(ComputedStyleInitialFunctions::InitialTextAlignLast());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAlignLast(StyleResolverState& state) {
  state.Style()->SetTextAlignLast(state.ParentStyle()->TextAlignLast());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAnchor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetTextAnchor(SVGComputedStyle::InitialTextAnchor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAnchor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetTextAnchor(state.ParentStyle()->SvgStyle().TextAnchor());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextCombineUpright(StyleResolverState& state) {
  state.Style()->SetTextCombine(ComputedStyleInitialFunctions::InitialTextCombine());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextCombineUpright(StyleResolverState& state) {
  state.Style()->SetTextCombine(state.ParentStyle()->TextCombine());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOverflow(StyleResolverState& state) {
  state.Style()->SetTextOverflow(ComputedStyleInitialFunctions::InitialTextOverflow());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOverflow(StyleResolverState& state) {
  state.Style()->SetTextOverflow(state.ParentStyle()->TextOverflow());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextTransform(StyleResolverState& state) {
  state.Style()->SetTextTransform(ComputedStyleInitialFunctions::InitialTextTransform());
  state.Style()->SetTextTransformIsInherited
(false);
}

state.Style()->SetTextTransformIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyTop(StyleResolverState& state) {
  state.Style()->SetTop(ComputedStyleInitialFunctions::InitialTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTop(StyleResolverState& state) {
  state.Style()->SetTop(state.ParentStyle()->Top());
}

void StyleBuilderFunctions::applyValueCSSPropertyTop(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTop(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTransformStyle(StyleResolverState& state) {
  state.Style()->SetTransformStyle3D(ComputedStyleInitialFunctions::InitialTransformStyle3D());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTransformStyle(StyleResolverState& state) {
  state.Style()->SetTransformStyle3D(state.ParentStyle()->TransformStyle3D());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyUserSelect(StyleResolverState& state) {
  state.Style()->SetUserSelect(ComputedStyleInitialFunctions::InitialUserSelect());
}

void StyleBuilderFunctions::applyInheritCSSPropertyUserSelect(StyleResolverState& state) {
  state.Style()->SetUserSelect(state.ParentStyle()->UserSelect());
}

void StyleBuilderFunctions::applyValueCSSPropertyUserSelect(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetUserSelect(ToCSSIdentifierValue(value).ConvertTo<EUserSelect>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyVectorEffect(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetVectorEffect(SVGComputedStyle::InitialVectorEffect());
}

void StyleBuilderFunctions::applyInheritCSSPropertyVectorEffect(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetVectorEffect(state.ParentStyle()->SvgStyle().VectorEffect());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyVerticalAlign(StyleResolverState& state) {
  state.Style()->SetVerticalAlign(ComputedStyleInitialFunctions::InitialVerticalAlign());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAppearance(StyleResolverState& state) {
  state.Style()->SetAppearance(ComputedStyleInitialFunctions::InitialAppearance());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAppearance(StyleResolverState& state) {
  state.Style()->SetAppearance(state.ParentStyle()->Appearance());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBorderImage(StyleResolverState& state) {
  state.Style()->SetBorderImage(ComputedStyleInitialFunctions::InitialBorderImage());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBorderImage(StyleResolverState& state) {
  state.Style()->SetBorderImage(state.ParentStyle()->BorderImage());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBorderVerticalSpacing(StyleResolverState& state) {
  state.Style()->SetVerticalBorderSpacing(ComputedStyleInitialFunctions::InitialVerticalBorderSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBorderVerticalSpacing(StyleResolverState& state) {
  state.Style()->SetVerticalBorderSpacing(state.ParentStyle()->VerticalBorderSpacing());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxAlign(StyleResolverState& state) {
  state.Style()->SetBoxAlign(ComputedStyleInitialFunctions::InitialBoxAlign());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxAlign(StyleResolverState& state) {
  state.Style()->SetBoxAlign(state.ParentStyle()->BoxAlign());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxDecorationBreak(StyleResolverState& state) {
  state.Style()->SetBoxDecorationBreak(ComputedStyleInitialFunctions::InitialBoxDecorationBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxDecorationBreak(StyleResolverState& state) {
  state.Style()->SetBoxDecorationBreak(state.ParentStyle()->BoxDecorationBreak());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxDirection(StyleResolverState& state) {
  state.Style()->SetBoxDirection(ComputedStyleInitialFunctions::InitialBoxDirection());
  state.Style()->SetBoxDirectionIsInherited
(false);
}

state.Style()->SetBoxDirectionIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxLines(StyleResolverState& state) {
  state.Style()->SetBoxLines(ComputedStyleInitialFunctions::InitialBoxLines());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxLines(StyleResolverState& state) {
  state.Style()->SetBoxLines(state.ParentStyle()->BoxLines());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxLines(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxLines(ToCSSIdentifierValue(value).ConvertTo<EBoxLines>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxOrient(StyleResolverState& state) {
  state.Style()->SetBoxOrient(ComputedStyleInitialFunctions::InitialBoxOrient());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxOrient(StyleResolverState& state) {
  state.Style()->SetBoxOrient(state.ParentStyle()->BoxOrient());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxPack(StyleResolverState& state) {
  state.Style()->SetBoxPack(ComputedStyleInitialFunctions::InitialBoxPack());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxPack(StyleResolverState& state) {
  state.Style()->SetBoxPack(state.ParentStyle()->BoxPack());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxPack(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxPack(ToCSSIdentifierValue(value).ConvertTo<EBoxPack>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitHyphenateCharacter(StyleResolverState& state) {
  state.Style()->SetHyphenationString(ComputedStyleInitialFunctions::InitialHyphenationString());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitHyphenateCharacter(StyleResolverState& state) {
  state.Style()->SetHyphenationString(state.ParentStyle()->HyphenationString());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(ComputedStyleInitialFunctions::InitialLineBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(state.ParentStyle()->GetLineBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitLineBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLineBreak(ToCSSIdentifierValue(value).ConvertTo<LineBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginAfterCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(ComputedStyleInitialFunctions::InitialMarginAfterCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginAfterCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(state.ParentStyle()->MarginAfterCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginBeforeCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(ComputedStyleInitialFunctions::InitialMarginBeforeCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginBeforeCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(state.ParentStyle()->MarginBeforeCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginBottomCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(ComputedStyleInitialFunctions::InitialMarginAfterCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginBottomCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(state.ParentStyle()->MarginAfterCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginTopCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(ComputedStyleInitialFunctions::InitialMarginBeforeCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginTopCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(state.ParentStyle()->MarginBeforeCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskBoxImageSource(StyleResolverState& state) {
  state.Style()->SetMaskBoxImageSource(ComputedStyleInitialFunctions::InitialMaskBoxImageSource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskBoxImageSource(StyleResolverState& state) {
  state.Style()->SetMaskBoxImageSource(state.ParentStyle()->MaskBoxImageSource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOriginX(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginX(ComputedStyleInitialFunctions::InitialPerspectiveOriginX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOriginX(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginX(state.ParentStyle()->PerspectiveOriginX());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOriginY(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginY(ComputedStyleInitialFunctions::InitialPerspectiveOriginY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOriginY(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginY(state.ParentStyle()->PerspectiveOriginY());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPrintColorAdjust(StyleResolverState& state) {
  state.Style()->SetPrintColorAdjust(ComputedStyleInitialFunctions::InitialPrintColorAdjust());
  state.Style()->SetPrintColorAdjustIsInherited
(false);
}

state.Style()->SetPrintColorAdjustIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitRtlOrdering(StyleResolverState& state) {
  state.Style()->SetRtlOrdering(ComputedStyleInitialFunctions::InitialRtlOrdering());
  state.Style()->SetRtlOrderingIsInherited
(false);
}

state.Style()->SetRtlOrderingIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitRubyPosition(StyleResolverState& state) {
  state.Style()->SetRubyPosition(ComputedStyleInitialFunctions::InitialRubyPosition());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitRubyPosition(StyleResolverState& state) {
  state.Style()->SetRubyPosition(state.ParentStyle()->GetRubyPosition());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTapHighlightColor(StyleResolverState& state) {
  state.Style()->SetTapHighlightColor(ComputedStyleInitialFunctions::InitialTapHighlightColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTapHighlightColor(StyleResolverState& state) {
  state.Style()->SetTapHighlightColor(state.ParentStyle()->TapHighlightColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextCombine(StyleResolverState& state) {
  state.Style()->SetTextCombine(ComputedStyleInitialFunctions::InitialTextCombine());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextCombine(StyleResolverState& state) {
  state.Style()->SetTextCombine(state.ParentStyle()->TextCombine());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextSecurity(StyleResolverState& state) {
  state.Style()->SetTextSecurity(ComputedStyleInitialFunctions::InitialTextSecurity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextSecurity(StyleResolverState& state) {
  state.Style()->SetTextSecurity(state.ParentStyle()->TextSecurity());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTransformOriginX(StyleResolverState& state) {
  state.Style()->SetTransformOriginX(ComputedStyleInitialFunctions::InitialTransformOriginX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTransformOriginX(StyleResolverState& state) {
  state.Style()->SetTransformOriginX(state.ParentStyle()->TransformOriginX());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTransformOriginY(StyleResolverState& state) {
  state.Style()->SetTransformOriginY(ComputedStyleInitialFunctions::InitialTransformOriginY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTransformOriginY(StyleResolverState& state) {
  state.Style()->SetTransformOriginY(state.ParentStyle()->TransformOriginY());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitUserDrag(StyleResolverState& state) {
  state.Style()->SetUserDrag(ComputedStyleInitialFunctions::InitialUserDrag());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitUserDrag(StyleResolverState& state) {
  state.Style()->SetUserDrag(state.ParentStyle()->UserDrag());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitUserDrag(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetUserDrag(ToCSSIdentifierValue(value).ConvertTo<EUserDrag>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitUserModify(StyleResolverState& state) {
  state.Style()->SetUserModify(ComputedStyleInitialFunctions::InitialUserModify());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitUserModify(StyleResolverState& state) {
  state.Style()->SetUserModify(state.ParentStyle()->UserModify());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWhiteSpace(StyleResolverState& state) {
  state.Style()->SetWhiteSpace(ComputedStyleInitialFunctions::InitialWhiteSpace());
  state.Style()->SetWhiteSpaceIsInherited
(false);
}

void StyleBuilderFunctions::applyValueCSSPropertyWhiteSpace(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWhiteSpace(ToCSSIdentifierValue(value).ConvertTo<EWhiteSpace>());

state.Style()->SetWhiteSpaceIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWidows(StyleResolverState& state) {
  state.Style()->SetWidows(ComputedStyleInitialFunctions::InitialWidows());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWidows(StyleResolverState& state) {
  state.Style()->SetWidows(state.ParentStyle()->Widows());
}

void StyleBuilderFunctions::applyValueCSSPropertyWidows(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWidows(ToCSSPrimitiveValue(value).ConvertTo<short>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWidth(StyleResolverState& state) {
  state.Style()->SetWidth(ComputedStyleInitialFunctions::InitialWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWidth(StyleResolverState& state) {
  state.Style()->SetWidth(state.ParentStyle()->Width());
}

void StyleBuilderFunctions::applyValueCSSPropertyWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWidth(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWordBreak(StyleResolverState& state) {
  state.Style()->SetWordBreak(ComputedStyleInitialFunctions::InitialWordBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWordBreak(StyleResolverState& state) {
  state.Style()->SetWordBreak(state.ParentStyle()->WordBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyWordBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWordBreak(ToCSSIdentifierValue(value).ConvertTo<EWordBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWordSpacing(StyleResolverState& state) {
  state.Style()->SetWordSpacing(ComputedStyleInitialFunctions::InitialWordSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWordSpacing(StyleResolverState& state) {
  state.Style()->SetWordSpacing(state.ParentStyle()->WordSpacing());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWordWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(ComputedStyleInitialFunctions::InitialOverflowWrap());
}