Remove friend declarations from CSSPropertyParser

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 5400 matching lines @@
     }
 
     return true;
 }
 
 // This class tracks parsing state for shadow values.  If it goes out of scope (e.g., due to an early return)
 // without the allowBreak bit being set, then it will clean up all of the objects and destroy them.
 class ShadowParseContext {
     STACK_ALLOCATED();
 public:
-    ShadowParseContext(CSSPropertyID prop, CSSPropertyParser* parser)
+    ShadowParseContext(CSSPropertyID prop)
         : property(prop)
-        , m_parser(parser)
         , allowX(true)
         , allowY(false)
         , allowBlur(false)
         , allowSpread(false)
         , allowColor(true)
         , allowStyle(prop == CSSPropertyWebkitBoxShadow || prop == CSSPropertyBoxShadow)
         , allowBreak(true)
     {
     }
 
@@ skipping 20 matching lines @@
 
         allowX = true;
         allowColor = true;
         allowBreak = true;
         allowY = false;
         allowBlur = false;
         allowSpread = false;
         allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
     }
 
-    void commitLength(CSSParserValue* v)
+    void commitLength(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
     {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> val = m_parser->createPrimitiveNumericValue(v);
-
         if (allowX) {
-            x = val.release();
+            x = val;
             allowX = false;
             allowY = true;
             allowColor = false;
             allowStyle = false;
             allowBreak = false;
         } else if (allowY) {
-            y = val.release();
+            y = val;
             allowY = false;
             allowBlur = true;
             allowColor = true;
             allowStyle = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
             allowBreak = true;
         } else if (allowBlur) {
-            blur = val.release();
+            blur = val;
             allowBlur = false;
             allowSpread = property == CSSPropertyWebkitBoxShadow || property == CSSPropertyBoxShadow;
         } else if (allowSpread) {
-            spread = val.release();
+            spread = val;
             allowSpread = false;
         }
     }
 
     void commitColor(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
     {
         color = val;
         allowColor = false;
         if (allowX) {
             allowStyle = false;
@@ skipping 12 matching lines @@
         if (allowX)
             allowBreak = false;
         else {
             allowBlur = false;
             allowSpread = false;
             allowColor = false;
         }
     }
 
     CSSPropertyID property;
-    CSSPropertyParser* m_parser;
 
     RefPtrWillBeMember<CSSValueList> values;
     RefPtrWillBeMember<CSSPrimitiveValue> x;
     RefPtrWillBeMember<CSSPrimitiveValue> y;
     RefPtrWillBeMember<CSSPrimitiveValue> blur;
     RefPtrWillBeMember<CSSPrimitiveValue> spread;
     RefPtrWillBeMember<CSSPrimitiveValue> style;
     RefPtrWillBeMember<CSSPrimitiveValue> color;
 
     bool allowX;
     bool allowY;
     bool allowBlur;
     bool allowSpread;
     bool allowColor;
     bool allowStyle; // inset or not.
     bool allowBreak;
 };
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseShadow(CSSParserValueList* valueList, CSSPropertyID propId)
 {
-    ShadowParseContext context(propId, this);
+    ShadowParseContext context(propId);
     for (CSSParserValue* val = valueList->current(); val; val = valueList->next()) {
         // Check for a comma break first.
         if (val->unit == CSSParserValue::Operator) {
             if (val->iValue != ',' || !context.allowBreak) {
                 // Other operators aren't legal or we aren't done with the current shadow
                 // value.  Treat as invalid.
                 return nullptr;
             }
             // The value is good.  Commit it.
             context.commitValue();
         } else if (validUnit(val, FLength, HTMLStandardMode)) {
             // We required a length and didn't get one. Invalid.
             if (!context.allowLength())
                 return nullptr;
 
             // Blur radius must be non-negative.
             if (context.allowBlur && !validUnit(val, FLength | FNonNeg, HTMLStandardMode))
                 return nullptr;
 
             // A length is allowed here.  Construct the value and add it.
-            context.commitLength(val);
+            RefPtrWillBeRawPtr<CSSPrimitiveValue> length = createPrimitiveNumericValue(val);

[Timothy Loh, 2015/02/11 02:59:48]

Maybe just inline this in the function call

+            context.commitLength(length.release());
         } else if (val->id == CSSValueInset) {
             if (!context.allowStyle)
                 return nullptr;
 
             context.commitStyle(val);
         } else {
             // The only other type of value that's ok is a color value.
             RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedColor = nullptr;
             bool isColor = ((val->id >= CSSValueAqua && val->id <= CSSValueWindowtext) || val->id == CSSValueMenu
                             || (val->id >= CSSValueWebkitFocusRingColor && val->id <= CSSValueWebkitText && inQuirksMode())
@@ skipping 227 matching lines @@
         m_requireOutset = false;
         m_allowImageSlice = !m_imageSlice;
         m_allowImage = !m_image;
     }
 
     PassRefPtrWillBeRawPtr<CSSValue> commitCSSValue()
     {
         return createBorderImageValue(m_image, m_imageSlice.get(), m_borderWidth.get(), m_outset.get(), m_repeat.get());
     }
 
-    void commitMaskBoxImage(CSSPropertyParser* parser, bool important)
-    {
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSource, parser, m_image, important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSlice, parser, m_imageSlice.get(), important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageWidth, parser, m_borderWidth.get(), important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageOutset, parser, m_outset.get(), important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageRepeat, parser, m_repeat.get(), important);
-    }
-
-    void commitBorderImage(CSSPropertyParser* parser, bool important)
-    {
-        commitBorderImageProperty(CSSPropertyBorderImageSource, parser, m_image, important);
-        commitBorderImageProperty(CSSPropertyBorderImageSlice, parser, m_imageSlice.get(), important);
-        commitBorderImageProperty(CSSPropertyBorderImageWidth, parser, m_borderWidth.get(), important);
-        commitBorderImageProperty(CSSPropertyBorderImageOutset, parser, m_outset.get(), important);
-        commitBorderImageProperty(CSSPropertyBorderImageRepeat, parser, m_repeat, important);
-    }
-
-    void commitBorderImageProperty(CSSPropertyID propId, CSSPropertyParser* parser, PassRefPtrWillBeRawPtr<CSSValue> value, bool important)
-    {
-        if (value)
-            parser->addProperty(propId, value, important);
-        else
-            parser->addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
-    }
-
-    static bool buildFromParser(CSSPropertyParser&, CSSPropertyID, BorderImageParseContext&);
-
     bool m_canAdvance;
 
     bool m_allowCommit;
     bool m_allowImage;
     bool m_allowImageSlice;
     bool m_allowRepeat;
     bool m_allowForwardSlashOperator;
 
     bool m_allowWidth;
     bool m_requireOutset;
 
     RefPtrWillBeMember<CSSValue> m_image;
     RefPtrWillBeMember<CSSBorderImageSliceValue> m_imageSlice;
     RefPtrWillBeMember<CSSPrimitiveValue> m_borderWidth;
     RefPtrWillBeMember<CSSPrimitiveValue> m_outset;
 
     RefPtrWillBeMember<CSSValue> m_repeat;
 };
 
-bool BorderImageParseContext::buildFromParser(CSSPropertyParser& parser, CSSPropertyID propId, BorderImageParseContext& context)
+bool CSSPropertyParser::buildBorderImageParseContext(CSSPropertyID propId, BorderImageParseContext& context)
 {
-    CSSPropertyParser::ShorthandScope scope(&parser, propId);
-    while (CSSParserValue* val = parser.m_valueList->current()) {
+    CSSPropertyParser::ShorthandScope scope(this, propId);
+    while (CSSParserValue* val = m_valueList->current()) {
         context.setCanAdvance(false);
 
         if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(val))
             context.commitForwardSlashOperator();
 
         if (!context.canAdvance() && context.allowImage()) {
             if (val->unit == CSSPrimitiveValue::CSS_URI) {
-                context.commitImage(parser.createCSSImageValueWithReferrer(val->string, parser.m_context.completeURL(val->string)));
+                context.commitImage(createCSSImageValueWithReferrer(val->string, m_context.completeURL(val->string)));
             } else if (isGeneratedImageValue(val)) {
                 RefPtrWillBeRawPtr<CSSValue> value = nullptr;
-                if (parser.parseGeneratedImage(parser.m_valueList, value))
+                if (parseGeneratedImage(m_valueList, value))
                     context.commitImage(value.release());
                 else
                     return false;
             } else if (val->unit == CSSParserValue::Function && val->function->id == CSSValueWebkitImageSet) {
-                RefPtrWillBeRawPtr<CSSValue> value = parser.parseImageSet(parser.m_valueList);
+                RefPtrWillBeRawPtr<CSSValue> value = parseImageSet(m_valueList);
                 if (value)
                     context.commitImage(value.release());
                 else
                     return false;
             } else if (val->id == CSSValueNone)
                 context.commitImage(cssValuePool().createIdentifierValue(CSSValueNone));
         }
 
         if (!context.canAdvance() && context.allowImageSlice()) {
             RefPtrWillBeRawPtr<CSSBorderImageSliceValue> imageSlice = nullptr;
-            if (parser.parseBorderImageSlice(propId, imageSlice))
+            if (parseBorderImageSlice(propId, imageSlice))
                 context.commitImageSlice(imageSlice.release());
         }
 
         if (!context.canAdvance() && context.allowRepeat()) {
             RefPtrWillBeRawPtr<CSSValue> repeat = nullptr;
-            if (parser.parseBorderImageRepeat(repeat))
+            if (parseBorderImageRepeat(repeat))
                 context.commitRepeat(repeat.release());
         }
 
         if (!context.canAdvance() && context.allowWidth()) {
             RefPtrWillBeRawPtr<CSSPrimitiveValue> borderWidth = nullptr;
-            if (parser.parseBorderImageWidth(borderWidth))
+            if (parseBorderImageWidth(borderWidth))
                 context.commitBorderWidth(borderWidth.release());
         }
 
         if (!context.canAdvance() && context.requireOutset()) {
             RefPtrWillBeRawPtr<CSSPrimitiveValue> borderOutset = nullptr;
-            if (parser.parseBorderImageOutset(borderOutset))
+            if (parseBorderImageOutset(borderOutset))
                 context.commitBorderOutset(borderOutset.release());
         }
 
         if (!context.canAdvance())
             return false;
 
-        parser.m_valueList->next();
+        m_valueList->next();
     }
 
     return context.allowCommit();
 }
 
+void CSSPropertyParser::commitBorderImageProperty(CSSPropertyID propId, PassRefPtrWillBeRawPtr<CSSValue> value, bool important)
+{
+    if (value)
+        addProperty(propId, value, important);
+    else
+        addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
+}
+
 bool CSSPropertyParser::parseBorderImageShorthand(CSSPropertyID propId, bool important)
 {
     BorderImageParseContext context;
-    if (BorderImageParseContext::buildFromParser(*this, propId, context)) {
+    if (buildBorderImageParseContext(propId, context)) {
         switch (propId) {
         case CSSPropertyWebkitMaskBoxImage:
-            context.commitMaskBoxImage(this, important);
+            commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSource, context.m_image, important);
+            commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSlice, context.m_imageSlice.get(), important);
+            commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageWidth, context.m_borderWidth.get(), important);
+            commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageOutset, context.m_outset.get(), important);
+            commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageRepeat, context.m_repeat.get(), important);
             return true;
         case CSSPropertyBorderImage:
-            context.commitBorderImage(this, important);
+            commitBorderImageProperty(CSSPropertyBorderImageSource, context.m_image, important);
+            commitBorderImageProperty(CSSPropertyBorderImageSlice, context.m_imageSlice.get(), important);
+            commitBorderImageProperty(CSSPropertyBorderImageWidth, context.m_borderWidth.get(), important);
+            commitBorderImageProperty(CSSPropertyBorderImageOutset, context.m_outset.get(), important);
+            commitBorderImageProperty(CSSPropertyBorderImageRepeat, context.m_repeat, important);
             return true;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseBorderImage(CSSPropertyID propId)
 {
     BorderImageParseContext context;
-    if (BorderImageParseContext::buildFromParser(*this, propId, context)) {
+    if (buildBorderImageParseContext(propId, context)) {
         return context.commitCSSValue();
     }
     return nullptr;
 }
 
 static bool isBorderImageRepeatKeyword(int id)
 {
     return id == CSSValueStretch || id == CSSValueRepeat || id == CSSValueSpace || id == CSSValueRound;
 }
 
@@ skipping 25 matching lines @@
     } else
         secondValue = firstValue;
 
     result = createPrimitiveValuePair(firstValue, secondValue);
     return true;
 }
 
 class BorderImageSliceParseContext {
     STACK_ALLOCATED();
 public:
-    BorderImageSliceParseContext(CSSPropertyParser* parser)
-    : m_parser(parser)
-    , m_allowNumber(true)
+    BorderImageSliceParseContext()
+    : m_allowNumber(true)
     , m_allowFill(true)
     , m_allowFinalCommit(false)
     , m_fill(false)
     { }
 
     bool allowNumber() const { return m_allowNumber; }
     bool allowFill() const { return m_allowFill; }
     bool allowFinalCommit() const { return m_allowFinalCommit; }
     CSSPrimitiveValue* top() const { return m_top.get(); }
 
-    void commitNumber(CSSParserValue* v)
+    void commitNumber(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
     {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> val = m_parser->createPrimitiveNumericValue(v);
         if (!m_top)
             m_top = val;
         else if (!m_right)
             m_right = val;
         else if (!m_bottom)
             m_bottom = val;
         else {
             ASSERT(!m_left);
             m_left = val;
         }
@@ skipping 25 matching lines @@
         quad->setTop(m_top);
         quad->setRight(m_right);
         quad->setBottom(m_bottom);
         quad->setLeft(m_left);
 
         // Make our new border image value now.
         return CSSBorderImageSliceValue::create(cssValuePool().createValue(quad.release()), m_fill);
     }
 
 private:
-    CSSPropertyParser* m_parser;
-
     bool m_allowNumber;
     bool m_allowFill;
     bool m_allowFinalCommit;
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_top;
     RefPtrWillBeMember<CSSPrimitiveValue> m_right;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
     RefPtrWillBeMember<CSSPrimitiveValue> m_left;
 
     bool m_fill;
 };
 
 bool CSSPropertyParser::parseBorderImageSlice(CSSPropertyID propId, RefPtrWillBeRawPtr<CSSBorderImageSliceValue>& result)
 {
-    BorderImageSliceParseContext context(this);
+    BorderImageSliceParseContext context;
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->next()) {
         // FIXME calc() http://webkit.org/b/16662 : calc is parsed but values are not created yet.
         if (context.allowNumber() && !isCalculation(val) && validUnit(val, FInteger | FNonNeg | FPercent)) {
-            context.commitNumber(val);
+            context.commitNumber(createPrimitiveNumericValue(val));
         } else if (context.allowFill() && val->id == CSSValueFill) {
             context.commitFill();
         } else if (!inShorthand()) {
             // If we're not parsing a shorthand then we are invalid.
             return false;
         } else {
             if (context.allowFinalCommit()) {
                 // We're going to successfully parse, but we don't want to consume this token.
                 m_valueList->previous();
             }
@@ skipping 11 matching lines @@
         result = context.commitBorderImageSlice();
         return true;
     }
 
     return false;
 }
 
 class BorderImageQuadParseContext {
     STACK_ALLOCATED();
 public:
-    BorderImageQuadParseContext(CSSPropertyParser* parser)
-    : m_parser(parser)
-    , m_allowNumber(true)
+    BorderImageQuadParseContext()
+    : m_allowNumber(true)
     , m_allowFinalCommit(false)
     { }
 
     bool allowNumber() const { return m_allowNumber; }
     bool allowFinalCommit() const { return m_allowFinalCommit; }
     CSSPrimitiveValue* top() const { return m_top.get(); }
 
-    void commitNumber(CSSParserValue* v)
+    void commitNumber(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> val)
     {
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> val = nullptr;
-        if (v->id == CSSValueAuto)
-            val = cssValuePool().createIdentifierValue(v->id);
-        else
-            val = m_parser->createPrimitiveNumericValue(v);
-
         if (!m_top)
             m_top = val;
         else if (!m_right)
             m_right = val;
         else if (!m_bottom)
             m_bottom = val;
         else {
             ASSERT(!m_left);
             m_left = val;
         }
@@ skipping 25 matching lines @@
         quad->setTop(m_top);
         quad->setRight(m_right);
         quad->setBottom(m_bottom);
         quad->setLeft(m_left);
 
         // Make our new value now.
         return cssValuePool().createValue(quad.release());
     }
 
 private:
-    CSSPropertyParser* m_parser;
-
     bool m_allowNumber;
     bool m_allowFinalCommit;
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_top;
     RefPtrWillBeMember<CSSPrimitiveValue> m_right;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
     RefPtrWillBeMember<CSSPrimitiveValue> m_left;
 };
 
 bool CSSPropertyParser::parseBorderImageQuad(Units validUnits, RefPtrWillBeRawPtr<CSSPrimitiveValue>& result)
 {
-    BorderImageQuadParseContext context(this);
+    BorderImageQuadParseContext context;
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->next()) {
         if (context.allowNumber() && (validUnit(val, validUnits, HTMLStandardMode) || val->id == CSSValueAuto)) {
-            context.commitNumber(val);
+            if (val->id == CSSValueAuto)
+                context.commitNumber(cssValuePool().createIdentifierValue(val->id));
+            else
+                context.commitNumber(createPrimitiveNumericValue(val));
         } else if (!inShorthand()) {
             // If we're not parsing a shorthand then we are invalid.
             return false;
         } else {
             if (context.allowFinalCommit())
                 m_valueList->previous(); // The shorthand loop will advance back to this point.
             break;
         }
     }
 
@@ skipping 117 matching lines @@
             || (a->id == CSSValueBottom && !horizontal))
             result = cssValuePool().createValue(100., CSSPrimitiveValue::CSS_PERCENTAGE);
         else if (a->id == CSSValueCenter)
             result = cssValuePool().createValue(50., CSSPrimitiveValue::CSS_PERCENTAGE);
     } else if (a->unit == CSSPrimitiveValue::CSS_NUMBER || a->unit == CSSPrimitiveValue::CSS_PERCENTAGE) {
         result = cssValuePool().createValue(a->fValue, static_cast<CSSPrimitiveValue::UnitType>(a->unit));
     }
     return result;
 }
 
