Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Echtzeit-Diff

Einheitlicher Diff

Zeilen einklappen

Änderungen hervorheben

Syntaxhervorhebung

Werkzeuge

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

Zeilen
Gesamt
Entfernt

Wörter
Gesamt
Entfernt

Um diese Funktion weiterhin zu nutzen, aktualisieren Sie auf Diffchecker Pro Preise anzeigen

568 Zeilen

Zeilen
Gesamt
Hinzugefügt

Wörter
Gesamt
Hinzugefügt

Um diese Funktion weiterhin zu nutzen, aktualisieren Sie auf Diffchecker Pro Preise anzeigen

558 Zeilen

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

Gespeicherte Diffs

Originaltext

Datei öffnen

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

Geänderter Text

Datei öffnen

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