StyleBuilder should not know about StyleResolver.

Source/core/css/resolver/StyleBuilderCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
@@ skipping 32 matching lines @@
 #include "CSSValueKeywords.h"
 #include "StyleBuilderFunctions.h"
 #include "StylePropertyShorthand.h"
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSAspectRatioValue.h"
 #include "core/css/CSSCursorImageValue.h"
 #include "core/css/CSSGradientValue.h"
 #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"
 #include "core/css/CSSVariableValue.h"
 #include "core/css/Counter.h"
 #include "core/css/FontValue.h"
 #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"
 #include "core/page/Settings.h"
 #include "core/platform/graphics/FontDescription.h"
 #include "core/rendering/style/CounterContent.h"
 #include "core/rendering/style/CursorList.h"
 #include "core/rendering/style/QuotesData.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "core/rendering/style/RenderStyleConstants.h"
 #include "core/rendering/style/SVGRenderStyle.h"
 #include "core/rendering/style/SVGRenderStyleDefs.h"
 #include "core/rendering/style/ShadowData.h"
 #include "core/rendering/style/StyleGeneratedImage.h"
 #include "core/svg/SVGColor.h"
 #include "core/svg/SVGPaint.h"
 #include "core/svg/SVGURIReference.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 static Length clipConvertToLength(StyleResolverState& state, CSSPrimitiveValue* value)
 {
     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;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     if (Rect* rect = primitiveValue->getRectValue()) {
         Length top = clipConvertToLength(state, rect->top());
         Length right = clipConvertToLength(state, rect->right());
         Length bottom = clipConvertToLength(state, rect->bottom());
         Length left = clipConvertToLength(state, rect->left());
         state.style()->setClip(top, right, bottom, left);
         state.style()->setHasClip(true);
     } else if (primitiveValue->getValueID() == CSSValueAuto) {
         state.style()->setClip(Length(), Length(), Length(), Length());
         state.style()->setHasClip(false);
     }
 }
 
-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()) {
         CSSValueList* list = toCSSValueList(value);
         int len = list->length();
         state.style()->setCursor(CURSOR_AUTO);
         for (int i = 0; i < len; i++) {
             CSSValue* item = list->itemWithoutBoundsCheck(i);
             if (item->isCursorImageValue()) {
                 CSSCursorImageValue* image = static_cast<CSSCursorImageValue*>(item);
                 if (image->updateIfSVGCursorIsUsed(state.element())) // Elements with SVG cursors are not allowed to share style.
                     state.style()->setUnique();
                 state.style()->addCursor(state.styleImage(CSSPropertyCursor, image), image->hotSpot());
             } else if (item->isPrimitiveValue()) {
                 CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(item);
                 if (primitiveValue->isValueID())
                     state.style()->setCursor(*primitiveValue);
             }
         }
     } else if (value->isPrimitiveValue()) {
         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
         if (primitiveValue->isValueID() && state.style()->cursor() != ECursor(*primitiveValue))
             state.style()->setCursor(*primitiveValue);
     }
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyDirection(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyDirection(StyleResolverState& state, CSSValue* value)
 {
     state.style()->setDirection(*toCSSPrimitiveValue(value));
     Element* element = state.element();
     if (element && element == element->document()->documentElement())
         element->document()->setDirectionSetOnDocumentElement(true);
 }
 
 static inline bool isValidDisplayValue(StyleResolverState& state, EDisplay displayPropertyValue)
 {
     if (state.element() && state.element()->isSVGElement() && state.style()->styleType() == NOPSEUDO)
         return (displayPropertyValue == INLINE || displayPropertyValue == BLOCK || displayPropertyValue == NONE);
     return true;
 }
 
-void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInheritCSSPropertyDisplay(StyleResolverState& state)
 {
     EDisplay display = state.parentStyle()->display();
     if (!isValidDisplayValue(state, display))
         return;
     state.style()->setDisplay(display);
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyDisplay(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
 
     EDisplay display = *toCSSPrimitiveValue(value);
 
     if (!isValidDisplayValue(state, display))
         return;
 
     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;
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     switch (primitiveValue->getValueID()) {
     case CSSValueInvalid:
         ASSERT_NOT_REACHED();
         break;
     case CSSValueBolder:
         state.fontBuilder().setWeightBolder();
         break;
     case CSSValueLighter:
         state.fontBuilder().setWeightLighter();
         break;
     default:
         state.fontBuilder().setWeight(*primitiveValue);
     }
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyLineHeight(StyleResolver* styleResolver, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyLineHeight(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     Length lineHeight;
 
     if (primitiveValue->getValueID() == CSSValueNormal) {
         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()) {
         // FIXME: percentage should not be restricted to an integer here.
         lineHeight = Length((state.style()->fontSize() * primitiveValue->getIntValue()) / 100, Fixed);
     } else if (primitiveValue->isNumber()) {
         // FIXME: number and percentage values should produce the same type of Length (ie. Fixed or Percent).
         lineHeight = Length(primitiveValue->getDoubleValue() * 100.0, Percent);
     } else if (primitiveValue->isViewportPercentageLength()) {
         lineHeight = primitiveValue->viewportPercentageLength();
     } else {
         return;
     }
     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;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     EResize r = RESIZE_NONE;
     switch (primitiveValue->getValueID()) {
     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:
         r = *primitiveValue;
     }
     state.style()->setResize(r);
 }
 
 static Length mmLength(double mm) { return CSSPrimitiveValue::create(mm, CSSPrimitiveValue::CSS_MM)->computeLength<Length>(0, 0); }
 static Length inchLength(double inch) { return CSSPrimitiveValue::create(inch, CSSPrimitiveValue::CSS_IN)->computeLength<Length>(0, 0); }
@@ skipping 64 matching lines @@
         case CSSValuePortrait:
             // Nothing to do.
             break;
         default:
             return false;
         }
     }
     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;
     Length height;
     PageSizeType pageSizeType = PAGE_SIZE_AUTO;
     CSSValueListInspector inspector(value);
     switch (inspector.length()) {
     case 2: {
         // <length>{2} | <page-size> <orientation>
         if (!inspector.first()->isPrimitiveValue() || !inspector.second()->isPrimitiveValue())
@@ skipping 46 matching lines @@
         }
         break;
     }
     default:
         return;
     }
     state.style()->setPageSizeType(pageSizeType);
     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;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue->getValueID() != CSSValueWebkitMatchParent)
         state.style()->setTextAlign(*primitiveValue);
     else if (state.parentStyle()->textAlign() == TASTART)
         state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection() ? LEFT : RIGHT);
     else if (state.parentStyle()->textAlign() == TAEND)
         state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection() ? RIGHT : LEFT);
     else
         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()) {
         CSSValue* item = i.value();
         t |= *toCSSPrimitiveValue(item);
     }
     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)
     state.style()->setTextIndentLine(state.parentStyle()->textIndentLine());
 #endif
 }
 
