Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

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

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

568 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

558 lines

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

Saved diffs

Original text

Open file

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

Changed text

Open file

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