Make CSSToStyleMap static.

Source/core/css/resolver/CSSToStyleMap.cpp

 /*
  * 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 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.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 24 matching lines @@
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/rendering/style/BorderImageLengthBox.h"
 #include "core/rendering/style/FillLayer.h"
 
 namespace blink {
 
-const CSSToLengthConversionData& CSSToStyleMap::cssToLengthConversionData() const
-{
-    return m_state.cssToLengthConversionData();
-}
-
-PassRefPtr<StyleImage> CSSToStyleMap::styleImage(CSSPropertyID propertyId, CSSValue* value)
-{
-    return m_elementStyleResources.styleImage(m_state.document(), m_state.document().textLinkColors(), m_state.style()->color(), propertyId, value);
-}
-
-void CSSToStyleMap::mapFillAttachment(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillAttachment(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setAttachment(FillLayer::initialFillAttachment(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     switch (primitiveValue->getValueID()) {
     case CSSValueFixed:
         layer->setAttachment(FixedBackgroundAttachment);
         break;
     case CSSValueScroll:
         layer->setAttachment(ScrollBackgroundAttachment);
         break;
     case CSSValueLocal:
         layer->setAttachment(LocalBackgroundAttachment);
         break;
     default:
         return;
     }
 }
 
-void CSSToStyleMap::mapFillClip(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillClip(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setClip(FillLayer::initialFillClip(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     layer->setClip(*primitiveValue);
 }
 
-void CSSToStyleMap::mapFillComposite(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillComposite(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setComposite(FillLayer::initialFillComposite(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     layer->setComposite(*primitiveValue);
 }
 
-void CSSToStyleMap::mapFillBlendMode(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillBlendMode(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setBlendMode(FillLayer::initialFillBlendMode(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     layer->setBlendMode(*primitiveValue);
 }
 
-void CSSToStyleMap::mapFillOrigin(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillOrigin(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setOrigin(FillLayer::initialFillOrigin(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     layer->setOrigin(*primitiveValue);
 }
 
 
-void CSSToStyleMap::mapFillImage(FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillImage(StyleResolverState& state, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setImage(FillLayer::initialFillImage(layer->type()));
         return;
     }
 
     CSSPropertyID property = layer->type() == BackgroundFillLayer ? CSSPropertyBackgroundImage : CSSPropertyWebkitMaskImage;
-    layer->setImage(styleImage(property, value));
+    layer->setImage(state.styleImage(property, value));
 }
 
-void CSSToStyleMap::mapFillRepeatX(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillRepeatX(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setRepeatX(FillLayer::initialFillRepeatX(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     layer->setRepeatX(*primitiveValue);
 }
 
-void CSSToStyleMap::mapFillRepeatY(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillRepeatY(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setRepeatY(FillLayer::initialFillRepeatY(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     layer->setRepeatY(*primitiveValue);
 }
 
-void CSSToStyleMap::mapFillSize(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillSize(StyleResolverState& state, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setSizeType(FillLayer::initialFillSizeType(layer->type()));
         layer->setSizeLength(FillLayer::initialFillSizeLength(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue->getValueID() == CSSValueContain)
         layer->setSizeType(Contain);
     else if (primitiveValue->getValueID() == CSSValueCover)
         layer->setSizeType(Cover);
     else
         layer->setSizeType(SizeLength);
 
     LengthSize b = FillLayer::initialFillSizeLength(layer->type());
 
     if (primitiveValue->getValueID() == CSSValueContain || primitiveValue->getValueID() == CSSValueCover) {
         layer->setSizeLength(b);
         return;
     }
 
     Length firstLength;
     Length secondLength;
 
     if (Pair* pair = primitiveValue->getPairValue()) {
-        firstLength = pair->first()->convertToLength<AnyConversion>(cssToLengthConversionData());
-        secondLength = pair->second()->convertToLength<AnyConversion>(cssToLengthConversionData());
+        firstLength = pair->first()->convertToLength<AnyConversion>(state.cssToLengthConversionData());
+        secondLength = pair->second()->convertToLength<AnyConversion>(state.cssToLengthConversionData());
     } else {
-        firstLength = primitiveValue->convertToLength<AnyConversion>(cssToLengthConversionData());
+        firstLength = primitiveValue->convertToLength<AnyConversion>(state.cssToLengthConversionData());
         secondLength = Length();
     }
 
     b.setWidth(firstLength);
     b.setHeight(secondLength);
     layer->setSizeLength(b);
 }
 
-void CSSToStyleMap::mapFillXPosition(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillXPosition(StyleResolverState& state, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setXPosition(FillLayer::initialFillXPosition(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue->getPairValue();
     if (pair)
         primitiveValue = pair->second();
 
-    Length length = primitiveValue->convertToLength<FixedConversion | PercentConversion>(cssToLengthConversionData());
+    Length length = primitiveValue->convertToLength<FixedConversion | PercentConversion>(state.cssToLengthConversionData());
 
     layer->setXPosition(length);
     if (pair)
         layer->setBackgroundXOrigin(*(pair->first()));
 }
 
-void CSSToStyleMap::mapFillYPosition(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillYPosition(StyleResolverState& state, FillLayer* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setYPosition(FillLayer::initialFillYPosition(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue->getPairValue();
     if (pair)
         primitiveValue = pair->second();
 
-    Length length = primitiveValue->convertToLength<FixedConversion | PercentConversion>(cssToLengthConversionData());
+    Length length = primitiveValue->convertToLength<FixedConversion | PercentConversion>(state.cssToLengthConversionData());
 
     layer->setYPosition(length);
     if (pair)
         layer->setBackgroundYOrigin(*(pair->first()));
 }
 
-void CSSToStyleMap::mapFillMaskSourceType(FillLayer* layer, CSSValue* value) const
+void CSSToStyleMap::mapFillMaskSourceType(StyleResolverState&, FillLayer* layer, CSSValue* value)
 {
     EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer->type());
     if (value->isInitialValue()) {
         layer->setMaskSourceType(type);
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
@@ skipping 152 matching lines @@
 
     if (value->isInitialValue())
         return CSSTimingData::initialTimingFunction();
 
     CSSStepsTimingFunctionValue* stepsTimingFunction = toCSSStepsTimingFunctionValue(value);
     if (stepsTimingFunction->stepAtPosition() == StepsTimingFunction::Middle && !allowStepMiddle)
         return CSSTimingData::initialTimingFunction();
     return StepsTimingFunction::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtPosition());
 }
 
-void CSSToStyleMap::mapNinePieceImage(RenderStyle* mutableStyle, CSSPropertyID property, CSSValue* value, NinePieceImage& image)
+void CSSToStyleMap::mapNinePieceImage(StyleResolverState& state, CSSPropertyID property, CSSValue* value, NinePieceImage& image)
 {
     // If we're not a value list, then we are "none" and don't need to alter the empty image at all.
     if (!value || !value->isValueList())
         return;
 
     // Retrieve the border image value.
     CSSValueList* borderImage = toCSSValueList(value);
 
     // Set the image (this kicks off the load).
     CSSPropertyID imageProperty;
     if (property == CSSPropertyWebkitBorderImage)
         imageProperty = CSSPropertyBorderImageSource;
     else if (property == CSSPropertyWebkitMaskBoxImage)
         imageProperty = CSSPropertyWebkitMaskBoxImageSource;
     else
         imageProperty = property;
 
     for (unsigned i = 0 ; i < borderImage->length() ; ++i) {
         CSSValue* current = borderImage->item(i);
 
         if (current->isImageValue() || current->isImageGeneratorValue() || current->isImageSetValue())
-            image.setImage(styleImage(imageProperty, current));
+            image.setImage(state.styleImage(imageProperty, current));
         else if (current->isBorderImageSliceValue())
-            mapNinePieceImageSlice(current, image);
+            mapNinePieceImageSlice(state, current, image);
         else if (current->isValueList()) {
             CSSValueList* slashList = toCSSValueList(current);
             size_t length = slashList->length();
             // Map in the image slices.
             if (length && slashList->item(0)->isBorderImageSliceValue())
-                mapNinePieceImageSlice(slashList->item(0), image);
+                mapNinePieceImageSlice(state, slashList->item(0), image);
 
             // Map in the border slices.
             if (length > 1)
-                image.setBorderSlices(mapNinePieceImageQuad(slashList->item(1)));
+                image.setBorderSlices(mapNinePieceImageQuad(state, slashList->item(1)));
 
             // Map in the outset.
             if (length > 2)
-                image.setOutset(mapNinePieceImageQuad(slashList->item(2)));
+                image.setOutset(mapNinePieceImageQuad(state, slashList->item(2)));
         } else if (current->isPrimitiveValue()) {
             // Set the appropriate rules for stretch/round/repeat of the slices.
-            mapNinePieceImageRepeat(current, image);
+            mapNinePieceImageRepeat(state, current, image);
         }
     }
 
     if (property == CSSPropertyWebkitBorderImage) {
         // We have to preserve the legacy behavior of -webkit-border-image and make the border slices
         // also set the border widths. We don't need to worry about percentages, since we don't even support
         // those on real borders yet.
         if (image.borderSlices().top().isLength() && image.borderSlices().top().length().isFixed())
-            mutableStyle->setBorderTopWidth(image.borderSlices().top().length().value());
+            state.style()->setBorderTopWidth(image.borderSlices().top().length().value());
         if (image.borderSlices().right().isLength() && image.borderSlices().right().length().isFixed())
-            mutableStyle->setBorderRightWidth(image.borderSlices().right().length().value());
+            state.style()->setBorderRightWidth(image.borderSlices().right().length().value());
         if (image.borderSlices().bottom().isLength() && image.borderSlices().bottom().length().isFixed())
-            mutableStyle->setBorderBottomWidth(image.borderSlices().bottom().length().value());
+            state.style()->setBorderBottomWidth(image.borderSlices().bottom().length().value());
         if (image.borderSlices().left().isLength() && image.borderSlices().left().length().isFixed())
-            mutableStyle->setBorderLeftWidth(image.borderSlices().left().length().value());
+            state.style()->setBorderLeftWidth(image.borderSlices().left().length().value());
     }
 }
 
-void CSSToStyleMap::mapNinePieceImageSlice(CSSValue* value, NinePieceImage& image) const
+void CSSToStyleMap::mapNinePieceImageSlice(StyleResolverState&, CSSValue* value, NinePieceImage& image)
 {
     if (!value || !value->isBorderImageSliceValue())
         return;
 
     // Retrieve the border image value.
     CSSBorderImageSliceValue* borderImageSlice = toCSSBorderImageSliceValue(value);
 
     // Set up a length box to represent our image slices.
     LengthBox box;
     Quad* slices = borderImageSlice->slices();
@@ skipping 23 matching lines @@
 {
     if (value.isNumber())
         return value.getDoubleValue();
     if (value.isPercentage())
         return Length(value.getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
     if (value.getValueID() != CSSValueAuto)
         return value.computeLength<Length>(conversionData);
     return Length(Auto);
 }
 
-BorderImageLengthBox CSSToStyleMap::mapNinePieceImageQuad(CSSValue* value) const
+BorderImageLengthBox CSSToStyleMap::mapNinePieceImageQuad(StyleResolverState& state, CSSValue* value)
 {
     if (!value || !value->isPrimitiveValue())
         return BorderImageLengthBox(Length(Auto));
 
     Quad* slices = toCSSPrimitiveValue(value)->getQuadValue();
 
     // Set up a border image length box to represent our image slices.
     return BorderImageLengthBox(
-        toBorderImageLength(*slices->top(), cssToLengthConversionData()),
-        toBorderImageLength(*slices->right(), cssToLengthConversionData()),
-        toBorderImageLength(*slices->bottom(), cssToLengthConversionData()),
-        toBorderImageLength(*slices->left(), cssToLengthConversionData()));
+        toBorderImageLength(*slices->top(), state.cssToLengthConversionData()),
+        toBorderImageLength(*slices->right(), state.cssToLengthConversionData()),
+        toBorderImageLength(*slices->bottom(), state.cssToLengthConversionData()),
+        toBorderImageLength(*slices->left(), state.cssToLengthConversionData()));
 }
 
-void CSSToStyleMap::mapNinePieceImageRepeat(CSSValue* value, NinePieceImage& image) const
+void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, CSSValue* value, NinePieceImage& image)
 {
     if (!value || !value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue->getPairValue();
     if (!pair || !pair->first() || !pair->second())
         return;
 
     CSSValueID firstIdentifier = pair->first()->getValueID();
@@ skipping 28 matching lines @@
         verticalRule = SpaceImageRule;
         break;
     default: // CSSValueRepeat
         verticalRule = RepeatImageRule;
         break;
     }
     image.setVerticalRule(verticalRule);
 }
 
 };