टेक्स्ट की तुलना करें

दो टेक्स्ट फ़ाइलों के बीच अंतर ढूंढें

रियल-टाइम डिफ

यूनिफाइड डिफ

लाइनें संक्षिप्त करें

परिवर्तन हाइलाइट करें

सिंटैक्स हाइलाइटिंग

उपकरण

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

Untitled diff

Created 8 years agoDiff never expires

लाइनें
कुल
हटाया गया

शब्द
कुल
हटाया गया

इस सुविधा का उपयोग जारी रखने के लिए, अपग्रेड करें Diffchecker Pro मूल्य देखें

568 लाइनें

लाइनें
कुल
जोड़ा गया

शब्द
कुल
जोड़ा गया

इस सुविधा का उपयोग जारी रखने के लिए, अपग्रेड करें Diffchecker Pro मूल्य देखें

558 लाइनें

// Generated from template:

// templates/StyleBuilderFunctions.cpp.tmpl

// and input files:

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

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

#include "StyleBuilderFunctions.h"

#include "CSSValueKeywords.h"

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

#include "core/css/BasicShapeFunctions.h"

#include "core/css/CSSContentDistributionValue.h"

#include "core/css/CSSCustomIdentValue.h"

#include "core/css/CSSPrimitiveValueMappings.h"

#include "core/css/CSSURIValue.h"

#include "core/css/CSSValuePair.h"

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

#include "core/style/ComputedStyle.h"

