StyleBuilder should not know about StyleResolver.

Source/core/css/resolver/StyleBuilderCustom.cpp

Index: Source/core/css/resolver/StyleBuilderCustom.cpp
diff --git a/Source/core/css/resolver/StyleBuilderCustom.cpp b/Source/core/css/resolver/StyleBuilderCustom.cpp
index 9237e259daca81401e4a05fe9aca274310c6abf1..2ba2f839c6d27b46dded8ec87948f3ebea55c6d4 100644
--- a/Source/core/css/resolver/StyleBuilderCustom.cpp
+++ b/Source/core/css/resolver/StyleBuilderCustom.cpp
@@ -50,6 +50,7 @@
 #include "core/css/CSSGridTemplateValue.h"
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/CSSLineBoxContainValue.h"
+#include "core/css/CSSParser.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSProperty.h"
 #include "core/css/CSSReflectValue.h"
@@ -59,10 +60,10 @@
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/ShadowValue.h"
+#include "core/css/StylePropertySet.h"
 #include "core/css/resolver/ElementStyleResources.h"
 #include "core/css/resolver/FilterOperationResolver.h"
 #include "core/css/resolver/FontBuilder.h"
-#include "core/css/resolver/StyleResolver.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/css/resolver/TransformBuilder.h"
 #include "core/page/Frame.h"