-bool parseDeprecatedGradientColorStop(CSSPropertyParser* p, CSSParserValue* a, CSSGradientColorStop& stop)
+bool CSSPropertyParser::parseDeprecatedGradientColorStop(CSSParserValue* a, CSSGradientColorStop& stop)
 {
     if (a->unit != CSSParserValue::Function)
         return false;
 
     if (a->function->id != CSSValueFrom
         && a->function->id != CSSValueTo
         && a->function->id != CSSValueColorStop)
         return false;
 
     CSSParserValueList* args = a->function->args.get();
     if (!args)
         return false;
 
     if (a->function->id == CSSValueFrom || a->function->id == CSSValueTo) {
         // The "from" and "to" stops expect 1 argument.
         if (args->size() != 1)
             return false;
 
         if (a->function->id == CSSValueFrom)
             stop.m_position = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER);
         else
             stop.m_position = cssValuePool().createValue(1, CSSPrimitiveValue::CSS_NUMBER);
 
         CSSValueID id = args->current()->id;
         if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu)
             stop.m_color = cssValuePool().createIdentifierValue(id);
         else
-            stop.m_color = p->parseColor(args->current());
+            stop.m_color = parseColor(args->current());
         if (!stop.m_color)
             return false;
     }
 
     // The "color-stop" function expects 3 arguments.
     if (a->function->id == CSSValueColorStop) {
         if (args->size() != 3)
             return false;
 
         CSSParserValue* stopArg = args->current();
         if (stopArg->unit == CSSPrimitiveValue::CSS_PERCENTAGE)
             stop.m_position = cssValuePool().createValue(stopArg->fValue / 100, CSSPrimitiveValue::CSS_NUMBER);
         else if (stopArg->unit == CSSPrimitiveValue::CSS_NUMBER)
             stop.m_position = cssValuePool().createValue(stopArg->fValue, CSSPrimitiveValue::CSS_NUMBER);
         else
             return false;
 
         args->next();
         if (!consumeComma(args))
             return false;
 
         stopArg = args->current();
         CSSValueID id = stopArg->id;
         if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu)
             stop.m_color = cssValuePool().createIdentifierValue(id);
         else