-void StyleBuilderFunctions::applyInitialCSSPropertyTextIndent(StyleResolver*, StyleResolverState& state)
+void StyleBuilderFunctions::applyInitialCSSPropertyTextIndent(StyleResolverState& state)
 {
     state.style()->setTextIndent(RenderStyle::initialTextIndent());
 #if ENABLE(CSS3_TEXT)
     state.style()->setTextIndentLine(RenderStyle::initialTextIndentLine());
 #endif
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isValueList())
         return;
 
     // [ <length> | <percentage> ] -webkit-each-line
     // The order is guaranteed. See CSSParser::parseTextIndent.
     // The second value, -webkit-each-line is handled only when CSS3_TEXT is enabled.
 
     CSSValueList* valueList = toCSSValueList(value);
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(valueList->itemWithoutBoundsCheck(0));
     Length lengthOrPercentageValue = primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion>(state.style(), state.rootElementStyle(), state.style()->effectiveZoom());
     ASSERT(!lengthOrPercentageValue.isUndefined());
     state.style()->setTextIndent(lengthOrPercentageValue);
 
 #if ENABLE(CSS3_TEXT)
     ASSERT(valueList->length() <= 2);
     CSSPrimitiveValue* eachLineValue = toCSSPrimitiveValue(valueList->item(1));
     if (eachLineValue) {
         ASSERT(eachLineValue->getValueID() == CSSValueWebkitEachLine);
         state.style()->setTextIndentLine(TextIndentEachLine);
     } else {
         state.style()->setTextIndentLine(TextIndentFirstLine);
     }
 #endif
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue->getValueID())
         return state.style()->setVerticalAlign(*primitiveValue);
 
     state.style()->setVerticalAlignLength(primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion>(state.style(), state.rootElementStyle(), state.style()->effectiveZoom()));
 }
 
 static void resetEffectiveZoom(StyleResolverState& state)
 {
     // Reset the zoom in effect. This allows the setZoom method to accurately compute a new zoom in effect.
     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);
 
     if (primitiveValue->getValueID() == CSSValueNormal) {
         resetEffectiveZoom(state);
         state.setZoom(RenderStyle::initialZoom());
     } else if (primitiveValue->getValueID() == CSSValueReset) {
         state.setEffectiveZoom(RenderStyle::initialZoom());
         state.setZoom(RenderStyle::initialZoom());
     } else if (primitiveValue->getValueID() == CSSValueDocument) {
         float docZoom = state.rootElementStyle() ? state.rootElementStyle()->zoom() : RenderStyle::initialZoom();
         state.setEffectiveZoom(docZoom);
         state.setZoom(docZoom);
     } else if (primitiveValue->isPercentage()) {
         resetEffectiveZoom(state);
         if (float percent = primitiveValue->getFloatValue())
             state.setZoom(percent / 100.0f);
     } else if (primitiveValue->isNumber()) {
         resetEffectiveZoom(state);
         if (float number = primitiveValue->getFloatValue())
             state.setZoom(number);
     }
 }
 
-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;
     state.style()->setHasAspectRatio(true);
     state.style()->setAspectRatioDenominator(state.parentStyle()->aspectRatioDenominator());
     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);
         return;
     }
     CSSAspectRatioValue* aspectRatioValue = static_cast<CSSAspectRatioValue*>(value);
     state.style()->setHasAspectRatio(true);
     state.style()->setAspectRatioDenominator(aspectRatioValue->denominatorValue());
     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);
         if (primitiveValue->getValueID() == CSSValueNone) {
             state.style()->setClipPath(0);
         } else if (primitiveValue->isShape()) {
             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;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue->getValueID()) {
         switch (primitiveValue->getValueID()) {
         case CSSValueSmall:
             state.style()->setMarqueeIncrement(Length(1, Fixed)); // 1px.
             break;
         case CSSValueNormal:
             state.style()->setMarqueeIncrement(Length(6, Fixed)); // 6px. The WinIE default.
             break;
         case CSSValueLarge:
             state.style()->setMarqueeIncrement(Length(36, Fixed)); // 36px.
             break;
         default:
             break;
         }
     } else {
         Length marqueeLength = primitiveValue ? primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | FractionConversion>(state.style(), state.rootElementStyle()) : Length(Undefined);
         if (!marqueeLength.isUndefined())
             state.style()->setMarqueeIncrement(marqueeLength);
     }
 }
 
-void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeSpeed(StyleResolver*, StyleResolverState& state, CSSValue* value)
+void StyleBuilderFunctions::applyValueCSSPropertyWebkitMarqueeSpeed(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     if (CSSValueID valueID = primitiveValue->getValueID()) {
         switch (valueID) {
         case CSSValueSlow:
             state.style()->setMarqueeSpeed(500); // 500 msec.
             break;
         case CSSValueNormal:
             state.style()->setMarqueeSpeed(85); // 85msec. The WinIE default.
             break;
         case CSSValueFast:
             state.style()->setMarqueeSpeed(10); // 10msec. Super fast.
             break;
         default:
             break;
         }
     } else if (primitiveValue->isTime()) {
         state.style()->setMarqueeSpeed(primitiveValue->computeTime<int, CSSPrimitiveValue::Milliseconds>());
     } else if (primitiveValue->isNumber()) { // For scrollamount support.
         state.style()->setMarqueeSpeed(primitiveValue->getIntValue());
     }
 }
 
 // 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);
         ASSERT(list->length() == 2);
         if (list->length() != 2)
             return;
         for (unsigned i = 0; i < 2; ++i) {
             CSSValue* item = list->itemWithoutBoundsCheck(i);
             if (!item->isPrimitiveValue())
                 continue;
@@ skipping 24 matching lines @@
     if (primitiveValue->getValueID() == CSSValueFilled || primitiveValue->getValueID() == CSSValueOpen) {
         state.style()->setTextEmphasisFill(*primitiveValue);
         state.style()->setTextEmphasisMark(TextEmphasisMarkAuto);
     } else {
         state.style()->setTextEmphasisFill(TextEmphasisFillFilled);
         state.style()->setTextEmphasisMark(*primitiveValue);
     }
 }
 
 #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()) {
         TextUnderlinePosition t = *toCSSPrimitiveValue(value);
         state.style()->setTextUnderlinePosition(t);
         return;
     }
 
     unsigned t = 0;
     for (CSSValueListIterator i(value); i.hasMore(); i.advance()) {
@@ skipping 229 matching lines @@
     return numberToFloat(primitiveValue, out);
 }
 
 static String fragmentIdentifier(const CSSPrimitiveValue* primitiveValue, Document* document)
 {
     if (primitiveValue->primitiveType() != CSSPrimitiveValue::CSS_URI)
         return String();
     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;
+    }
 
-// 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)
+    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);
+}
+
+
+void StyleBuilder::oldApplyProperty(CSSPropertyID id, StyleResolverState& state, CSSValue* value, bool isInitial, bool isInherit)
 {
     CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? toCSSPrimitiveValue(value) : 0;
 
     float zoomFactor = state.style()->effectiveZoom();
 
     // What follows is a list that maps the CSS properties into their corresponding front-end
     // RenderStyle values.
     switch (id) {
     case CSSPropertyContent:
         // list of string, uri, counter, attr, i
@@ skipping 347 matching lines @@
     case CSSPropertyWebkitPaddingAfter:
     case CSSPropertyWebkitLogicalWidth:
     case CSSPropertyWebkitLogicalHeight:
     case CSSPropertyWebkitMinLogicalWidth:
     case CSSPropertyWebkitMinLogicalHeight:
     case CSSPropertyWebkitMaxLogicalWidth:
     case CSSPropertyWebkitMaxLogicalHeight:
     {
         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:
     case CSSPropertyTextLineThroughColor:
     case CSSPropertyTextLineThroughMode:
     case CSSPropertyTextLineThroughStyle:
     case CSSPropertyTextLineThroughWidth:
     case CSSPropertyTextOverlineColor:
     case CSSPropertyTextOverlineMode:
     case CSSPropertyTextOverlineStyle:
@@ skipping 689 matching lines @@
         break;
     }
     case CSSPropertyEnableBackground:
         // Silently ignoring this property for now
         // http://bugs.webkit.org/show_bug.cgi?id=6022
         break;
     }
 }
 
 } // namespace WebCore