namespace blink {

void StyleBuilderFunctions::applyInitialCSSPropertyDirection(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyDirection(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyFontKerning(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyFontKerning(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOrientation(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOrientation(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextRendering(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyTextRendering(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLocale(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLocale(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextOrientation(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextOrientation(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitWritingMode(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitWritingMode(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyWritingMode(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyWritingMode(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignContent(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignContent(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignmentBaseline(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignmentBaseline(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBackfaceVisibility(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBackfaceVisibility(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBaselineShift(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomStyle(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomStyle(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomWidth(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomWidth(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderCollapse(StyleResolverState& state) {

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

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

state.Style()->SetBorderCollapseIsInherited

(false);

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderCollapse(StyleResolverState& state) {

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

state.Style()->SetBorderCollapseIsInherited

(true);

}

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

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

state.Style()->SetBorderCollapseIsInherited

(false);

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageSource(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageSource(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftStyle(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftStyle(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftWidth(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftWidth(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightStyle(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightStyle(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightWidth(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightWidth(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopRightRadius(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopRightRadius(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopStyle(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopStyle(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopWidth(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopWidth(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBottom(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBottom(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBoxSizing(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBoxSizing(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakAfter(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakAfter(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakBefore(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakBefore(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakInside(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakInside(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyBufferedRendering(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyBufferedRendering(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyCaptionSide(StyleResolverState& state) {

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

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

state.Style()->SetCaptionSideIsInherited

(false);

}

void StyleBuilderFunctions::applyInheritCSSPropertyCaptionSide(StyleResolverState& state) {

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

state.Style()->SetCaptionSideIsInherited

(true);

}

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

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

state.Style()->SetCaptionSideIsInherited

(false);

}

void StyleBuilderFunctions::applyInitialCSSPropertyClear(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyClear(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyClipRule(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyClipRule(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorInterpolation(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyColorInterpolation(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorInterpolationFilters(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyColorInterpolationFilters(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorRendering(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyColorRendering(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnFill(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnFill(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnRuleStyle(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnRuleStyle(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyCx(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyCx(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyCy(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyCy(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyDisplay(StyleResolverState& state) {

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

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state) {

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyDominantBaseline(StyleResolverState& state) {

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

}

void StyleBuilderFunctions::applyInheritCSSPropertyDominantBaseline(StyleResolverState& state) {

void StyleBuilderFunctions::applyInheritCSSPropertyDom

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

}

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

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

}

void StyleBuilderFunctions::applyInitialCSSPropertyEmptyCells(StyleResolverState& state) {

state.Style()

सेव किए गए Diffs

ऑरिजनल टेक्स्ट

फ़ाइल खोलें

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

#include "StyleBuilderFunctions.h"

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

namespace blink {

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

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

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

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

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

}

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

}

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextEmphasisColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextEmphasisColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextEmphasisColor(color);
}

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

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

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextFillColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextFillColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextFillColor(color);
}

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

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextFillColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextFillColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkTextFillColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextStrokeColor(StyleResolverState& state) {
  StyleColor color = StyleColor::CurrentColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextStrokeColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextStrokeColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextStrokeColor(StyleResolverState& state) {
  // Visited link style can never explicitly inherit from parent visited link
  // style so no separate getters are needed.
  StyleColor color = state.ParentStyle()->TextStrokeColor();
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextStrokeColor(color);
  if (state.ApplyPropertyToVisitedLinkStyle())
    state.Style()->SetVisitedLinkTextStrokeColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextStrokeColor(StyleResolverState& state, const CSSValue& value)
{
  if (state.ApplyPropertyToRegularStyle())
    state.Style()->SetTextStrokeColor(StyleBuilderConverter::ConvertStyleColor(state, value));
  if (state.ApplyPropertyToVisitedLinkStyle()) {
    state.Style()->SetVisitedLinkTextStrokeColor(
        StyleBuilderConverter::ConvertStyleColor(state, value, true));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyCounterIncrement(StyleResolverState& state) {
  state.Style()->ClearIncrementDirectives();
}

void StyleBuilderFunctions::applyInheritCSSPropertyCounterIncrement(StyleResolverState& state) {
  const CounterDirectiveMap* parentMap = state.ParentStyle()->GetCounterDirectives();
  if (!parentMap)
    return;

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();
  DCHECK(!parentMap->IsEmpty());

typedef CounterDirectiveMap::const_iterator Iterator;
  Iterator end = parentMap->end();
  for (Iterator it = parentMap->begin(); it != end; ++it) {
    CounterDirectives& directives = map.insert(it->key, CounterDirectives()).stored_value->value;
    directives.InheritIncrement(it->value);
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyCounterIncrement(StyleResolverState& state, const CSSValue& value) {
  state.Style()->ClearIncrementDirectives();

if (!value.IsValueList()) {
    DCHECK(value.IsIdentifierValue());
    DCHECK_EQ(ToCSSIdentifierValue(value).GetValueID(), CSSValueNone);
    return;
  }

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();

const CSSValueList& list = ToCSSValueList(value);

for (size_t i = 0; i < list.length(); ++i) {
    const CSSValuePair& pair = ToCSSValuePair(list.Item(i));
    AtomicString identifier(ToCSSCustomIdentValue(pair.First()).Value());
    int value = ToCSSPrimitiveValue(pair.Second()).GetIntValue();
    CounterDirectives& directives =
        map.insert(identifier, CounterDirectives()).stored_value->value;
    directives.AddIncrementValue(value);
  }
  DCHECK(!map.IsEmpty());
}

void StyleBuilderFunctions::applyInitialCSSPropertyCounterReset(StyleResolverState& state) {
  state.Style()->ClearResetDirectives();
}

void StyleBuilderFunctions::applyInheritCSSPropertyCounterReset(StyleResolverState& state) {
  const CounterDirectiveMap* parentMap = state.ParentStyle()->GetCounterDirectives();
  if (!parentMap)
    return;

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();
  DCHECK(!parentMap->IsEmpty());

void StyleBuilderFunctions::applyValueCSSPropertyCounterReset(StyleResolverState& state, const CSSValue& value) {
  state.Style()->ClearResetDirectives();

if (!value.IsValueList()) {
    DCHECK(value.IsIdentifierValue());
    DCHECK_EQ(ToCSSIdentifierValue(value).GetValueID(), CSSValueNone);
    return;
  }

CounterDirectiveMap& map = state.Style()->AccessCounterDirectives();

const CSSValueList& list = ToCSSValueList(value);

for (size_t i = 0; i < list.length(); ++i) {
    const CSSValuePair& pair = ToCSSValuePair(list.Item(i));
    AtomicString identifier(ToCSSCustomIdentValue(pair.First()).Value());
    int value = ToCSSPrimitiveValue(pair.Second()).GetIntValue();
    CounterDirectives& directives =
        map.insert(identifier, CounterDirectives()).stored_value->value;
    directives.SetResetValue(value);
  }
  DCHECK(!map.IsEmpty());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundAttachment(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetAttachment(FillLayer::InitialFillAttachment(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearAttachment();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundAttachment(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsAttachmentSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetAttachment(currParent->Attachment());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearAttachment();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundAttachment(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillAttachment(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillAttachment(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearAttachment();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundBlendMode(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetBlendMode(FillLayer::InitialFillBlendMode(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearBlendMode();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundBlendMode(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsBlendModeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetBlendMode(currParent->BlendMode());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearBlendMode();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundBlendMode(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillBlendMode(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillBlendMode(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearBlendMode();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetClip(FillLayer::InitialFillClip(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearClip();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsClipSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetClip(currParent->Clip());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundClip(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillClip(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillClip(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetImage(FillLayer::InitialFillImage(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearImage();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsImageSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetImage(currParent->GetImage());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundImage(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillImage(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillImage(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetOrigin(FillLayer::InitialFillOrigin(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearOrigin();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsOriginSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetOrigin(currParent->Origin());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundOrigin(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillOrigin(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillOrigin(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetXPosition(FillLayer::InitialFillXPosition(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearXPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsXPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetXPosition(currParent->XPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundPositionX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillXPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillXPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetYPosition(FillLayer::InitialFillYPosition(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearYPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsYPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetYPosition(currParent->YPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundPositionY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillYPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillYPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetRepeatX(FillLayer::InitialFillRepeatX(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatX();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsRepeatXSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatX(currParent->RepeatX());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundRepeatX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatX(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatX(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetRepeatY(FillLayer::InitialFillRepeatY(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatY();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsRepeatYSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatY(currParent->RepeatY());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundRepeatY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatY(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatY(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyBackgroundSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
currChild->SetSize(FillLayer::InitialFillSize(kBackgroundFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearSize();
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackgroundSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->BackgroundLayers();
while (currParent && currParent->IsSizeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetSize(currParent->Size());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyBackgroundSize(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessBackgroundLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillSize(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillSize(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaskSourceType(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetMaskSourceType(FillLayer::InitialFillMaskSourceType(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearMaskSourceType();
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaskSourceType(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsMaskSourceTypeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetMaskSourceType(currParent->MaskSourceType());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearMaskSourceType();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyMaskSourceType(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillMaskSourceType(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillMaskSourceType(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearMaskSourceType();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetClip(FillLayer::InitialFillClip(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearClip();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskClip(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsClipSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetClip(currParent->Clip());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskClip(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillClip(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillClip(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearClip();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskComposite(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetComposite(FillLayer::InitialFillComposite(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearComposite();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskComposite(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsCompositeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetComposite(currParent->Composite());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearComposite();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskComposite(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillComposite(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillComposite(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearComposite();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetImage(FillLayer::InitialFillImage(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearImage();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskImage(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsImageSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetImage(currParent->GetImage());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskImage(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillImage(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillImage(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearImage();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetOrigin(FillLayer::InitialFillOrigin(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearOrigin();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskOrigin(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsOriginSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetOrigin(currParent->Origin());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskOrigin(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillOrigin(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillOrigin(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearOrigin();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetXPosition(FillLayer::InitialFillXPosition(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearXPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskPositionX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsXPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetXPosition(currParent->XPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskPositionX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillXPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillXPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearXPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetYPosition(FillLayer::InitialFillYPosition(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearYPosition();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskPositionY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsYPositionSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetYPosition(currParent->YPosition());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskPositionY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillYPosition(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillYPosition(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearYPosition();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetRepeatX(FillLayer::InitialFillRepeatX(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatX();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskRepeatX(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsRepeatXSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatX(currParent->RepeatX());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskRepeatX(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatX(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatX(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatX();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetRepeatY(FillLayer::InitialFillRepeatY(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearRepeatY();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskRepeatY(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsRepeatYSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetRepeatY(currParent->RepeatY());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskRepeatY(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillRepeatY(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillRepeatY(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearRepeatY();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
currChild->SetSize(FillLayer::InitialFillSize(kMaskFillLayer));
for (currChild = currChild->Next(); currChild; currChild = currChild->Next())
  currChild->ClearSize();
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskSize(StyleResolverState& state) {
FillLayer* currChild = &state.Style()->AccessMaskLayers();
FillLayer* prevChild = 0;
const FillLayer* currParent = &state.ParentStyle()->MaskLayers();
while (currParent && currParent->IsSizeSet()) {
    if (!currChild)
      currChild = prevChild->EnsureNext();
    currChild->SetSize(currParent->Size());
    prevChild = currChild;
    currChild = prevChild->Next();
    currParent = currParent->Next();
  }

while (currChild) {
    // Reset any remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitMaskSize(StyleResolverState& state, const CSSValue& value) {
  FillLayer* currChild = &state.Style()->AccessMaskLayers();
  FillLayer* prevChild = 0;
  if (value.IsValueList() && !value.IsImageSetValue()) {
    // Walk each value and put it into a layer, creating new layers as needed.
    const CSSValueList& valueList = ToCSSValueList(value);
    for (unsigned int i = 0; i < valueList.length(); i++) {
      if (!currChild)
        currChild = prevChild->EnsureNext();
      CSSToStyleMap::MapFillSize(state, currChild, valueList.Item(i));
      prevChild = currChild;
      currChild = currChild->Next();
    }
  } else {
    CSSToStyleMap::MapFillSize(state, currChild, value);
    currChild = currChild->Next();
  }
  while (currChild) {
    // Reset all remaining layers to not have the property set.
    currChild->ClearSize();
    currChild = currChild->Next();
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateColumns(StyleResolverState& state) {
  state.Style()->SetGridTemplateColumns(ComputedStyle::InitialGridTemplateColumns());
  state.Style()->SetNamedGridColumnLines(ComputedStyle::InitialNamedGridColumnLines());
  state.Style()->SetOrderedNamedGridColumnLines(ComputedStyle::InitialOrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumns(ComputedStyle::InitialGridAutoRepeatColumns());
  state.Style()->SetGridAutoRepeatColumnsInsertionPoint(ComputedStyle::InitialGridAutoRepeatColumnsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridColumnLines(ComputedStyle::InitialNamedGridColumnLines());
  state.Style()->SetAutoRepeatOrderedNamedGridColumnLines(ComputedStyle::InitialOrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumnsType(ComputedStyle::InitialGridAutoRepeatColumnsType());

}

void StyleBuilderFunctions::applyInheritCSSPropertyGridTemplateColumns(StyleResolverState& state) {
  state.Style()->SetGridTemplateColumns(state.ParentStyle()->GridTemplateColumns());
  state.Style()->SetNamedGridColumnLines(state.ParentStyle()->NamedGridColumnLines());
  state.Style()->SetOrderedNamedGridColumnLines(state.ParentStyle()->OrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumns(state.ParentStyle()->GridAutoRepeatColumns());
  state.Style()->SetGridAutoRepeatColumnsInsertionPoint(state.ParentStyle()->GridAutoRepeatColumnsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridColumnLines(state.ParentStyle()->AutoRepeatNamedGridColumnLines());
  state.Style()->SetAutoRepeatOrderedNamedGridColumnLines(state.ParentStyle()->AutoRepeatOrderedNamedGridColumnLines());
  state.Style()->SetGridAutoRepeatColumnsType(state.ParentStyle()->GridAutoRepeatColumnsType());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridTemplateColumns(StyleResolverState& state, const CSSValue& value) {
  Vector<GridTrackSize> trackSizes;
  Vector<GridTrackSize> autoRepeatTrackSizes;
  NamedGridLinesMap namedGridLines;
  OrderedNamedGridLines orderedNamedGridLines;
  NamedGridLinesMap autoRepeatNamedGridLines;
  OrderedNamedGridLines autoRepeatOrderedNamedGridLines;
  AutoRepeatType autoRepeatType = ComputedStyle::InitialGridAutoRepeatType();
  size_t autoRepeatInsertionPoint =
      ComputedStyle::InitialGridAutoRepeatInsertionPoint();
  StyleBuilderConverter::ConvertGridTrackList(
      value, trackSizes, namedGridLines, orderedNamedGridLines,
      autoRepeatTrackSizes, autoRepeatNamedGridLines,
      autoRepeatOrderedNamedGridLines, autoRepeatInsertionPoint,
      autoRepeatType, state);
  const NamedGridAreaMap& namedGridAreas = state.Style()->NamedGridArea();
  if (!namedGridAreas.IsEmpty()) {
    StyleBuilderConverter::CreateImplicitNamedGridLinesFromGridArea(
        namedGridAreas, namedGridLines, kForColumns);
  }
  state.Style()->SetGridTemplateColumns(trackSizes);
  state.Style()->SetNamedGridColumnLines(namedGridLines);
  state.Style()->SetOrderedNamedGridColumnLines(orderedNamedGridLines);
  state.Style()->SetGridAutoRepeatColumns(autoRepeatTrackSizes);
  state.Style()->SetGridAutoRepeatColumnsInsertionPoint(
      autoRepeatInsertionPoint);
  state.Style()->SetAutoRepeatNamedGridColumnLines(autoRepeatNamedGridLines);
  state.Style()->SetAutoRepeatOrderedNamedGridColumnLines(
      autoRepeatOrderedNamedGridLines);
  state.Style()->SetGridAutoRepeatColumnsType(autoRepeatType);
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateRows(StyleResolverState& state) {
  state.Style()->SetGridTemplateRows(ComputedStyle::InitialGridTemplateRows());
  state.Style()->SetNamedGridRowLines(ComputedStyle::InitialNamedGridRowLines());
  state.Style()->SetOrderedNamedGridRowLines(ComputedStyle::InitialOrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRows(ComputedStyle::InitialGridAutoRepeatRows());
  state.Style()->SetGridAutoRepeatRowsInsertionPoint(ComputedStyle::InitialGridAutoRepeatRowsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridRowLines(ComputedStyle::InitialNamedGridRowLines());
  state.Style()->SetAutoRepeatOrderedNamedGridRowLines(ComputedStyle::InitialOrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRowsType(ComputedStyle::InitialGridAutoRepeatRowsType());

}

void StyleBuilderFunctions::applyInheritCSSPropertyGridTemplateRows(StyleResolverState& state) {
  state.Style()->SetGridTemplateRows(state.ParentStyle()->GridTemplateRows());
  state.Style()->SetNamedGridRowLines(state.ParentStyle()->NamedGridRowLines());
  state.Style()->SetOrderedNamedGridRowLines(state.ParentStyle()->OrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRows(state.ParentStyle()->GridAutoRepeatRows());
  state.Style()->SetGridAutoRepeatRowsInsertionPoint(state.ParentStyle()->GridAutoRepeatRowsInsertionPoint());
  state.Style()->SetAutoRepeatNamedGridRowLines(state.ParentStyle()->AutoRepeatNamedGridRowLines());
  state.Style()->SetAutoRepeatOrderedNamedGridRowLines(state.ParentStyle()->AutoRepeatOrderedNamedGridRowLines());
  state.Style()->SetGridAutoRepeatRowsType(state.ParentStyle()->GridAutoRepeatRowsType());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridTemplateRows(StyleResolverState& state, const CSSValue& value) {
  Vector<GridTrackSize> trackSizes;
  Vector<GridTrackSize> autoRepeatTrackSizes;
  NamedGridLinesMap namedGridLines;
  OrderedNamedGridLines orderedNamedGridLines;
  NamedGridLinesMap autoRepeatNamedGridLines;
  OrderedNamedGridLines autoRepeatOrderedNamedGridLines;
  AutoRepeatType autoRepeatType = ComputedStyle::InitialGridAutoRepeatType();
  size_t autoRepeatInsertionPoint =
      ComputedStyle::InitialGridAutoRepeatInsertionPoint();
  StyleBuilderConverter::ConvertGridTrackList(
      value, trackSizes, namedGridLines, orderedNamedGridLines,
      autoRepeatTrackSizes, autoRepeatNamedGridLines,
      autoRepeatOrderedNamedGridLines, autoRepeatInsertionPoint,
      autoRepeatType, state);
  const NamedGridAreaMap& namedGridAreas = state.Style()->NamedGridArea();
  if (!namedGridAreas.IsEmpty()) {
    StyleBuilderConverter::CreateImplicitNamedGridLinesFromGridArea(
        namedGridAreas, namedGridLines, kForRows);
  }
  state.Style()->SetGridTemplateRows(trackSizes);
  state.Style()->SetNamedGridRowLines(namedGridLines);
  state.Style()->SetOrderedNamedGridRowLines(orderedNamedGridLines);
  state.Style()->SetGridAutoRepeatRows(autoRepeatTrackSizes);
  state.Style()->SetGridAutoRepeatRowsInsertionPoint(
      autoRepeatInsertionPoint);
  state.Style()->SetAutoRepeatNamedGridRowLines(autoRepeatNamedGridLines);
  state.Style()->SetAutoRepeatOrderedNamedGridRowLines(
      autoRepeatOrderedNamedGridLines);
  state.Style()->SetGridAutoRepeatRowsType(autoRepeatType);
}

void StyleBuilderFunctions::applyInitialCSSPropertyFill(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillPaint(
      SVGComputedStyle::InitialFillPaintType(),
      SVGComputedStyle::InitialFillPaintColor(),
      SVGComputedStyle::InitialFillPaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFill(StyleResolverState& state) {
  const SVGComputedStyle& svgParentStyle = state.ParentStyle()->SvgStyle();
  state.Style()->AccessSVGStyle().SetFillPaint(
      svgParentStyle.FillPaintType(),
      svgParentStyle.FillPaintColor(),
      svgParentStyle.FillPaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyFill(StyleResolverState& state, const CSSValue& value) {
  const CSSValue* localValue = &value;
  String url;
  if (value.IsValueList()) {
    const CSSValueList& list = ToCSSValueList(value);
    DCHECK_EQ(list.length(), 2U);
    url = ToCSSURIValue(list.Item(0)).Value();
    localValue = &list.Item(1);
  }

Color color;
  SVGPaintType paintType = SVG_PAINTTYPE_RGBCOLOR;
  if (localValue->IsURIValue()) {
    paintType = SVG_PAINTTYPE_URI;
    url = ToCSSURIValue(localValue)->Value();
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueNone) {
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_NONE : SVG_PAINTTYPE_URI_NONE;
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueCurrentcolor) {
    color = state.Style()->GetColor();
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_CURRENTCOLOR
    	                      : SVG_PAINTTYPE_URI_CURRENTCOLOR;
  } else {
    color = StyleBuilderConverter::ConvertColor(state, *localValue);
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_RGBCOLOR
    	                      : SVG_PAINTTYPE_URI_RGBCOLOR;
  }
  state.Style()->AccessSVGStyle().SetFillPaint(paintType, color, url,
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStroke(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokePaint(
      SVGComputedStyle::InitialStrokePaintType(),
      SVGComputedStyle::InitialStrokePaintColor(),
      SVGComputedStyle::InitialStrokePaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStroke(StyleResolverState& state) {
  const SVGComputedStyle& svgParentStyle = state.ParentStyle()->SvgStyle();
  state.Style()->AccessSVGStyle().SetStrokePaint(
      svgParentStyle.StrokePaintType(),
      svgParentStyle.StrokePaintColor(),
      svgParentStyle.StrokePaintUri(),
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyStroke(StyleResolverState& state, const CSSValue& value) {
  const CSSValue* localValue = &value;
  String url;
  if (value.IsValueList()) {
    const CSSValueList& list = ToCSSValueList(value);
    DCHECK_EQ(list.length(), 2U);
    url = ToCSSURIValue(list.Item(0)).Value();
    localValue = &list.Item(1);
  }

Color color;
  SVGPaintType paintType = SVG_PAINTTYPE_RGBCOLOR;
  if (localValue->IsURIValue()) {
    paintType = SVG_PAINTTYPE_URI;
    url = ToCSSURIValue(localValue)->Value();
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueNone) {
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_NONE : SVG_PAINTTYPE_URI_NONE;
  } else if (localValue->IsIdentifierValue() &&
             ToCSSIdentifierValue(localValue)->GetValueID() == CSSValueCurrentcolor) {
    color = state.Style()->GetColor();
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_CURRENTCOLOR
    	                      : SVG_PAINTTYPE_URI_CURRENTCOLOR;
  } else {
    color = StyleBuilderConverter::ConvertColor(state, *localValue);
    paintType = url.IsEmpty() ? SVG_PAINTTYPE_RGBCOLOR
    	                      : SVG_PAINTTYPE_URI_RGBCOLOR;
  }
  state.Style()->AccessSVGStyle().SetStrokePaint(paintType, color, url,
      state.ApplyPropertyToRegularStyle(),
      state.ApplyPropertyToVisitedLinkStyle());
}

} // namespace blink

परिवर्तित टेक्स्ट

फ़ाइल खोलें

#include "StyleBuilderFunctions.h"

namespace blink {

void StyleBuilderFunctions::applyInitialCSSPropertyDirection(StyleResolverState& state) {
  state.Style()->SetDirection(ComputedStyleInitialFunctions::InitialDirection());
}

void StyleBuilderFunctions::applyInheritCSSPropertyDirection(StyleResolverState& state) {
  state.Style()->SetDirection(state.ParentStyle()->Direction());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFontKerning(StyleResolverState& state) {
  state.GetFontBuilder().SetKerning(FontBuilder::InitialKerning());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFontKerning(StyleResolverState& state) {
  state.GetFontBuilder().SetKerning(state.ParentFontDescription().GetKerning());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(ComputedStyleInitialFunctions::InitialTextOrientation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextRendering(StyleResolverState& state) {
  state.GetFontBuilder().SetTextRendering(FontBuilder::InitialTextRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextRendering(StyleResolverState& state) {
  state.GetFontBuilder().SetTextRendering(state.ParentFontDescription().TextRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {
  state.GetFontBuilder().SetFontSmoothing(FontBuilder::InitialFontSmoothing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitFontSmoothing(StyleResolverState& state) {
  state.GetFontBuilder().SetFontSmoothing(state.ParentFontDescription().FontSmoothing());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLocale(StyleResolverState& state) {
  state.GetFontBuilder().SetLocale(FontBuilder::InitialLocale());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLocale(StyleResolverState& state) {
  state.GetFontBuilder().SetLocale(state.ParentFontDescription().Locale());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(ComputedStyleInitialFunctions::InitialTextOrientation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextOrientation(StyleResolverState& state) {
  state.Style()->SetTextOrientation(state.ParentStyle()->GetTextOrientation());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(ComputedStyleInitialFunctions::InitialWritingMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(ComputedStyleInitialFunctions::InitialWritingMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWritingMode(StyleResolverState& state) {
  state.Style()->SetWritingMode(state.ParentStyle()->GetWritingMode());
}

void StyleBuilderFunctions::applyInitialCSSPropertyAlignContent(StyleResolverState& state) {
  state.Style()->SetAlignContent(ComputedStyleInitialFunctions::InitialAlignContent());
}

void StyleBuilderFunctions::applyInheritCSSPropertyAlignContent(StyleResolverState& state) {
  state.Style()->SetAlignContent(state.ParentStyle()->AlignContent());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBackfaceVisibility(StyleResolverState& state) {
  state.Style()->SetBackfaceVisibility(ComputedStyleInitialFunctions::InitialBackfaceVisibility());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBackfaceVisibility(StyleResolverState& state) {
  state.Style()->SetBackfaceVisibility(state.ParentStyle()->BackfaceVisibility());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBaselineShift(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetBaselineShift(SVGComputedStyle::InitialBaselineShift());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomLeftRadius(ComputedStyleInitialFunctions::InitialBorderBottomLeftRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomLeftRadius(state.ParentStyle()->BorderBottomLeftRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomRightRadius(ComputedStyleInitialFunctions::InitialBorderBottomRightRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderBottomRightRadius(state.ParentStyle()->BorderBottomRightRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomStyle(StyleResolverState& state) {
  state.Style()->SetBorderBottomStyle(ComputedStyleInitialFunctions::InitialBorderBottomStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomStyle(StyleResolverState& state) {
  state.Style()->SetBorderBottomStyle(state.ParentStyle()->BorderBottomStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderBottomWidth(StyleResolverState& state) {
  state.Style()->SetBorderBottomWidth(ComputedStyleInitialFunctions::InitialBorderBottomWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderBottomWidth(StyleResolverState& state) {
  state.Style()->SetBorderBottomWidth(state.ParentStyle()->BorderBottomWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderCollapse(StyleResolverState& state) {
  state.Style()->SetBorderCollapse(ComputedStyleInitialFunctions::InitialBorderCollapse());
  state.Style()->SetBorderCollapseIsInherited
(false);
}

state.Style()->SetBorderCollapseIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderImageSource(StyleResolverState& state) {
  state.Style()->SetBorderImageSource(ComputedStyleInitialFunctions::InitialBorderImageSource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderImageSource(StyleResolverState& state) {
  state.Style()->SetBorderImageSource(state.ParentStyle()->BorderImageSource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftStyle(StyleResolverState& state) {
  state.Style()->SetBorderLeftStyle(ComputedStyleInitialFunctions::InitialBorderLeftStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftStyle(StyleResolverState& state) {
  state.Style()->SetBorderLeftStyle(state.ParentStyle()->BorderLeftStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderLeftWidth(StyleResolverState& state) {
  state.Style()->SetBorderLeftWidth(ComputedStyleInitialFunctions::InitialBorderLeftWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderLeftWidth(StyleResolverState& state) {
  state.Style()->SetBorderLeftWidth(state.ParentStyle()->BorderLeftWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightStyle(StyleResolverState& state) {
  state.Style()->SetBorderRightStyle(ComputedStyleInitialFunctions::InitialBorderRightStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightStyle(StyleResolverState& state) {
  state.Style()->SetBorderRightStyle(state.ParentStyle()->BorderRightStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderRightWidth(StyleResolverState& state) {
  state.Style()->SetBorderRightWidth(ComputedStyleInitialFunctions::InitialBorderRightWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderRightWidth(StyleResolverState& state) {
  state.Style()->SetBorderRightWidth(state.ParentStyle()->BorderRightWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopLeftRadius(ComputedStyleInitialFunctions::InitialBorderTopLeftRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopLeftRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopLeftRadius(state.ParentStyle()->BorderTopLeftRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopRightRadius(ComputedStyleInitialFunctions::InitialBorderTopRightRadius());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopRightRadius(StyleResolverState& state) {
  state.Style()->SetBorderTopRightRadius(state.ParentStyle()->BorderTopRightRadius());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopStyle(StyleResolverState& state) {
  state.Style()->SetBorderTopStyle(ComputedStyleInitialFunctions::InitialBorderTopStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopStyle(StyleResolverState& state) {
  state.Style()->SetBorderTopStyle(state.ParentStyle()->BorderTopStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBorderTopWidth(StyleResolverState& state) {
  state.Style()->SetBorderTopWidth(ComputedStyleInitialFunctions::InitialBorderTopWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBorderTopWidth(StyleResolverState& state) {
  state.Style()->SetBorderTopWidth(state.ParentStyle()->BorderTopWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyBottom(StyleResolverState& state) {
  state.Style()->SetBottom(ComputedStyleInitialFunctions::InitialBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBottom(StyleResolverState& state) {
  state.Style()->SetBottom(state.ParentStyle()->Bottom());
}

void StyleBuilderFunctions::applyValueCSSPropertyBottom(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBottom(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyBoxSizing(StyleResolverState& state) {
  state.Style()->SetBoxSizing(ComputedStyleInitialFunctions::InitialBoxSizing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBoxSizing(StyleResolverState& state) {
  state.Style()->SetBoxSizing(state.ParentStyle()->BoxSizing());
}

void StyleBuilderFunctions::applyValueCSSPropertyBoxSizing(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxSizing(ToCSSIdentifierValue(value).ConvertTo<EBoxSizing>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakAfter(StyleResolverState& state) {
  state.Style()->SetBreakAfter(ComputedStyleInitialFunctions::InitialBreakAfter());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakAfter(StyleResolverState& state) {
  state.Style()->SetBreakAfter(state.ParentStyle()->BreakAfter());
}

void StyleBuilderFunctions::applyValueCSSPropertyBreakAfter(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBreakAfter(ToCSSIdentifierValue(value).ConvertTo<EBreakBetween>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakBefore(StyleResolverState& state) {
  state.Style()->SetBreakBefore(ComputedStyleInitialFunctions::InitialBreakBefore());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakBefore(StyleResolverState& state) {
  state.Style()->SetBreakBefore(state.ParentStyle()->BreakBefore());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyBreakInside(StyleResolverState& state) {
  state.Style()->SetBreakInside(ComputedStyleInitialFunctions::InitialBreakInside());
}

void StyleBuilderFunctions::applyInheritCSSPropertyBreakInside(StyleResolverState& state) {
  state.Style()->SetBreakInside(state.ParentStyle()->BreakInside());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyCaptionSide(StyleResolverState& state) {
  state.Style()->SetCaptionSide(ComputedStyleInitialFunctions::InitialCaptionSide());
  state.Style()->SetCaptionSideIsInherited
(false);
}

state.Style()->SetCaptionSideIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyClear(StyleResolverState& state) {
  state.Style()->SetClear(ComputedStyleInitialFunctions::InitialClear());
}

void StyleBuilderFunctions::applyInheritCSSPropertyClear(StyleResolverState& state) {
  state.Style()->SetClear(state.ParentStyle()->Clear());
}

void StyleBuilderFunctions::applyValueCSSPropertyClear(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetClear(ToCSSIdentifierValue(value).ConvertTo<EClear>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyClipRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetClipRule(SVGComputedStyle::InitialClipRule());
}

void StyleBuilderFunctions::applyInheritCSSPropertyClipRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetClipRule(state.ParentStyle()->SvgStyle().ClipRule());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyColorRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorRendering(SVGComputedStyle::InitialColorRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColorRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetColorRendering(state.ParentStyle()->SvgStyle().ColorRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnFill(StyleResolverState& state) {
  state.Style()->SetColumnFill(ComputedStyleInitialFunctions::InitialColumnFill());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnFill(StyleResolverState& state) {
  state.Style()->SetColumnFill(state.ParentStyle()->GetColumnFill());
}

void StyleBuilderFunctions::applyValueCSSPropertyColumnFill(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetColumnFill(ToCSSIdentifierValue(value).ConvertTo<EColumnFill>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyColumnRuleStyle(StyleResolverState& state) {
  state.Style()->SetColumnRuleStyle(ComputedStyleInitialFunctions::InitialColumnRuleStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyColumnRuleStyle(StyleResolverState& state) {
  state.Style()->SetColumnRuleStyle(state.ParentStyle()->ColumnRuleStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyCx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCx(SVGComputedStyle::InitialCx());
}

void StyleBuilderFunctions::applyInheritCSSPropertyCx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCx(state.ParentStyle()->SvgStyle().Cx());
}

void StyleBuilderFunctions::applyValueCSSPropertyCx(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetCx(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyCy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCy(SVGComputedStyle::InitialCy());
}

void StyleBuilderFunctions::applyInheritCSSPropertyCy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCy(state.ParentStyle()->SvgStyle().Cy());
}

void StyleBuilderFunctions::applyValueCSSPropertyCy(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetCy(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyDisplay(StyleResolverState& state) {
  state.Style()->SetDisplay(ComputedStyleInitialFunctions::InitialDisplay());
}

void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state) {
  state.Style()->SetDisplay(state.ParentStyle()->Display());
}

void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetDisplay(ToCSSIdentifierValue(value).ConvertTo<EDisplay>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyDominantBaseline(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetDominantBaseline(SVGComputedStyle::InitialDominantBaseline());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyEmptyCells(StyleResolverState& state) {
  state.Style()->SetEmptyCells(ComputedStyleInitialFunctions::InitialEmptyCells());
  state.Style()->SetEmptyCellsIsInherited
(false);
}

void StyleBuilderFunctions::applyValueCSSPropertyEmptyCells(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetEmptyCells(ToCSSIdentifierValue(value).ConvertTo<EEmptyCells>());

state.Style()->SetEmptyCellsIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyFillOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillOpacity(SVGComputedStyle::InitialFillOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFillOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillOpacity(state.ParentStyle()->SvgStyle().FillOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFillRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillRule(SVGComputedStyle::InitialFillRule());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFillRule(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFillRule(state.ParentStyle()->SvgStyle().FillRule());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexDirection(StyleResolverState& state) {
  state.Style()->SetFlexDirection(ComputedStyleInitialFunctions::InitialFlexDirection());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexDirection(StyleResolverState& state) {
  state.Style()->SetFlexDirection(state.ParentStyle()->FlexDirection());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexGrow(StyleResolverState& state) {
  state.Style()->SetFlexGrow(ComputedStyleInitialFunctions::InitialFlexGrow());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexGrow(StyleResolverState& state) {
  state.Style()->SetFlexGrow(state.ParentStyle()->FlexGrow());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexGrow(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexGrow(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexShrink(StyleResolverState& state) {
  state.Style()->SetFlexShrink(ComputedStyleInitialFunctions::InitialFlexShrink());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexShrink(StyleResolverState& state) {
  state.Style()->SetFlexShrink(state.ParentStyle()->FlexShrink());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexShrink(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexShrink(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFlexWrap(StyleResolverState& state) {
  state.Style()->SetFlexWrap(ComputedStyleInitialFunctions::InitialFlexWrap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFlexWrap(StyleResolverState& state) {
  state.Style()->SetFlexWrap(state.ParentStyle()->FlexWrap());
}

void StyleBuilderFunctions::applyValueCSSPropertyFlexWrap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFlexWrap(ToCSSIdentifierValue(value).ConvertTo<EFlexWrap>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFloat(StyleResolverState& state) {
  state.Style()->SetFloating(ComputedStyleInitialFunctions::InitialFloating());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloat(StyleResolverState& state) {
  state.Style()->SetFloating(state.ParentStyle()->Floating());
}

void StyleBuilderFunctions::applyValueCSSPropertyFloat(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetFloating(ToCSSIdentifierValue(value).ConvertTo<EFloat>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyFloodColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodColor(SVGComputedStyle::InitialFloodColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloodColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodColor(state.ParentStyle()->SvgStyle().FloodColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyFloodOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodOpacity(SVGComputedStyle::InitialFloodOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyFloodOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetFloodOpacity(state.ParentStyle()->SvgStyle().FloodOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridAutoColumns(StyleResolverState& state) {
  state.Style()->SetGridAutoColumns(ComputedStyleInitialFunctions::InitialGridAutoColumns());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridAutoColumns(StyleResolverState& state) {
  state.Style()->SetGridAutoColumns(state.ParentStyle()->GridAutoColumns());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridAutoRows(StyleResolverState& state) {
  state.Style()->SetGridAutoRows(ComputedStyleInitialFunctions::InitialGridAutoRows());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridAutoRows(StyleResolverState& state) {
  state.Style()->SetGridAutoRows(state.ParentStyle()->GridAutoRows());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnEnd(StyleResolverState& state) {
  state.Style()->SetGridColumnEnd(ComputedStyleInitialFunctions::InitialGridColumnEnd());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnEnd(StyleResolverState& state) {
  state.Style()->SetGridColumnEnd(state.ParentStyle()->GridColumnEnd());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnGap(StyleResolverState& state) {
  state.Style()->SetGridColumnGap(ComputedStyleInitialFunctions::InitialGridColumnGap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnGap(StyleResolverState& state) {
  state.Style()->SetGridColumnGap(state.ParentStyle()->GridColumnGap());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridColumnStart(StyleResolverState& state) {
  state.Style()->SetGridColumnStart(ComputedStyleInitialFunctions::InitialGridColumnStart());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridColumnStart(StyleResolverState& state) {
  state.Style()->SetGridColumnStart(state.ParentStyle()->GridColumnStart());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowEnd(StyleResolverState& state) {
  state.Style()->SetGridRowEnd(ComputedStyleInitialFunctions::InitialGridRowEnd());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowEnd(StyleResolverState& state) {
  state.Style()->SetGridRowEnd(state.ParentStyle()->GridRowEnd());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowGap(StyleResolverState& state) {
  state.Style()->SetGridRowGap(ComputedStyleInitialFunctions::InitialGridRowGap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowGap(StyleResolverState& state) {
  state.Style()->SetGridRowGap(state.ParentStyle()->GridRowGap());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridRowGap(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetGridRowGap(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridRowStart(StyleResolverState& state) {
  state.Style()->SetGridRowStart(ComputedStyleInitialFunctions::InitialGridRowStart());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridRowStart(StyleResolverState& state) {
  state.Style()->SetGridRowStart(state.ParentStyle()->GridRowStart());
}

void StyleBuilderFunctions::applyInitialCSSPropertyHeight(StyleResolverState& state) {
  state.Style()->SetHeight(ComputedStyleInitialFunctions::InitialHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyHeight(StyleResolverState& state) {
  state.Style()->SetHeight(state.ParentStyle()->Height());
}

void StyleBuilderFunctions::applyValueCSSPropertyHeight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetHeight(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyImageRendering(StyleResolverState& state) {
  state.Style()->SetImageRendering(ComputedStyleInitialFunctions::InitialImageRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyImageRendering(StyleResolverState& state) {
  state.Style()->SetImageRendering(state.ParentStyle()->ImageRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyIsolation(StyleResolverState& state) {
  state.Style()->SetIsolation(ComputedStyleInitialFunctions::InitialIsolation());
}

void StyleBuilderFunctions::applyInheritCSSPropertyIsolation(StyleResolverState& state) {
  state.Style()->SetIsolation(state.ParentStyle()->Isolation());
}

void StyleBuilderFunctions::applyValueCSSPropertyIsolation(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetIsolation(ToCSSIdentifierValue(value).ConvertTo<EIsolation>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyJustifyContent(StyleResolverState& state) {
  state.Style()->SetJustifyContent(ComputedStyleInitialFunctions::InitialJustifyContent());
}

void StyleBuilderFunctions::applyInheritCSSPropertyJustifyContent(StyleResolverState& state) {
  state.Style()->SetJustifyContent(state.ParentStyle()->JustifyContent());
}

void StyleBuilderFunctions::applyInitialCSSPropertyLeft(StyleResolverState& state) {
  state.Style()->SetLeft(ComputedStyleInitialFunctions::InitialLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLeft(StyleResolverState& state) {
  state.Style()->SetLeft(state.ParentStyle()->Left());
}

void StyleBuilderFunctions::applyValueCSSPropertyLeft(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLeft(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyLetterSpacing(StyleResolverState& state) {
  state.Style()->SetLetterSpacing(ComputedStyleInitialFunctions::InitialLetterSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLetterSpacing(StyleResolverState& state) {
  state.Style()->SetLetterSpacing(state.ParentStyle()->LetterSpacing());
}

void StyleBuilderFunctions::applyInitialCSSPropertyLightingColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetLightingColor(SVGComputedStyle::InitialLightingColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLightingColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetLightingColor(state.ParentStyle()->SvgStyle().LightingColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(ComputedStyleInitialFunctions::InitialLineBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(state.ParentStyle()->GetLineBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyLineBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLineBreak(ToCSSIdentifierValue(value).ConvertTo<LineBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyListStyleImage(StyleResolverState& state) {
  state.Style()->SetListStyleImage(ComputedStyleInitialFunctions::InitialListStyleImage());
}

void StyleBuilderFunctions::applyInheritCSSPropertyListStyleImage(StyleResolverState& state) {
  state.Style()->SetListStyleImage(state.ParentStyle()->ListStyleImage());
}

void StyleBuilderFunctions::applyInitialCSSPropertyListStylePosition(StyleResolverState& state) {
  state.Style()->SetListStylePosition(ComputedStyleInitialFunctions::InitialListStylePosition());
  state.Style()->SetListStylePositionIsInherited
(false);
}

state.Style()->SetListStylePositionIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyListStyleType(StyleResolverState& state) {
  state.Style()->SetListStyleType(ComputedStyleInitialFunctions::InitialListStyleType());
}

void StyleBuilderFunctions::applyInheritCSSPropertyListStyleType(StyleResolverState& state) {
  state.Style()->SetListStyleType(state.ParentStyle()->ListStyleType());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerEnd(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerEndResource(SVGComputedStyle::InitialMarkerEndResource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerMid(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerMidResource(SVGComputedStyle::InitialMarkerMidResource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMarkerStart(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMarkerStartResource(SVGComputedStyle::InitialMarkerStartResource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaskType(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMaskType(SVGComputedStyle::InitialMaskType());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaskType(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetMaskType(state.ParentStyle()->SvgStyle().MaskType());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyMaxHeight(StyleResolverState& state) {
  state.Style()->SetMaxHeight(ComputedStyleInitialFunctions::InitialMaxHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaxHeight(StyleResolverState& state) {
  state.Style()->SetMaxHeight(state.ParentStyle()->MaxHeight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMaxWidth(StyleResolverState& state) {
  state.Style()->SetMaxWidth(ComputedStyleInitialFunctions::InitialMaxWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMaxWidth(StyleResolverState& state) {
  state.Style()->SetMaxWidth(state.ParentStyle()->MaxWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMinHeight(StyleResolverState& state) {
  state.Style()->SetMinHeight(ComputedStyleInitialFunctions::InitialMinHeight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMinHeight(StyleResolverState& state) {
  state.Style()->SetMinHeight(state.ParentStyle()->MinHeight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyMinWidth(StyleResolverState& state) {
  state.Style()->SetMinWidth(ComputedStyleInitialFunctions::InitialMinWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMinWidth(StyleResolverState& state) {
  state.Style()->SetMinWidth(state.ParentStyle()->MinWidth());
}

void StyleBuilderFunctions::applyValueCSSPropertyMinWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetMinWidth(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyMixBlendMode(StyleResolverState& state) {
  state.Style()->SetBlendMode(ComputedStyleInitialFunctions::InitialBlendMode());
}

void StyleBuilderFunctions::applyInheritCSSPropertyMixBlendMode(StyleResolverState& state) {
  state.Style()->SetBlendMode(state.ParentStyle()->BlendMode());
}

void StyleBuilderFunctions::applyValueCSSPropertyMixBlendMode(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBlendMode(ToCSSIdentifierValue(value).ConvertTo<WebBlendMode>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyObjectFit(StyleResolverState& state) {
  state.Style()->SetObjectFit(ComputedStyleInitialFunctions::InitialObjectFit());
}

void StyleBuilderFunctions::applyInheritCSSPropertyObjectFit(StyleResolverState& state) {
  state.Style()->SetObjectFit(state.ParentStyle()->GetObjectFit());
}

void StyleBuilderFunctions::applyValueCSSPropertyObjectFit(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetObjectFit(ToCSSIdentifierValue(value).ConvertTo<EObjectFit>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOpacity(StyleResolverState& state) {
  state.Style()->SetOpacity(ComputedStyleInitialFunctions::InitialOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOpacity(StyleResolverState& state) {
  state.Style()->SetOpacity(state.ParentStyle()->Opacity());
}

void StyleBuilderFunctions::applyValueCSSPropertyOpacity(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOpacity(ToCSSPrimitiveValue(value).ConvertTo<float>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyOrphans(StyleResolverState& state) {
  state.Style()->SetOrphans(ComputedStyleInitialFunctions::InitialOrphans());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOrphans(StyleResolverState& state) {
  state.Style()->SetOrphans(state.ParentStyle()->Orphans());
}

void StyleBuilderFunctions::applyValueCSSPropertyOrphans(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOrphans(ToCSSPrimitiveValue(value).ConvertTo<short>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(ComputedStyleInitialFunctions::InitialOverflowWrap());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(state.ParentStyle()->OverflowWrap());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowX(StyleResolverState& state) {
  state.Style()->SetOverflowX(ComputedStyleInitialFunctions::InitialOverflowX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowX(StyleResolverState& state) {
  state.Style()->SetOverflowX(state.ParentStyle()->OverflowX());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverflowX(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowX(ToCSSIdentifierValue(value).ConvertTo<EOverflow>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverflowY(StyleResolverState& state) {
  state.Style()->SetOverflowY(ComputedStyleInitialFunctions::InitialOverflowY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverflowY(StyleResolverState& state) {
  state.Style()->SetOverflowY(state.ParentStyle()->OverflowY());
}

void StyleBuilderFunctions::applyValueCSSPropertyOverflowY(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetOverflowY(ToCSSIdentifierValue(value).ConvertTo<EOverflow>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverscrollBehaviorX(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorX(ComputedStyleInitialFunctions::InitialOverscrollBehaviorX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverscrollBehaviorX(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorX(state.ParentStyle()->OverscrollBehaviorX());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyOverscrollBehaviorY(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorY(ComputedStyleInitialFunctions::InitialOverscrollBehaviorY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOverscrollBehaviorY(StyleResolverState& state) {
  state.Style()->SetOverscrollBehaviorY(state.ParentStyle()->OverscrollBehaviorY());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyPointerEvents(StyleResolverState& state) {
  state.Style()->SetPointerEvents(ComputedStyleInitialFunctions::InitialPointerEvents());
  state.Style()->SetPointerEventsIsInherited
(false);
}

state.Style()->SetPointerEventsIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyPosition(StyleResolverState& state) {
  state.Style()->SetPosition(ComputedStyleInitialFunctions::InitialPosition());
}

void StyleBuilderFunctions::applyValueCSSPropertyPosition(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetPosition(ToCSSIdentifierValue(value).ConvertTo<EPosition>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyR(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetR(SVGComputedStyle::InitialR());
}

void StyleBuilderFunctions::applyInheritCSSPropertyR(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetR(state.ParentStyle()->SvgStyle().R());
}

void StyleBuilderFunctions::applyValueCSSPropertyR(StyleResolverState& state, const CSSValue& value) {
  state.Style()->AccessSVGStyle().SetR(StyleBuilderConverter::ConvertLength(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyResize(StyleResolverState& state) {
  state.Style()->SetResize(ComputedStyleInitialFunctions::InitialResize());
}

void StyleBuilderFunctions::applyInheritCSSPropertyResize(StyleResolverState& state) {
  state.Style()->SetResize(state.ParentStyle()->Resize());
}

void StyleBuilderFunctions::applyInitialCSSPropertyRight(StyleResolverState& state) {
  state.Style()->SetRight(ComputedStyleInitialFunctions::InitialRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRight(StyleResolverState& state) {
  state.Style()->SetRight(state.ParentStyle()->Right());
}

void StyleBuilderFunctions::applyValueCSSPropertyRight(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetRight(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyRx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRx(SVGComputedStyle::InitialRx());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRx(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRx(state.ParentStyle()->SvgStyle().Rx());
}

void StyleBuilderFunctions::applyInitialCSSPropertyRy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRy(SVGComputedStyle::InitialRy());
}

void StyleBuilderFunctions::applyInheritCSSPropertyRy(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetRy(state.ParentStyle()->SvgStyle().Ry());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingBottom(StyleResolverState& state) {
  state.Style()->SetScrollPaddingBottom(ComputedStyleInitialFunctions::InitialScrollPaddingBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingBottom(StyleResolverState& state) {
  state.Style()->SetScrollPaddingBottom(state.ParentStyle()->ScrollPaddingBottom());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingLeft(StyleResolverState& state) {
  state.Style()->SetScrollPaddingLeft(ComputedStyleInitialFunctions::InitialScrollPaddingLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingLeft(StyleResolverState& state) {
  state.Style()->SetScrollPaddingLeft(state.ParentStyle()->ScrollPaddingLeft());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingRight(StyleResolverState& state) {
  state.Style()->SetScrollPaddingRight(ComputedStyleInitialFunctions::InitialScrollPaddingRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingRight(StyleResolverState& state) {
  state.Style()->SetScrollPaddingRight(state.ParentStyle()->ScrollPaddingRight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollPaddingTop(StyleResolverState& state) {
  state.Style()->SetScrollPaddingTop(ComputedStyleInitialFunctions::InitialScrollPaddingTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollPaddingTop(StyleResolverState& state) {
  state.Style()->SetScrollPaddingTop(state.ParentStyle()->ScrollPaddingTop());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginBottom(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginBottom(ComputedStyleInitialFunctions::InitialScrollSnapMarginBottom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginBottom(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginBottom(state.ParentStyle()->ScrollSnapMarginBottom());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginLeft(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginLeft(ComputedStyleInitialFunctions::InitialScrollSnapMarginLeft());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginLeft(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginLeft(state.ParentStyle()->ScrollSnapMarginLeft());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginRight(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginRight(ComputedStyleInitialFunctions::InitialScrollSnapMarginRight());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginRight(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginRight(state.ParentStyle()->ScrollSnapMarginRight());
}

void StyleBuilderFunctions::applyInitialCSSPropertyScrollSnapMarginTop(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginTop(ComputedStyleInitialFunctions::InitialScrollSnapMarginTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyScrollSnapMarginTop(StyleResolverState& state) {
  state.Style()->SetScrollSnapMarginTop(state.ParentStyle()->ScrollSnapMarginTop());
}

void StyleBuilderFunctions::applyInitialCSSPropertyShapeRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetShapeRendering(SVGComputedStyle::InitialShapeRendering());
}

void StyleBuilderFunctions::applyInheritCSSPropertyShapeRendering(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetShapeRendering(state.ParentStyle()->SvgStyle().ShapeRendering());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertySpeak(StyleResolverState& state) {
  state.Style()->SetSpeak(ComputedStyleInitialFunctions::InitialSpeak());
}

void StyleBuilderFunctions::applyInheritCSSPropertySpeak(StyleResolverState& state) {
  state.Style()->SetSpeak(state.ParentStyle()->Speak());
}

void StyleBuilderFunctions::applyValueCSSPropertySpeak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetSpeak(ToCSSIdentifierValue(value).ConvertTo<ESpeak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyStopColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopColor(SVGComputedStyle::InitialStopColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStopColor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopColor(state.ParentStyle()->SvgStyle().StopColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStopOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopOpacity(SVGComputedStyle::InitialStopOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStopOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStopOpacity(state.ParentStyle()->SvgStyle().StopOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeDashoffset(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeDashOffset(SVGComputedStyle::InitialStrokeDashOffset());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeLinecap(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCapStyle(SVGComputedStyle::InitialCapStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeLinecap(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetCapStyle(state.ParentStyle()->SvgStyle().CapStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeLinejoin(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetJoinStyle(SVGComputedStyle::InitialJoinStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeLinejoin(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetJoinStyle(state.ParentStyle()->SvgStyle().JoinStyle());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeOpacity(SVGComputedStyle::InitialStrokeOpacity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeOpacity(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeOpacity(state.ParentStyle()->SvgStyle().StrokeOpacity());
}

void StyleBuilderFunctions::applyInitialCSSPropertyStrokeWidth(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeWidth(SVGComputedStyle::InitialStrokeWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyStrokeWidth(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetStrokeWidth(state.ParentStyle()->SvgStyle().StrokeWidth());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTableLayout(StyleResolverState& state) {
  state.Style()->SetTableLayout(ComputedStyleInitialFunctions::InitialTableLayout());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTableLayout(StyleResolverState& state) {
  state.Style()->SetTableLayout(state.ParentStyle()->TableLayout());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAlign(StyleResolverState& state) {
  state.Style()->SetTextAlign(ComputedStyleInitialFunctions::InitialTextAlign());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAlign(StyleResolverState& state) {
  state.Style()->SetTextAlign(state.ParentStyle()->GetTextAlign());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAlignLast(StyleResolverState& state) {
  state.Style()->SetTextAlignLast(ComputedStyleInitialFunctions::InitialTextAlignLast());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAlignLast(StyleResolverState& state) {
  state.Style()->SetTextAlignLast(state.ParentStyle()->TextAlignLast());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextAnchor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetTextAnchor(SVGComputedStyle::InitialTextAnchor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextAnchor(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetTextAnchor(state.ParentStyle()->SvgStyle().TextAnchor());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextCombineUpright(StyleResolverState& state) {
  state.Style()->SetTextCombine(ComputedStyleInitialFunctions::InitialTextCombine());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextCombineUpright(StyleResolverState& state) {
  state.Style()->SetTextCombine(state.ParentStyle()->TextCombine());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextOverflow(StyleResolverState& state) {
  state.Style()->SetTextOverflow(ComputedStyleInitialFunctions::InitialTextOverflow());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextOverflow(StyleResolverState& state) {
  state.Style()->SetTextOverflow(state.ParentStyle()->TextOverflow());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyTextTransform(StyleResolverState& state) {
  state.Style()->SetTextTransform(ComputedStyleInitialFunctions::InitialTextTransform());
  state.Style()->SetTextTransformIsInherited
(false);
}

state.Style()->SetTextTransformIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyTop(StyleResolverState& state) {
  state.Style()->SetTop(ComputedStyleInitialFunctions::InitialTop());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTop(StyleResolverState& state) {
  state.Style()->SetTop(state.ParentStyle()->Top());
}

void StyleBuilderFunctions::applyValueCSSPropertyTop(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetTop(StyleBuilderConverter::ConvertLengthOrAuto(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyTransformStyle(StyleResolverState& state) {
  state.Style()->SetTransformStyle3D(ComputedStyleInitialFunctions::InitialTransformStyle3D());
}

void StyleBuilderFunctions::applyInheritCSSPropertyTransformStyle(StyleResolverState& state) {
  state.Style()->SetTransformStyle3D(state.ParentStyle()->TransformStyle3D());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyUserSelect(StyleResolverState& state) {
  state.Style()->SetUserSelect(ComputedStyleInitialFunctions::InitialUserSelect());
}

void StyleBuilderFunctions::applyInheritCSSPropertyUserSelect(StyleResolverState& state) {
  state.Style()->SetUserSelect(state.ParentStyle()->UserSelect());
}

void StyleBuilderFunctions::applyValueCSSPropertyUserSelect(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetUserSelect(ToCSSIdentifierValue(value).ConvertTo<EUserSelect>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyVectorEffect(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetVectorEffect(SVGComputedStyle::InitialVectorEffect());
}

void StyleBuilderFunctions::applyInheritCSSPropertyVectorEffect(StyleResolverState& state) {
  state.Style()->AccessSVGStyle().SetVectorEffect(state.ParentStyle()->SvgStyle().VectorEffect());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyVerticalAlign(StyleResolverState& state) {
  state.Style()->SetVerticalAlign(ComputedStyleInitialFunctions::InitialVerticalAlign());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAppearance(StyleResolverState& state) {
  state.Style()->SetAppearance(ComputedStyleInitialFunctions::InitialAppearance());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAppearance(StyleResolverState& state) {
  state.Style()->SetAppearance(state.ParentStyle()->Appearance());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBorderImage(StyleResolverState& state) {
  state.Style()->SetBorderImage(ComputedStyleInitialFunctions::InitialBorderImage());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBorderImage(StyleResolverState& state) {
  state.Style()->SetBorderImage(state.ParentStyle()->BorderImage());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBorderVerticalSpacing(StyleResolverState& state) {
  state.Style()->SetVerticalBorderSpacing(ComputedStyleInitialFunctions::InitialVerticalBorderSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBorderVerticalSpacing(StyleResolverState& state) {
  state.Style()->SetVerticalBorderSpacing(state.ParentStyle()->VerticalBorderSpacing());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxAlign(StyleResolverState& state) {
  state.Style()->SetBoxAlign(ComputedStyleInitialFunctions::InitialBoxAlign());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxAlign(StyleResolverState& state) {
  state.Style()->SetBoxAlign(state.ParentStyle()->BoxAlign());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxDecorationBreak(StyleResolverState& state) {
  state.Style()->SetBoxDecorationBreak(ComputedStyleInitialFunctions::InitialBoxDecorationBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxDecorationBreak(StyleResolverState& state) {
  state.Style()->SetBoxDecorationBreak(state.ParentStyle()->BoxDecorationBreak());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxDirection(StyleResolverState& state) {
  state.Style()->SetBoxDirection(ComputedStyleInitialFunctions::InitialBoxDirection());
  state.Style()->SetBoxDirectionIsInherited
(false);
}

state.Style()->SetBoxDirectionIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxLines(StyleResolverState& state) {
  state.Style()->SetBoxLines(ComputedStyleInitialFunctions::InitialBoxLines());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxLines(StyleResolverState& state) {
  state.Style()->SetBoxLines(state.ParentStyle()->BoxLines());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxLines(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxLines(ToCSSIdentifierValue(value).ConvertTo<EBoxLines>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxOrient(StyleResolverState& state) {
  state.Style()->SetBoxOrient(ComputedStyleInitialFunctions::InitialBoxOrient());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxOrient(StyleResolverState& state) {
  state.Style()->SetBoxOrient(state.ParentStyle()->BoxOrient());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitBoxPack(StyleResolverState& state) {
  state.Style()->SetBoxPack(ComputedStyleInitialFunctions::InitialBoxPack());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitBoxPack(StyleResolverState& state) {
  state.Style()->SetBoxPack(state.ParentStyle()->BoxPack());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBoxPack(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetBoxPack(ToCSSIdentifierValue(value).ConvertTo<EBoxPack>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitHyphenateCharacter(StyleResolverState& state) {
  state.Style()->SetHyphenationString(ComputedStyleInitialFunctions::InitialHyphenationString());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitHyphenateCharacter(StyleResolverState& state) {
  state.Style()->SetHyphenationString(state.ParentStyle()->HyphenationString());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(ComputedStyleInitialFunctions::InitialLineBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitLineBreak(StyleResolverState& state) {
  state.Style()->SetLineBreak(state.ParentStyle()->GetLineBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitLineBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetLineBreak(ToCSSIdentifierValue(value).ConvertTo<LineBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginAfterCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(ComputedStyleInitialFunctions::InitialMarginAfterCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginAfterCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(state.ParentStyle()->MarginAfterCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginBeforeCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(ComputedStyleInitialFunctions::InitialMarginBeforeCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginBeforeCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(state.ParentStyle()->MarginBeforeCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginBottomCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(ComputedStyleInitialFunctions::InitialMarginAfterCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginBottomCollapse(StyleResolverState& state) {
  state.Style()->SetMarginAfterCollapse(state.ParentStyle()->MarginAfterCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMarginTopCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(ComputedStyleInitialFunctions::InitialMarginBeforeCollapse());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMarginTopCollapse(StyleResolverState& state) {
  state.Style()->SetMarginBeforeCollapse(state.ParentStyle()->MarginBeforeCollapse());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitMaskBoxImageSource(StyleResolverState& state) {
  state.Style()->SetMaskBoxImageSource(ComputedStyleInitialFunctions::InitialMaskBoxImageSource());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitMaskBoxImageSource(StyleResolverState& state) {
  state.Style()->SetMaskBoxImageSource(state.ParentStyle()->MaskBoxImageSource());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOriginX(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginX(ComputedStyleInitialFunctions::InitialPerspectiveOriginX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOriginX(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginX(state.ParentStyle()->PerspectiveOriginX());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOriginY(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginY(ComputedStyleInitialFunctions::InitialPerspectiveOriginY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOriginY(StyleResolverState& state) {
  state.Style()->SetPerspectiveOriginY(state.ParentStyle()->PerspectiveOriginY());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPrintColorAdjust(StyleResolverState& state) {
  state.Style()->SetPrintColorAdjust(ComputedStyleInitialFunctions::InitialPrintColorAdjust());
  state.Style()->SetPrintColorAdjustIsInherited
(false);
}

state.Style()->SetPrintColorAdjustIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitRtlOrdering(StyleResolverState& state) {
  state.Style()->SetRtlOrdering(ComputedStyleInitialFunctions::InitialRtlOrdering());
  state.Style()->SetRtlOrderingIsInherited
(false);
}

state.Style()->SetRtlOrderingIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitRubyPosition(StyleResolverState& state) {
  state.Style()->SetRubyPosition(ComputedStyleInitialFunctions::InitialRubyPosition());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitRubyPosition(StyleResolverState& state) {
  state.Style()->SetRubyPosition(state.ParentStyle()->GetRubyPosition());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTapHighlightColor(StyleResolverState& state) {
  state.Style()->SetTapHighlightColor(ComputedStyleInitialFunctions::InitialTapHighlightColor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTapHighlightColor(StyleResolverState& state) {
  state.Style()->SetTapHighlightColor(state.ParentStyle()->TapHighlightColor());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextCombine(StyleResolverState& state) {
  state.Style()->SetTextCombine(ComputedStyleInitialFunctions::InitialTextCombine());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextCombine(StyleResolverState& state) {
  state.Style()->SetTextCombine(state.ParentStyle()->TextCombine());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextSecurity(StyleResolverState& state) {
  state.Style()->SetTextSecurity(ComputedStyleInitialFunctions::InitialTextSecurity());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextSecurity(StyleResolverState& state) {
  state.Style()->SetTextSecurity(state.ParentStyle()->TextSecurity());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTransformOriginX(StyleResolverState& state) {
  state.Style()->SetTransformOriginX(ComputedStyleInitialFunctions::InitialTransformOriginX());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTransformOriginX(StyleResolverState& state) {
  state.Style()->SetTransformOriginX(state.ParentStyle()->TransformOriginX());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTransformOriginY(StyleResolverState& state) {
  state.Style()->SetTransformOriginY(ComputedStyleInitialFunctions::InitialTransformOriginY());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTransformOriginY(StyleResolverState& state) {
  state.Style()->SetTransformOriginY(state.ParentStyle()->TransformOriginY());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitUserDrag(StyleResolverState& state) {
  state.Style()->SetUserDrag(ComputedStyleInitialFunctions::InitialUserDrag());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitUserDrag(StyleResolverState& state) {
  state.Style()->SetUserDrag(state.ParentStyle()->UserDrag());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitUserDrag(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetUserDrag(ToCSSIdentifierValue(value).ConvertTo<EUserDrag>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitUserModify(StyleResolverState& state) {
  state.Style()->SetUserModify(ComputedStyleInitialFunctions::InitialUserModify());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitUserModify(StyleResolverState& state) {
  state.Style()->SetUserModify(state.ParentStyle()->UserModify());
}

}

void StyleBuilderFunctions::applyInitialCSSPropertyWhiteSpace(StyleResolverState& state) {
  state.Style()->SetWhiteSpace(ComputedStyleInitialFunctions::InitialWhiteSpace());
  state.Style()->SetWhiteSpaceIsInherited
(false);
}

void StyleBuilderFunctions::applyValueCSSPropertyWhiteSpace(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWhiteSpace(ToCSSIdentifierValue(value).ConvertTo<EWhiteSpace>());

state.Style()->SetWhiteSpaceIsInherited
(false);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWidows(StyleResolverState& state) {
  state.Style()->SetWidows(ComputedStyleInitialFunctions::InitialWidows());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWidows(StyleResolverState& state) {
  state.Style()->SetWidows(state.ParentStyle()->Widows());
}

void StyleBuilderFunctions::applyValueCSSPropertyWidows(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWidows(ToCSSPrimitiveValue(value).ConvertTo<short>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWidth(StyleResolverState& state) {
  state.Style()->SetWidth(ComputedStyleInitialFunctions::InitialWidth());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWidth(StyleResolverState& state) {
  state.Style()->SetWidth(state.ParentStyle()->Width());
}

void StyleBuilderFunctions::applyValueCSSPropertyWidth(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWidth(StyleBuilderConverter::ConvertLengthSizing(state, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyWordBreak(StyleResolverState& state) {
  state.Style()->SetWordBreak(ComputedStyleInitialFunctions::InitialWordBreak());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWordBreak(StyleResolverState& state) {
  state.Style()->SetWordBreak(state.ParentStyle()->WordBreak());
}

void StyleBuilderFunctions::applyValueCSSPropertyWordBreak(StyleResolverState& state, const CSSValue& value) {
  state.Style()->SetWordBreak(ToCSSIdentifierValue(value).ConvertTo<EWordBreak>());

}

void StyleBuilderFunctions::applyInitialCSSPropertyWordSpacing(StyleResolverState& state) {
  state.Style()->SetWordSpacing(ComputedStyleInitialFunctions::InitialWordSpacing());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWordSpacing(StyleResolverState& state) {
  state.Style()->SetWordSpacing(state.ParentStyle()->WordSpacing());
}

void StyleBuilderFunctions::applyInitialCSSPropertyWordWrap(StyleResolverState& state) {
  state.Style()->SetOverflowWrap(ComputedStyleInitialFunctions::InitialOverflowWrap());
}