-            stop.m_color = p->parseColor(stopArg);
+            stop.m_color = parseColor(stopArg);
         if (!stop.m_color)
             return false;
     }
 
     return true;
 }
 
 bool CSSPropertyParser::parseDeprecatedGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient)
 {
     // Walk the arguments.
@@ skipping 108 matching lines @@
         if (!consumeComma(args))
             return false;
 
         // Now examine the stop itself.
         a = args->current();
         if (!a)
             return false;
 
         // The function name needs to be one of "from", "to", or "color-stop."
         CSSGradientColorStop stop;
-        if (!parseDeprecatedGradientColorStop(this, a, stop))
+        if (!parseDeprecatedGradientColorStop(a, stop))
             return false;
         result->addStop(stop);
 
         // Advance
         a = args->next();
     }
 
     gradient = result.release();
     return true;
 }
@@ skipping 11 matching lines @@
         case CSSValueTop:
         case CSSValueBottom:
             isHorizontal = false;
             break;
         default:
             return nullptr;
     }
     return cssValuePool().createIdentifierValue(a->id);
 }
 
-PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parseGradientColorOrKeyword(CSSPropertyParser* p, CSSParserValue* value)
-{
-    CSSValueID id = value->id;
-    if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor)
-        return cssValuePool().createIdentifierValue(id);
-
-    return p->parseColor(value);
-}
-
 bool CSSPropertyParser::parseDeprecatedLinearGradient(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
 {
     RefPtrWillBeRawPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating, CSSPrefixedLinearGradient);
 
     // Walk the arguments.
     CSSParserValueList* args = valueList->current()->function->args.get();
     if (!args || !args->size())
         return false;
 
     CSSParserValue* a = args->current();
@@ skipping 384 matching lines @@
                 return false;
 
             a = valueList->next();
             if (!a)
                 return false;
         }
 
         // <color-stop> = <color> [ <percentage> | <length> ]?
         // <color-hint> = <length> | <percentage>
         CSSGradientColorStop stop;
-        stop.m_color = parseGradientColorOrKeyword(this, a);
+        CSSValueID id = a->id;
+        if (id == CSSValueWebkitText || (id >= CSSValueAqua && id <= CSSValueWindowtext) || id == CSSValueMenu || id == CSSValueCurrentcolor)
+            stop.m_color = cssValuePool().createIdentifierValue(id);
+        else
+            stop.m_color = parseColor(a);
+
 
         // Two hints in a row are not allowed.
         if (!stop.m_color && (!supportsColorHints || previousStopWasColorHint))
             return false;
         previousStopWasColorHint = !stop.m_color;
 
         if (stop.m_color)
             a = valueList->next();
 
         if (a) {
@@ skipping 1591 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink