Move parsing of "keyword only" SVG properties to CSSParserFastPaths

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 7648 matching lines @@
     ASSERT(value);
 
     CSSValueID id = value->id;
 
     bool validPrimitive = false;
     RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
 
     switch (propId) {
     /* The comment to the right defines all valid value of these
      * properties as defined in SVG 1.1, Appendix N. Property index */
-    case CSSPropertyAlignmentBaseline:
-    // auto | baseline | before-edge | text-before-edge | middle |
-    // central | after-edge | text-after-edge | ideographic | alphabetic |
-    // hanging | mathematical | inherit
-        if (id == CSSValueAuto || id == CSSValueBaseline || id == CSSValueMiddle
-            || (id >= CSSValueBeforeEdge && id <= CSSValueMathematical))
-            validPrimitive = true;
-        break;
-
     case CSSPropertyBaselineShift:
     // baseline | super | sub | <percentage> | <length> | inherit
         if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
             validPrimitive = true;
         else
             validPrimitive = validUnit(value, FLength | FPercent, SVGAttributeMode);
         break;
 
-    case CSSPropertyDominantBaseline:
-    // auto | use-script | no-change | reset-size | ideographic |
-    // alphabetic | hanging | mathematical | central | middle |
-    // text-after-edge | text-before-edge | inherit
-        if (id == CSSValueAuto || id == CSSValueMiddle
-            || (id >= CSSValueUseScript && id <= CSSValueResetSize)
-            || (id >= CSSValueCentral && id <= CSSValueMathematical))
-            validPrimitive = true;
-        break;
-
     case CSSPropertyEnableBackground:
     // accumulate | new [x] [y] [width] [height] | inherit
         if (id == CSSValueAccumulate) // TODO : new
             validPrimitive = true;
         break;
 
     case CSSPropertyClipPath:
     case CSSPropertyFilter:
     case CSSPropertyMarkerStart:
     case CSSPropertyMarkerMid:
     case CSSPropertyMarkerEnd:
     case CSSPropertyMask:
         if (id == CSSValueNone) {
             validPrimitive = true;
         } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
             parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI);
             if (parsedValue)
                 m_valueList->next();
         }
         break;
 
-    case CSSPropertyClipRule: // nonzero | evenodd | inherit
-    case CSSPropertyFillRule:
-        if (id == CSSValueNonzero || id == CSSValueEvenodd)
-            validPrimitive = true;
-        break;
-
     case CSSPropertyStrokeMiterlimit: // <miterlimit> | inherit
         validPrimitive = validUnit(value, FNumber | FNonNeg, SVGAttributeMode);
         break;
 
-    case CSSPropertyStrokeLinejoin: // miter | round | bevel | inherit
-        if (id == CSSValueMiter || id == CSSValueRound || id == CSSValueBevel)
-            validPrimitive = true;
-        break;
-
-    case CSSPropertyStrokeLinecap: // butt | round | square | inherit
-        if (id == CSSValueButt || id == CSSValueRound || id == CSSValueSquare)
-            validPrimitive = true;
-        break;
-
     case CSSPropertyStrokeOpacity: // <opacity-value> | inherit
     case CSSPropertyFillOpacity:
     case CSSPropertyStopOpacity:
     case CSSPropertyFloodOpacity:
         validPrimitive = validUnit(value, FNumber | FPercent, SVGAttributeMode);
         break;
 
-    case CSSPropertyShapeRendering:
-    // auto | optimizeSpeed | crispEdges | geometricPrecision | inherit
-        if (id == CSSValueAuto || id == CSSValueOptimizeSpeed
-            || id == CSSValueCrispEdges || id == CSSValueGeometricPrecision)
-            validPrimitive = true;
-        break;
-
-    case CSSPropertyColorRendering: // optimizeQuality | inherit
-        if (id == CSSValueAuto || id == CSSValueOptimizeSpeed
-            || id == CSSValueOptimizeQuality)
-            validPrimitive = true;
-        break;
-
-    case CSSPropertyBufferedRendering: // auto | dynamic | static
-        if (id == CSSValueAuto || id == CSSValueDynamic || id == CSSValueStatic)
-            validPrimitive = true;
-        break;
-
-    case CSSPropertyColorInterpolation: // auto | sRGB | linearRGB | inherit
-    case CSSPropertyColorInterpolationFilters:
-        if (id == CSSValueAuto || id == CSSValueSRGB || id == CSSValueLinearRGB)
-            validPrimitive = true;
-        break;
-
     /* Start of supported CSS properties with validation. This is needed for parseShortHand to work
      * correctly and allows optimization in applyRule(..)
      */
 
-    case CSSPropertyTextAnchor: // start | middle | end | inherit
-        if (id == CSSValueStart || id == CSSValueMiddle || id == CSSValueEnd)
-            validPrimitive = true;
-        break;
-
     case CSSPropertyGlyphOrientationVertical: // auto | <angle> | inherit
         if (id == CSSValueAuto) {
             validPrimitive = true;
             break;
         }
     /* fallthrough intentional */
     case CSSPropertyGlyphOrientationHorizontal: // <angle> (restricted to _deg_ per SVG 1.1 spec) | inherit
         if (value->unit == CSSPrimitiveValue::CSS_DEG || value->unit == CSSPrimitiveValue::CSS_NUMBER) {
             parsedValue = CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::CSS_DEG);
 
@@ skipping 40 matching lines @@
 
         break;
 
     case CSSPropertyPaintOrder:
         if (m_valueList->size() == 1 && id == CSSValueNormal)
             validPrimitive = true;
         else if ((parsedValue = parsePaintOrder()))
             m_valueList->next();
         break;
 
-    case CSSPropertyVectorEffect: // none | non-scaling-stroke | inherit
-        if (id == CSSValueNone || id == CSSValueNonScalingStroke)
-            validPrimitive = true;
-        break;
-
-    case CSSPropertyWritingMode:
-    // lr-tb | rl_tb | tb-rl | lr | rl | tb | inherit
-        if (id == CSSValueLrTb || id == CSSValueRlTb || id == CSSValueTbRl || id == CSSValueLr || id == CSSValueRl || id == CSSValueTb)
-            validPrimitive = true;
-        break;
-
     case CSSPropertyStrokeWidth: // <length> | inherit
     case CSSPropertyStrokeDashoffset:
     case CSSPropertyCx:
     case CSSPropertyCy:
     case CSSPropertyX:
     case CSSPropertyY:
     case CSSPropertyR:
     case CSSPropertyRx:
     case CSSPropertyRy:
         validPrimitive = validUnit(value, FLength | FPercent, SVGAttributeMode);
         break;
     case CSSPropertyStrokeDasharray: // none | <dasharray> | inherit
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseSVGStrokeDasharray();
         break;
 
-    case CSSPropertyMaskType: // luminance | alpha | inherit
-        if (id == CSSValueLuminance || id == CSSValueAlpha)
-            validPrimitive = true;
-        break;
-
     /* shorthand properties */
     case CSSPropertyMarker: {
         ShorthandScope scope(this, propId);
         CSSPropertyParser::ImplicitScope implicitScope(this);
         if (!parseValue(CSSPropertyMarkerStart, important))
             return false;
         if (m_valueList->current()) {
             rollbackLastProperties(1);
             return false;
         }
@@ skipping 351 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink