[SVGDom] Initial linear gradient support

experimental/svg/model/SkSVGAttributeParser.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkParse.h"
 #include "SkSVGAttributeParser.h"
 #include "SkSVGTypes.h"
@@ skipping 95 matching lines @@
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gUnitInfo); ++i) {
         if (this->parseExpectedStringToken(gUnitInfo[i].fUnitName)) {
             *unit = gUnitInfo[i].fUnit;
             return true;
         }
     }
     return false;
 }
 
+// https://www.w3.org/TR/SVG/types.html#DataTypeColor
 bool SkSVGAttributeParser::parseNamedColorToken(SkColor* c) {
     if (const char* next = SkParse::FindNamedColor(fCurPos, strlen(fCurPos), c)) {
         fCurPos = next;
         return true;
     }
     return false;
 }
 
 bool SkSVGAttributeParser::parseHexColorToken(SkColor* c) {
     uint32_t v;
@@ skipping 15 matching lines @@
             ((v <<  0) & 0x0000000f);
         break;
     default:
         return false;
     }
 
     *c = v | 0xff000000;
     return true;
 }
 
-// https://www.w3.org/TR/SVG/types.html#DataTypeColor
+bool SkSVGAttributeParser::parseColorComponentToken(int32_t* c) {
+    fCurPos = SkParse::FindS32(fCurPos, c);
+    if (!fCurPos) {
+        return false;
+    }
+
+    if (*fCurPos == '%') {
+        *c = SkScalarRoundToInt(*c * 255.0f / 100);
+        fCurPos++;
+    }
+
+    return true;
+}
+
+bool SkSVGAttributeParser::parseRGBColorToken(SkColor* c) {
+    return this->parseParenthesized("rgb", [this](SkColor* c) -> bool {
+        int32_t r, g, b;
+        if (this->parseColorComponentToken(&r) &&
+            this->parseSepToken() &&
+            this->parseColorComponentToken(&g) &&
+            this->parseSepToken() &&
+            this->parseColorComponentToken(&b)) {
+
+            *c = SkColorSetRGB(static_cast<uint8_t>(r),
+                               static_cast<uint8_t>(g),
+                               static_cast<uint8_t>(b));
+            return true;
+        }
+        return false;
+    }, c);
+}
+
 bool SkSVGAttributeParser::parseColor(SkSVGColorType* color) {
     SkColor c;
 
     // consume preceding whitespace
     this->parseWSToken();
 
     // TODO: rgb(...)
     bool parsedValue = false;
-    if (this->parseHexColorToken(&c) || this->parseNamedColorToken(&c)) {
+    if (this->parseHexColorToken(&c)
+        || this->parseNamedColorToken(&c)
+        || this->parseRGBColorToken(&c)) {
         *color = SkSVGColorType(c);
         parsedValue = true;
 
         // consume trailing whitespace
         this->parseWSToken();
     }
 
     return parsedValue && this->parseEOSToken();
 }
 
+// https://www.w3.org/TR/SVG/linking.html#IRIReference
+bool SkSVGAttributeParser::parseIRI(SkSVGStringType* iri) {
+    // consume preceding whitespace
+    this->parseWSToken();
+
+    // we only support local fragments
+    if (!this->parseExpectedStringToken("#")) {
+        return false;
+    }
+    const auto* start = fCurPos;
+    this->advanceWhile([](char c) -> bool { return !is_eos(c) && c != ')'; });
+    if (start == fCurPos) {
+        return false;
+    }
+    *iri = SkString(start, fCurPos - start);
+    return true;
+}
+
+// https://www.w3.org/TR/SVG/types.html#DataTypeFuncIRI
+bool SkSVGAttributeParser::parseFuncIRI(SkSVGStringType* iri) {
+    return this->parseParenthesized("url", [this](SkSVGStringType* iri) -> bool {
+        return this->parseIRI(iri);
+    }, iri);
+}
+
 // https://www.w3.org/TR/SVG/types.html#DataTypeNumber
 bool SkSVGAttributeParser::parseNumber(SkSVGNumberType* number) {
     // consume WS
     this->parseWSToken();
 
     SkScalar s;
     if (this->parseScalarToken(&s)) {
         *number = SkSVGNumberType(s);
         // consume trailing separators
         this->parseSepToken();
@@ skipping 175 matching lines @@
         return false;
     }
 
     *t = SkSVGTransformType(matrix);
     return true;
 }
 
 // https://www.w3.org/TR/SVG/painting.html#SpecifyingPaint
 bool SkSVGAttributeParser::parsePaint(SkSVGPaint* paint) {
     SkSVGColorType c;
+    SkSVGStringType iri;
     bool parsedValue = false;
     if (this->parseColor(&c)) {
         *paint = SkSVGPaint(c);
         parsedValue = true;
     } else if (this->parseExpectedStringToken("none")) {
         *paint = SkSVGPaint(SkSVGPaint::Type::kNone);
         parsedValue = true;
     } else if (this->parseExpectedStringToken("currentColor")) {
         *paint = SkSVGPaint(SkSVGPaint::Type::kCurrentColor);
         parsedValue = true;
     } else if (this->parseExpectedStringToken("inherit")) {
         *paint = SkSVGPaint(SkSVGPaint::Type::kInherit);
         parsedValue = true;
+    } else if (this->parseFuncIRI(&iri)) {
+        *paint = SkSVGPaint(iri.value());
+        parsedValue = true;
     }
     return parsedValue && this->parseEOSToken();
 }
 
 // https://www.w3.org/TR/SVG/painting.html#StrokeLinecapProperty
 bool SkSVGAttributeParser::parseLineCap(SkSVGLineCap* cap) {
     static const struct {
         SkSVGLineCap::Type fType;
         const char*        fName;
     } gCapInfo[] = {
@@ skipping 69 matching lines @@
         parsedValue = true;
     }
 
     if (parsedValue && this->parseEOSToken()) {
         *points = pts;
         return true;
     }
 
     return false;
 }