CL for perf tryjob on win

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 25 matching lines @@
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/resolver/StyleBuilderConverter.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/style/BorderImageLengthBox.h"
 #include "core/style/FillLayer.h"
 
 namespace blink {
 
-void CSSToStyleMap::mapFillAttachment(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillAttachment(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setAttachment(FillLayer::initialFillAttachment(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    switch (primitiveValue->getValueID()) {
+    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(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillClip(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setClip(FillLayer::initialFillClip(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    layer->setClip(*primitiveValue);
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    layer->setClip(primitiveValue);
 }
 
-void CSSToStyleMap::mapFillComposite(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillComposite(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setComposite(FillLayer::initialFillComposite(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    layer->setComposite(*primitiveValue);
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    layer->setComposite(primitiveValue);
 }
 
-void CSSToStyleMap::mapFillBlendMode(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillBlendMode(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setBlendMode(FillLayer::initialFillBlendMode(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    layer->setBlendMode(*primitiveValue);
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    layer->setBlendMode(primitiveValue);
 }
 
-void CSSToStyleMap::mapFillOrigin(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillOrigin(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setOrigin(FillLayer::initialFillOrigin(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    layer->setOrigin(*primitiveValue);
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    layer->setOrigin(primitiveValue);
 }
 
 
-void CSSToStyleMap::mapFillImage(StyleResolverState& state, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillImage(StyleResolverState& state, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setImage(FillLayer::initialFillImage(layer->type()));
         return;
     }
 
     CSSPropertyID property = layer->type() == BackgroundFillLayer ? CSSPropertyBackgroundImage : CSSPropertyWebkitMaskImage;
     layer->setImage(state.styleImage(property, value));
 }
 
-void CSSToStyleMap::mapFillRepeatX(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillRepeatX(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setRepeatX(FillLayer::initialFillRepeatX(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    layer->setRepeatX(*primitiveValue);
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    layer->setRepeatX(primitiveValue);
 }
 
-void CSSToStyleMap::mapFillRepeatY(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillRepeatY(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setRepeatY(FillLayer::initialFillRepeatY(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    layer->setRepeatY(*primitiveValue);
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    layer->setRepeatY(primitiveValue);
 }
 
-void CSSToStyleMap::mapFillSize(StyleResolverState& state, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillSize(StyleResolverState& state, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setSizeType(FillLayer::initialFillSizeType(layer->type()));
         layer->setSizeLength(FillLayer::initialFillSizeLength(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getValueID() == CSSValueContain)
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    if (primitiveValue.getValueID() == CSSValueContain)
         layer->setSizeType(Contain);
-    else if (primitiveValue->getValueID() == CSSValueCover)
+    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) {
+    if (primitiveValue.getValueID() == CSSValueContain || primitiveValue.getValueID() == CSSValueCover) {
         layer->setSizeLength(b);
         return;
     }
 
     Length firstLength;
     Length secondLength;
 
-    if (Pair* pair = primitiveValue->getPairValue()) {
-        firstLength = StyleBuilderConverter::convertLengthOrAuto(state, pair->first());
-        secondLength = StyleBuilderConverter::convertLengthOrAuto(state, pair->second());
+    if (Pair* pair = primitiveValue.getPairValue()) {
+        firstLength = StyleBuilderConverter::convertLengthOrAuto(state, CSSValue(*pair->first()));
+        secondLength = StyleBuilderConverter::convertLengthOrAuto(state, CSSValue(*pair->second()));
     } else {
-        firstLength = StyleBuilderConverter::convertLengthOrAuto(state, primitiveValue);
+        firstLength = StyleBuilderConverter::convertLengthOrAuto(state, value);
         secondLength = Length();
     }
 
     b.setWidth(firstLength);
     b.setHeight(secondLength);
     layer->setSizeLength(b);
 }
 
-void CSSToStyleMap::mapFillXPosition(StyleResolverState& state, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillXPosition(StyleResolverState& state, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setXPosition(FillLayer::initialFillXPosition(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue* primitiveValue = &toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue->getPairValue();
     if (pair)
         primitiveValue = pair->second();
 
     Length length = primitiveValue->convertToLength(state.cssToLengthConversionData());
 
     layer->setXPosition(length);
     if (pair)
         layer->setBackgroundXOrigin(*(pair->first()));
 }
 
-void CSSToStyleMap::mapFillYPosition(StyleResolverState& state, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillYPosition(StyleResolverState& state, FillLayer* layer, CSSValue value)
 {
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setYPosition(FillLayer::initialFillYPosition(layer->type()));
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue* primitiveValue = &toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue->getPairValue();
     if (pair)
         primitiveValue = pair->second();
 
     Length length = primitiveValue->convertToLength(state.cssToLengthConversionData());
 
     layer->setYPosition(length);
     if (pair)
         layer->setBackgroundYOrigin(*(pair->first()));
 }
 
-void CSSToStyleMap::mapFillMaskSourceType(StyleResolverState&, FillLayer* layer, CSSValue* value)
+void CSSToStyleMap::mapFillMaskSourceType(StyleResolverState&, FillLayer* layer, CSSValue value)
 {
     EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer->type());
-    if (value->isInitialValue()) {
+    if (value.isInitialValue()) {
         layer->setMaskSourceType(type);
         return;
     }
 
-    if (!value->isPrimitiveValue())
+    if (!value.isPrimitiveValue())
         return;
 
-    switch (toCSSPrimitiveValue(value)->getValueID()) {
+    switch (toCSSPrimitiveValue(value).getValueID()) {
     case CSSValueAlpha:
         type = MaskAlpha;
         break;
     case CSSValueLuminance:
         type = MaskLuminance;
         break;
     case CSSValueAuto:
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     layer->setMaskSourceType(type);
 }
 
-double CSSToStyleMap::mapAnimationDelay(CSSValue* value)
+double CSSToStyleMap::mapAnimationDelay(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSTimingData::initialDelay();
-    return toCSSPrimitiveValue(value)->computeSeconds();
+    return toCSSPrimitiveValue(value).computeSeconds();
 }
 
-Timing::PlaybackDirection CSSToStyleMap::mapAnimationDirection(CSSValue* value)
+Timing::PlaybackDirection CSSToStyleMap::mapAnimationDirection(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSAnimationData::initialDirection();
 
-    switch (toCSSPrimitiveValue(value)->getValueID()) {
+    switch (toCSSPrimitiveValue(value).getValueID()) {
     case CSSValueNormal:
         return Timing::PlaybackDirectionNormal;
     case CSSValueAlternate:
         return Timing::PlaybackDirectionAlternate;
     case CSSValueReverse:
         return Timing::PlaybackDirectionReverse;
     case CSSValueAlternateReverse:
         return Timing::PlaybackDirectionAlternateReverse;
     default:
         ASSERT_NOT_REACHED();
         return CSSAnimationData::initialDirection();
     }
 }
 
-double CSSToStyleMap::mapAnimationDuration(CSSValue* value)
+double CSSToStyleMap::mapAnimationDuration(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSTimingData::initialDuration();
-    return toCSSPrimitiveValue(value)->computeSeconds();
+    return toCSSPrimitiveValue(value).computeSeconds();
 }
 
-Timing::FillMode CSSToStyleMap::mapAnimationFillMode(CSSValue* value)
+Timing::FillMode CSSToStyleMap::mapAnimationFillMode(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSAnimationData::initialFillMode();
 
-    switch (toCSSPrimitiveValue(value)->getValueID()) {
+    switch (toCSSPrimitiveValue(value).getValueID()) {
     case CSSValueNone:
         return Timing::FillModeNone;
     case CSSValueForwards:
         return Timing::FillModeForwards;
     case CSSValueBackwards:
         return Timing::FillModeBackwards;
     case CSSValueBoth:
         return Timing::FillModeBoth;
     default:
         ASSERT_NOT_REACHED();
         return CSSAnimationData::initialFillMode();
     }
 }
 
-double CSSToStyleMap::mapAnimationIterationCount(CSSValue* value)
+double CSSToStyleMap::mapAnimationIterationCount(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSAnimationData::initialIterationCount();
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getValueID() == CSSValueInfinite)
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    if (primitiveValue.getValueID() == CSSValueInfinite)
         return std::numeric_limits<double>::infinity();
-    return primitiveValue->getFloatValue();
+    return primitiveValue.getFloatValue();
 }
 
-AtomicString CSSToStyleMap::mapAnimationName(CSSValue* value)
+AtomicString CSSToStyleMap::mapAnimationName(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSAnimationData::initialName();
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getValueID() == CSSValueNone)
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    if (primitiveValue.getValueID() == CSSValueNone)
         return CSSAnimationData::initialName();
-    return AtomicString(primitiveValue->getStringValue());
+    return AtomicString(primitiveValue.getStringValue());
 }
 
-EAnimPlayState CSSToStyleMap::mapAnimationPlayState(CSSValue* value)
+EAnimPlayState CSSToStyleMap::mapAnimationPlayState(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSAnimationData::initialPlayState();
-    if (toCSSPrimitiveValue(value)->getValueID() == CSSValuePaused)
+    if (toCSSPrimitiveValue(value).getValueID() == CSSValuePaused)
         return AnimPlayStatePaused;
-    ASSERT(toCSSPrimitiveValue(value)->getValueID() == CSSValueRunning);
+    ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueRunning);
     return AnimPlayStatePlaying;
 }
 
-CSSTransitionData::TransitionProperty CSSToStyleMap::mapAnimationProperty(CSSValue* value)
+CSSTransitionData::TransitionProperty CSSToStyleMap::mapAnimationProperty(CSSValue value)
 {
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSTransitionData::initialProperty();
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->isCustomIdent())
-        return CSSTransitionData::TransitionProperty(primitiveValue->getStringValue());
-    if (primitiveValue->getValueID() == CSSValueAll)
+    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    if (primitiveValue.isCustomIdent())
+        return CSSTransitionData::TransitionProperty(primitiveValue.getStringValue());
+    if (primitiveValue.getValueID() == CSSValueAll)
         return CSSTransitionData::TransitionProperty(CSSTransitionData::TransitionAll);
-    if (primitiveValue->getValueID() == CSSValueNone)
+    if (primitiveValue.getValueID() == CSSValueNone)
         return CSSTransitionData::TransitionProperty(CSSTransitionData::TransitionNone);
-    return CSSTransitionData::TransitionProperty(primitiveValue->getPropertyID());
+    return CSSTransitionData::TransitionProperty(primitiveValue.getPropertyID());
 }
 
-PassRefPtr<TimingFunction> CSSToStyleMap::mapAnimationTimingFunction(CSSValue* value, bool allowStepMiddle)
+PassRefPtr<TimingFunction> CSSToStyleMap::mapAnimationTimingFunction(CSSValue value, bool allowStepMiddle)
 {
     // FIXME: We should probably only call into this function with a valid
     // single timing function value which isn't initial or inherit. We can
     // currently get into here with initial since the parser expands unset
     // properties in shorthands to initial.
 
-    if (value->isPrimitiveValue()) {
-        CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-        switch (primitiveValue->getValueID()) {
+    if (value.isPrimitiveValue()) {
+        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+        switch (primitiveValue.getValueID()) {
         case CSSValueLinear:
             return LinearTimingFunction::shared();
         case CSSValueEase:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
         case CSSValueEaseIn:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
         case CSSValueEaseOut:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
         case CSSValueEaseInOut:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut);
         case CSSValueStepStart:
             return StepsTimingFunction::preset(StepsTimingFunction::Start);
         case CSSValueStepMiddle:
             if (allowStepMiddle)
                 return StepsTimingFunction::preset(StepsTimingFunction::Middle);
             return CSSTimingData::initialTimingFunction();
         case CSSValueStepEnd:
             return StepsTimingFunction::preset(StepsTimingFunction::End);
         default:
             ASSERT_NOT_REACHED();
             return CSSTimingData::initialTimingFunction();
         }
     }
 
-    if (value->isCubicBezierTimingFunctionValue()) {
-        CSSCubicBezierTimingFunctionValue* cubicTimingFunction = toCSSCubicBezierTimingFunctionValue(value);
-        return CubicBezierTimingFunction::create(cubicTimingFunction->x1(), cubicTimingFunction->y1(), cubicTimingFunction->x2(), cubicTimingFunction->y2());
+    if (value.isCubicBezierTimingFunctionValue()) {
+        CSSCubicBezierTimingFunctionValue& cubicTimingFunction = toCSSCubicBezierTimingFunctionValue(value);
+        return CubicBezierTimingFunction::create(cubicTimingFunction.x1(), cubicTimingFunction.y1(), cubicTimingFunction.x2(), cubicTimingFunction.y2());
     }
 
-    if (value->isInitialValue())
+    if (value.isInitialValue())
         return CSSTimingData::initialTimingFunction();
 
-    CSSStepsTimingFunctionValue* stepsTimingFunction = toCSSStepsTimingFunctionValue(value);
-    if (stepsTimingFunction->stepAtPosition() == StepsTimingFunction::Middle && !allowStepMiddle)
+    CSSStepsTimingFunctionValue& stepsTimingFunction = toCSSStepsTimingFunctionValue(value);
+    if (stepsTimingFunction.stepAtPosition() == StepsTimingFunction::Middle && !allowStepMiddle)
         return CSSTimingData::initialTimingFunction();
-    return StepsTimingFunction::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtPosition());
+    return StepsTimingFunction::create(stepsTimingFunction.numberOfSteps(), stepsTimingFunction.stepAtPosition());
 }
 
-void CSSToStyleMap::mapNinePieceImage(StyleResolverState& state, CSSPropertyID property, CSSValue* value, NinePieceImage& image)
+void CSSToStyleMap::mapNinePieceImage(StyleResolverState& state, CSSPropertyID property, NullableCSSValue 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);
+        CSSValue current = borderImage->item(i);
 
-        if (current->isImageValue() || current->isImageGeneratorValue() || current->isImageSetValue())
+        if (current.isImageValue() || current.isImageGeneratorValue() || current.isImageSetValue()) {
             image.setImage(state.styleImage(imageProperty, current));
-        else if (current->isBorderImageSliceValue())
+        } else if (current.isBorderImageSliceValue()) {
             mapNinePieceImageSlice(state, current, image);
-        else if (current->isValueList()) {
-            CSSValueList* slashList = toCSSValueList(current);
-            size_t length = slashList->length();
+        } 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(state, slashList->item(0), image);
+            if (length && slashList.item(0).isBorderImageSliceValue())
+                mapNinePieceImageSlice(state, slashList.item(0), image);
 
             // Map in the border slices.
             if (length > 1)
-                image.setBorderSlices(mapNinePieceImageQuad(state, slashList->item(1)));
+                image.setBorderSlices(mapNinePieceImageQuad(state, slashList.item(1)));
 
             // Map in the outset.
             if (length > 2)
-                image.setOutset(mapNinePieceImageQuad(state, slashList->item(2)));
-        } else if (current->isPrimitiveValue()) {
+                image.setOutset(mapNinePieceImageQuad(state, slashList.item(2)));
+        } else if (current.isPrimitiveValue()) {
             // Set the appropriate rules for stretch/round/repeat of the slices.
             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())
             state.style()->setBorderTopWidth(image.borderSlices().top().length().value());
         if (image.borderSlices().right().isLength() && image.borderSlices().right().length().isFixed())
             state.style()->setBorderRightWidth(image.borderSlices().right().length().value());
         if (image.borderSlices().bottom().isLength() && image.borderSlices().bottom().length().isFixed())
             state.style()->setBorderBottomWidth(image.borderSlices().bottom().length().value());
         if (image.borderSlices().left().isLength() && image.borderSlices().left().length().isFixed())
             state.style()->setBorderLeftWidth(image.borderSlices().left().length().value());
     }
 }
 
-void CSSToStyleMap::mapNinePieceImageSlice(StyleResolverState&, CSSValue* value, NinePieceImage& image)
+void CSSToStyleMap::mapNinePieceImageSlice(StyleResolverState&, NullableCSSValue 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(), Percent);
     if (value.getValueID() != CSSValueAuto)
         return value.computeLength<Length>(conversionData);
     return Length(Auto);
 }
 
-BorderImageLengthBox CSSToStyleMap::mapNinePieceImageQuad(StyleResolverState& state, CSSValue* value)
+BorderImageLengthBox CSSToStyleMap::mapNinePieceImageQuad(StyleResolverState& state, NullableCSSValue 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(), state.cssToLengthConversionData()),
         toBorderImageLength(*slices->right(), state.cssToLengthConversionData()),
         toBorderImageLength(*slices->bottom(), state.cssToLengthConversionData()),
         toBorderImageLength(*slices->left(), state.cssToLengthConversionData()));
 }
 
-void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, CSSValue* value, NinePieceImage& image)
+void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, NullableCSSValue 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);
 }
 
 };