Support 'paint-order' from SVG2.

Source/core/css/SVGCSSParser.cpp

 /*
     Copyright (C) 2008 Eric Seidel <eric@webkit.org>
     Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
                   2004, 2005, 2007, 2010 Rob Buis <buis@kde.org>
     Copyright (C) 2005, 2006 Apple Computer, Inc.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
@@ skipping 203 matching lines @@
         else if (id == CSSValueCurrentcolor)
             parsedValue = SVGColor::createCurrentColor();
         else // TODO : svgcolor (iccColor)
             parsedValue = parseSVGColor();
 
         if (parsedValue)
             m_valueList->next();
 
         break;
 
+    case CSSPropertyPaintOrder:

[pdr., 2013/05/03 17:58:29]

When adding a property, you need to add an entry to the big switch statement in
UseCounter.cpp as well.

[Erik Dahlström (inactive), 2013/06/03 15:58:24]

is that really useful? it's a new feature, and UseCounter seems to be more for
deprecation. What I mean is, it's not going to be used much yet, so I'd think
it's kind of pointless to add it at this stage.

+        if (m_valueList->size() == 1 && id == CSSValueNormal)
+            valid_primitive = true;
+        else if (parsedValue = parsePaintOrder())

[pdr., 2013/05/03 17:58:29]

You'll need to use extra parenthesis here to make clang happy:

"else if ((parsedValue = parsePaintOrder()))"

+            m_valueList->next();
+        break;
+
     case CSSPropertyVectorEffect: // none | non-scaling-stroke | inherit
         if (id == CSSValueNone || id == CSSValueNonScalingStroke)
             valid_primitive = 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)
             valid_primitive = true;
         break;
@@ skipping 124 matching lines @@
 }
 
 PassRefPtr<CSSValue> CSSParser::parseSVGColor()
 {
     RGBA32 c = Color::transparent;
     if (!parseColorFromValue(m_valueList->current(), c))
         return 0;
     return SVGColor::createFromColor(Color(c));
 }
 
+// normal | [ fill || stroke || markers ]
+PassRefPtr<CSSValue> CSSParser::parsePaintOrder()
+{
+    if (m_valueList->size() > 3)
+        return 0;
+
+    CSSParserValue* value = m_valueList->current();
+    if (!value)
+        return 0;
+
+    RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
+
+    PaintOrderState paint_order = NORMAL;
+    bool valid = true;
+
+    for ( ; valid && value; value = m_valueList->next())

[pdr., 2013/05/03 17:58:29]

Style nit (here, and elsewhere): paintOrder instead of paint_order.

Suggestion: I think this loop would be cleaner written as:
do {
    if (valid = parsePaintOrderParameter(parsedValues.get(), value,
paint_order))
        parsedValues->append(CSSPrimitiveValue::createIdentifier(value->id));
} while (valid && (value = m_valueList->next()));

+    {
+        valid = parsePaintOrderParameter(parsedValues.get(), value, paint_order);
+        if (valid)
+            parsedValues->append(CSSPrimitiveValue::createIdentifier(value->id));
+    }
+
+    return valid ? parsedValues : 0;
+}
+
+bool CSSParser::parsePaintOrderParameter(CSSValueList* parsedValues, CSSParserValue* value, PaintOrderState& paint_order)
+{
+    switch (paint_order)
+    {
+    case NORMAL:
+        switch (value->id) {
+        case CSSValueFill:
+            paint_order = FILL;
+            return true;
+        case CSSValueStroke:
+            paint_order = STROKE;
+            return true;
+        case CSSValueMarkers:
+            paint_order = MARKERS;
+            return true;
+        default:
+            return false;
+        }
+    case FILL:
+            switch (value->id) {
+            case CSSValueStroke:
+                paint_order = FILL_STROKE;
+                return true;
+            case CSSValueMarkers:
+                paint_order = FILL_MARKERS;
+                return true;
+            default:
+                return false;
+            }
+    case STROKE:
+            switch (value->id) {
+            case CSSValueFill:
+                paint_order = STROKE_FILL;
+                return true;
+            case CSSValueMarkers:
+                paint_order = STROKE_MARKERS;
+                return true;
+            default:
+                return false;
+            }
+    case MARKERS:
+            switch (value->id) {
+            case CSSValueFill:
+                paint_order = MARKERS_FILL;
+                return true;
+            case CSSValueStroke:
+                paint_order = MARKERS_STROKE;
+                return true;
+            default:
+                return false;
+            }
+    case FILL_STROKE:
+            switch (value->id) {
+            case CSSValueMarkers:
+                paint_order = NORMAL;
+                return true;
+            default:
+                return false;
+            }
+    case FILL_MARKERS:
+            switch (value->id) {
+            case CSSValueStroke:
+                paint_order = FILL_MARKERS_STROKE;
+                return true;
+            default:
+                return false;
+            }
+    case STROKE_MARKERS:
+            switch (value->id) {
+            case CSSValueFill:
+                paint_order = STROKE_MARKERS_FILL;
+                return true;
+            default:
+                return false;
+            }
+    case STROKE_FILL:
+            switch (value->id) {
+            case CSSValueMarkers:
+                paint_order = STROKE_FILL_MARKERS;
+                return true;
+            default:
+                return false;
+            }
+    case MARKERS_FILL:
+            switch (value->id) {
+            case CSSValueStroke:
+                paint_order = MARKERS_FILL_STROKE;
+                return true;
+            default:
+                return false;
+            }
+    case MARKERS_STROKE:
+            switch (value->id) {
+            case CSSValueFill:
+                paint_order = MARKERS_STROKE_FILL;
+                return true;
+            default:
+                return false;
+            }
+    default:
+        ASSERT_NOT_REACHED();
+        return false;
+    }
+}
+
 }
 
 #endif // ENABLE(SVG)