@@ -91,22 +92,22 @@ static Length clipConvertToLength(StyleResolverState& state, CSSPrimitiveValue*
     return value->convertToLength<FixedIntegerConversion | PercentConversion | FractionConversion | AutoConversion>(state.style(), state.rootElementStyle(), state.style()->effectiveZoom());
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyClip(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyClip(StyleResolverState& state)
 {
     state.style()->setClip(Length(), Length(), Length(), Length());
     state.style()->setHasClip(false);
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyClip(StyleResolver* styleResolver, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyClip(StyleResolverState& state)
 {
     RenderStyle* parentStyle = state.parentStyle();
     if (!parentStyle->hasClip())
-        return applyInitialCSSPropertyClip(styleResolver, state);
+        return applyInitialCSSPropertyClip(state);
     state.style()->setClip(parentStyle->clipTop(), parentStyle->clipRight(), parentStyle->clipBottom(), parentStyle->clipLeft());
     state.style()->setHasClip(true);
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyClip(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyClip(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -126,19 +127,19 @@ void StyleBuilderFunctions::applyValueCSSPropertyClip(StyleResolver*, StyleResol
     }
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyCursor(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyCursor(StyleResolverState& state)
 {
     state.style()->clearCursorList();
     state.style()->setCursor(RenderStyle::initialCursor());
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyCursor(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyCursor(StyleResolverState& state)
 {
     state.style()->setCursor(state.parentStyle()->cursor());
     state.style()->setCursorList(state.parentStyle()->cursors());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyCursor(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyCursor(StyleResolverState& state, CSSValue* value)
 {
     state.style()->clearCursorList();
     if (value->isValueList()) {
@@ -165,7 +166,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyCursor(StyleResolver*, StyleRes
     }
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyDirection(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyDirection(StyleResolverState& state, CSSValue* value)
 {
     state.style()->setDirection(*toCSSPrimitiveValue(value));
     Element* element = state.element();
@@ -180,7 +181,7 @@ static inline bool isValidDisplayValue(StyleResolverState& state, EDisplay displ
     return true;
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state)
 {
     EDisplay display = state.parentStyle()->display();
     if (!isValidDisplayValue(state, display))
@@ -188,7 +189,7 @@ void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolver*, Style
     state.style()->setDisplay(display);
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -201,47 +202,47 @@ void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolver*, StyleRe
     state.style()->setDisplay(display);
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyFontFamily(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyFontFamily(StyleResolverState& state)
 {
     state.fontBuilder().setFontFamilyInitial(state.style()->effectiveZoom());
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyFontFamily(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyFontFamily(StyleResolverState& state)
 {
     state.fontBuilder().setFontFamilyInherit(state.parentFontDescription());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyFontFamily(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyFontFamily(StyleResolverState& state, CSSValue* value)
 {
     state.fontBuilder().setFontFamilyValue(value, state.style()->effectiveZoom());
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyFontSize(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyFontSize(StyleResolverState& state)
 {
     state.fontBuilder().setFontSizeInitial(state.style()->effectiveZoom());
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyFontSize(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyFontSize(StyleResolverState& state)
 {
     state.fontBuilder().setFontSizeInherit(state.parentFontDescription(), state.style()->effectiveZoom());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyFontSize(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyFontSize(StyleResolverState& state, CSSValue* value)
 {
     state.fontBuilder().setFontSizeValue(value, state.parentStyle(), state.rootElementStyle(), state.style()->effectiveZoom());
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyFontWeight(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyFontWeight(StyleResolverState& state)
 {
     state.fontBuilder().setWeight(FontWeightNormal);
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyFontWeight(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyFontWeight(StyleResolverState& state)
 {
     state.fontBuilder().setWeight(state.parentFontDescription().weight());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyFontWeight(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyFontWeight(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -261,7 +262,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyFontWeight(StyleResolver*, Styl
     }
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyLineHeight(StyleResolver* styleResolver, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyLineHeight(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -273,7 +274,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyLineHeight(StyleResolver* style
         lineHeight = RenderStyle::initialLineHeight();
     } else if (primitiveValue->isLength()) {
         double multiplier = state.style()->effectiveZoom();
-        if (Frame* frame = styleResolver->document()->frame())
+        if (Frame* frame = state.elementContext().document()->frame())

[dglazkov, 2013/08/01 21:47:49]

not lgtm. This one does indeed cause a crash.

             multiplier *= frame->textZoomFactor();
         lineHeight = primitiveValue->computeLength<Length>(state.style(), state.rootElementStyle(), multiplier);
     } else if (primitiveValue->isPercentage()) {
@@ -290,31 +291,31 @@ void StyleBuilderFunctions::applyValueCSSPropertyLineHeight(StyleResolver* style
     state.style()->setLineHeight(lineHeight);
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyListStyleImage(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyListStyleImage(StyleResolverState& state, CSSValue* value)
 {
     state.style()->setListStyleImage(state.styleImage(CSSPropertyListStyleImage, value));
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyOutlineStyle(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyOutlineStyle(StyleResolverState& state)
 {
     state.style()->setOutlineStyleIsAuto(RenderStyle::initialOutlineStyleIsAuto());
     state.style()->setOutlineStyle(RenderStyle::initialBorderStyle());
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyOutlineStyle(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyOutlineStyle(StyleResolverState& state)
 {
     state.style()->setOutlineStyleIsAuto(state.parentStyle()->outlineStyleIsAuto());
     state.style()->setOutlineStyle(state.parentStyle()->outlineStyle());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyOutlineStyle(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyOutlineStyle(StyleResolverState& state, CSSValue* value)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     state.style()->setOutlineStyleIsAuto(*primitiveValue);
     state.style()->setOutlineStyle(*primitiveValue);
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyResize(StyleResolver* styleResolver, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyResize(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -326,7 +327,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyResize(StyleResolver* styleReso
     case 0:
         return;
     case CSSValueAuto:
-        if (Settings* settings = styleResolver->document()->settings())
+        if (Settings* settings = state.elementContext().document()->settings())

[eseidel, 2013/08/01 21:09:53]

Does this still risk changing behavior in the <canvas> case where we aren't
provided an element and thus elementContext().document() is 0?

[dglazkov, 2013/08/01 21:16:19]

The good news is that in <canvas> we're only applying a specific set of
font-related properties, so this case won't hit. However, it will be good to
assert the doc here.

             r = settings->textAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
         break;
     default:
@@ -411,9 +412,9 @@ static bool getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CSSPrimitiveVal
     return true;
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertySize(StyleResolver*, StyleResolverState&) { }
-void StyleBuilderFunctions::applyInheritCSSPropertySize(StyleResolver*, StyleResolverState&) { }
-void StyleBuilderFunctions::applyValueCSSPropertySize(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyInitialCSSPropertySize(StyleResolverState&) { }
+void StyleBuilderFunctions::applyInheritCSSPropertySize(StyleResolverState&) { }
+void StyleBuilderFunctions::applyValueCSSPropertySize(StyleResolverState& state, CSSValue* value)
 {
     state.style()->resetPageSizeType();
     Length width;
@@ -480,7 +481,7 @@ void StyleBuilderFunctions::applyValueCSSPropertySize(StyleResolver*, StyleResol
     state.style()->setPageSize(LengthSize(width, height));
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyTextAlign(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyTextAlign(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -497,7 +498,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyTextAlign(StyleResolver*, Style
         state.style()->setTextAlign(state.parentStyle()->textAlign());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyTextDecoration(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyTextDecoration(StyleResolverState& state, CSSValue* value)
 {
     TextDecoration t = RenderStyle::initialTextDecoration();
     for (CSSValueListIterator i(value); i.hasMore(); i.advance()) {
@@ -507,7 +508,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyTextDecoration(StyleResolver*,
     state.style()->setTextDecoration(t);
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyTextIndent(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyTextIndent(StyleResolverState& state)
 {
     state.style()->setTextIndent(state.parentStyle()->textIndent());
 #if ENABLE(CSS3_TEXT)
@@ -515,7 +516,7 @@ void StyleBuilderFunctions::applyInheritCSSPropertyTextIndent(StyleResolver*, St
 #endif
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyTextIndent(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyTextIndent(StyleResolverState& state)
 {
     state.style()->setTextIndent(RenderStyle::initialTextIndent());
 #if ENABLE(CSS3_TEXT)
@@ -523,7 +524,7 @@ void StyleBuilderFunctions::applyInitialCSSPropertyTextIndent(StyleResolver*, St
 #endif
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isValueList())
         return;
@@ -550,7 +551,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolver*, Styl
 #endif
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -569,19 +570,19 @@ static void resetEffectiveZoom(StyleResolverState& state)
     state.setEffectiveZoom(state.parentStyle() ? state.parentStyle()->effectiveZoom() : RenderStyle::initialZoom());
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyZoom(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
     state.setZoom(RenderStyle::initialZoom());
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyZoom(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
     state.setZoom(state.parentStyle()->zoom());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyZoom(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyZoom(StyleResolverState& state, CSSValue* value)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(value->isPrimitiveValue());
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
@@ -607,14 +608,14 @@ void StyleBuilderFunctions::applyValueCSSPropertyZoom(StyleResolver*, StyleResol
     }
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAspectRatio(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAspectRatio(StyleResolverState& state)
 {
     state.style()->setHasAspectRatio(RenderStyle::initialHasAspectRatio());
     state.style()->setAspectRatioDenominator(RenderStyle::initialAspectRatioDenominator());
     state.style()->setAspectRatioNumerator(RenderStyle::initialAspectRatioNumerator());
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAspectRatio(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAspectRatio(StyleResolverState& state)
 {
     if (!state.parentStyle()->hasAspectRatio())
         return;
@@ -623,7 +624,7 @@ void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAspectRatio(StyleResolv
     state.style()->setAspectRatioNumerator(state.parentStyle()->aspectRatioNumerator());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitAspectRatio(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitAspectRatio(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isAspectRatioValue()) {
         state.style()->setHasAspectRatio(false);
@@ -635,7 +636,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyWebkitAspectRatio(StyleResolver
     state.style()->setAspectRatioNumerator(aspectRatioValue->numeratorValue());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitClipPath(StyleResolver* styleResolver, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitClipPath(StyleResolverState& state, CSSValue* value)
 {
     if (value->isPrimitiveValue()) {
         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
@@ -645,29 +646,29 @@ void StyleBuilderFunctions::applyValueCSSPropertyWebkitClipPath(StyleResolver* s
             state.style()->setClipPath(ShapeClipPathOperation::create(basicShapeForValue(state, primitiveValue->getShapeValue())));
         } else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_URI) {
             String cssURLValue = primitiveValue->getStringValue();
-            KURL url = styleResolver->document()->completeURL(cssURLValue);
+            KURL url = state.elementContext().document()->completeURL(cssURLValue);

[eseidel, 2013/08/01 21:09:53]

Same comment.  It's also not clear that we shoudl be resolving urls at this time
or not...

             // FIXME: It doesn't work with forward or external SVG references (see https://bugs.webkit.org/show_bug.cgi?id=90405)
             state.style()->setClipPath(ReferenceClipPathOperation::create(cssURLValue, url.fragmentIdentifier()));
         }
     }
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyWebkitFontVariantLigatures(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyWebkitFontVariantLigatures(StyleResolverState& state)
 {
     state.fontBuilder().setFontVariantLigaturesInitial();
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyWebkitFontVariantLigatures(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyWebkitFontVariantLigatures(StyleResolverState& state)
 {
     state.fontBuilder().setFontVariantLigaturesInherit(state.parentFontDescription());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitFontVariantLigatures(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitFontVariantLigatures(StyleResolverState& state, CSSValue* value)
 {
     state.fontBuilder().setFontVariantLigaturesValue(value);
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeIncrement(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeIncrement(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -694,7 +695,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeIncrement(StyleRes
     }
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeSpeed(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeSpeed(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
@@ -722,39 +723,39 @@ void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeSpeed(StyleResolve
 }
 
 // FIXME: We should use the same system for this as the rest of the pseudo-shorthands (e.g. background-position)
-void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOrigin(StyleResolver* styleResolver, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyWebkitPerspectiveOrigin(StyleResolverState& state)
 {
-    applyInitialCSSPropertyWebkitPerspectiveOriginX(styleResolver, state);
-    applyInitialCSSPropertyWebkitPerspectiveOriginY(styleResolver, state);
+    applyInitialCSSPropertyWebkitPerspectiveOriginX(state);
+    applyInitialCSSPropertyWebkitPerspectiveOriginY(state);
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOrigin(StyleResolver* styleResolver, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyWebkitPerspectiveOrigin(StyleResolverState& state)
 {
-    applyInheritCSSPropertyWebkitPerspectiveOriginX(styleResolver, state);
-    applyInheritCSSPropertyWebkitPerspectiveOriginY(styleResolver, state);
+    applyInheritCSSPropertyWebkitPerspectiveOriginX(state);
+    applyInheritCSSPropertyWebkitPerspectiveOriginY(state);
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitPerspectiveOrigin(StyleResolver*, StyleResolverState&, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitPerspectiveOrigin(StyleResolverState&, CSSValue* value)
 {
     // This is expanded in the parser
     ASSERT_NOT_REACHED();
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextEmphasisStyle(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state)
 {
     state.style()->setTextEmphasisFill(RenderStyle::initialTextEmphasisFill());
     state.style()->setTextEmphasisMark(RenderStyle::initialTextEmphasisMark());
     state.style()->setTextEmphasisCustomMark(RenderStyle::initialTextEmphasisCustomMark());
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextEmphasisStyle(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state)
 {
     state.style()->setTextEmphasisFill(state.parentStyle()->textEmphasisFill());
     state.style()->setTextEmphasisMark(state.parentStyle()->textEmphasisMark());
     state.style()->setTextEmphasisCustomMark(state.parentStyle()->textEmphasisCustomMark());
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisStyle(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state, CSSValue* value)
 {
     if (value->isValueList()) {
         CSSValueList* list = toCSSValueList(value);
@@ -799,7 +800,7 @@ void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisStyle(StyleRe
 }
 
 #if ENABLE(CSS3_TEXT)
-void StyleBuilderFunctions::applyValueCSSPropetyWebkitTextUnderlinePosition(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropetyWebkitTextUnderlinePosition(StyleResolverState& state, CSSValue* value)
 {
     // This is true if value is 'auto' or 'alphabetic'.
     if (value->isPrimitiveValue()) {
@@ -1049,10 +1050,127 @@ static String fragmentIdentifier(const CSSPrimitiveValue* primitiveValue, Docume
     return SVGURIReference::fragmentIdentifierFromIRIString(primitiveValue->getStringValue(), document);
 }
 
+static inline bool isValidVisitedLinkProperty(CSSPropertyID id)
+{
+    switch (id) {
+    case CSSPropertyBackgroundColor:
+    case CSSPropertyBorderLeftColor:
+    case CSSPropertyBorderRightColor:
+    case CSSPropertyBorderTopColor:
+    case CSSPropertyBorderBottomColor:
+    case CSSPropertyColor:
+    case CSSPropertyFill:
+    case CSSPropertyOutlineColor:
+    case CSSPropertyStroke:
+    case CSSPropertyTextDecorationColor:
+    case CSSPropertyWebkitColumnRuleColor:
+    case CSSPropertyWebkitTextEmphasisColor:
+    case CSSPropertyWebkitTextFillColor:
+    case CSSPropertyWebkitTextStrokeColor:
+        return true;
+    default:
+        break;
+    }
+
+    return false;
+}
+
+static bool hasVariableReference(CSSValue* value)
+{
+    if (value->isPrimitiveValue()) {
+        CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+        return primitiveValue->hasVariableReference();
+    }
+
+    if (value->isCalculationValue())
+        return static_cast<CSSCalcValue*>(value)->hasVariableReference();
+
+    if (value->isReflectValue()) {
+        CSSReflectValue* reflectValue = static_cast<CSSReflectValue*>(value);
+        CSSPrimitiveValue* direction = reflectValue->direction();
+        CSSPrimitiveValue* offset = reflectValue->offset();
+        CSSValue* mask = reflectValue->mask();
+        return (direction && hasVariableReference(direction)) || (offset && hasVariableReference(offset)) || (mask && hasVariableReference(mask));
+    }
+
+    for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
+        if (hasVariableReference(i.value()))
+            return true;
+    }
+
+    return false;
+}
+
+// FIXME: Resolving variables should be factored better. Maybe a resover-style class?
+static void resolveVariables(StyleResolverState& state, CSSPropertyID id, CSSValue* value, Vector<std::pair<CSSPropertyID, String> >& knownExpressions)
+{
+    std::pair<CSSPropertyID, String> expression(id, value->serializeResolvingVariables(*state.style()->variables()));
+
+    if (knownExpressions.contains(expression))
+        return; // cycle detected.
+
+    knownExpressions.append(expression);
+
+    // FIXME: It would be faster not to re-parse from strings, but for now CSS property validation lives inside the parser so we do it there.
+    RefPtr<MutableStylePropertySet> resultSet = MutableStylePropertySet::create();
+    if (!CSSParser::parseValue(resultSet.get(), id, expression.second, false, state.elementContext().document()))
+        return; // expression failed to parse.
+
+    for (unsigned i = 0; i < resultSet->propertyCount(); i++) {
+        StylePropertySet::PropertyReference property = resultSet->propertyAt(i);
+        if (property.id() != CSSPropertyVariable && hasVariableReference(property.value())) {
+            resolveVariables(state, property.id(), property.value(), knownExpressions);
+        } else {
+            StyleBuilder::applyProperty(property.id(), state, property.value());
+            // All properties become dependent on their parent style when they use variables.
+            state.style()->setHasExplicitlyInheritedProperties();
+        }
+    }
+}
+
+void StyleBuilder::applyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value)
+{
+    if (id != CSSPropertyVariable && hasVariableReference(value)) {
+        Vector<std::pair<CSSPropertyID, String> > knownExpressions;
+        resolveVariables(state, id, value, knownExpressions);
+        return;
+    }
+
+    // CSS variables don't resolve shorthands at parsing time, so this should be *after* handling variables.
+    ASSERT_WITH_MESSAGE(!isExpandedShorthand(id), "Shorthand property id = %d wasn't expanded at parsing time", id);
+
+    bool isInherit = state.parentNode() && value->isInheritedValue();
+    bool isInitial = value->isInitialValue() || (!state.parentNode() && value->isInheritedValue());
+
+    ASSERT(!isInherit || !isInitial); // isInherit -> !isInitial && isInitial -> !isInherit
+    ASSERT(!isInherit || (state.parentNode() && state.parentStyle())); // isInherit -> (state.parentNode() && state.parentStyle())
+
+    if (!state.applyPropertyToRegularStyle() && (!state.applyPropertyToVisitedLinkStyle() || !isValidVisitedLinkProperty(id))) {
+        // Limit the properties that can be applied to only the ones honored by :visited.
+        return;
+    }
+
+    if (isInherit && !state.parentStyle()->hasExplicitlyInheritedProperties() && !CSSProperty::isInheritedProperty(id))
+        state.parentStyle()->setHasExplicitlyInheritedProperties();
+
+    if (id == CSSPropertyVariable) {
+        ASSERT_WITH_SECURITY_IMPLICATION(value->isVariableValue());
+        CSSVariableValue* variable = toCSSVariableValue(value);
+        ASSERT(!variable->name().isEmpty());
+        ASSERT(!variable->value().isEmpty());
+        state.style()->setVariable(variable->name(), variable->value());
+        return;
+    }
+
+    if (StyleBuilder::applyProperty(id, state, value, isInitial, isInherit))
+        return;
+
+    // Fall back to the old switch statement, which is now in StyleBuilderCustom.cpp

[eseidel, 2013/08/01 21:09:53]

This comment probably isn't needed anymore. :)

+    StyleBuilder::oldApplyProperty(id, state, value, isInitial, isInherit);
+}
+
 
-// FIXME: Every use of "styleResolver" in this function is a layering
-// violation and should be removed.
-void StyleBuilder::oldApplyProperty(CSSPropertyID id, StyleResolver* styleResolver, StyleResolverState& state, CSSValue* value, bool isInitial, bool isInherit)
+void StyleBuilder::oldApplyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value, bool isInitial, bool isInherit)
 {
     CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? toCSSPrimitiveValue(value) : 0;
 
@@ -1420,7 +1538,7 @@ void StyleBuilder::oldApplyProperty(CSSPropertyID id, StyleResolver* styleResolv
     {
         CSSPropertyID newId = CSSProperty::resolveDirectionAwareProperty(id, state.style()->direction(), state.style()->writingMode());
         ASSERT(newId != id);
-        return styleResolver->applyProperty(state, newId, value);
+        return applyProperty(newId, state, value);
     }
     case CSSPropertyFontStretch:
     case CSSPropertyPage: