Comparar texto

Encontre a diferença entre dois arquivos de texto

Diff em tempo real

Diff unificado

Recolher linhas

Destacar alterações

Realce de sintaxe

Ferramentas

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

Linhas
Total
Removido

Palavras
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

568 linhas

Linhas
Total
Adicionado

Palavras
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

558 linhas

// 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()

Diferenças salvas

Texto original

Abrir arquivo

// 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

Texto alterado

Abrir arquivo

#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());
}