[SVGDom] Initial linear gradient support

experimental/svg/model/SkSVGTypes.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkSVGTypes_DEFINED
 #define SkSVGTypes_DEFINED
 
 #include "SkColor.h"
 #include "SkMatrix.h"
 #include "SkPoint.h"
 #include "SkRect.h"
 #include "SkScalar.h"
+#include "SkString.h"
 #include "SkTDArray.h"
 #include "SkTypes.h"
 
 template <typename T>
 class SkSVGPrimitiveTypeWrapper {
 public:
     SkSVGPrimitiveTypeWrapper() = default;
     explicit constexpr SkSVGPrimitiveTypeWrapper(T v) : fValue(v) {}
 
     SkSVGPrimitiveTypeWrapper(const SkSVGPrimitiveTypeWrapper&)            = default;
     SkSVGPrimitiveTypeWrapper& operator=(const SkSVGPrimitiveTypeWrapper&) = default;
     SkSVGPrimitiveTypeWrapper& operator=(const T& v) { fValue = v; return *this; }
 
     bool operator==(const SkSVGPrimitiveTypeWrapper<T>& other) const {
         return fValue == other.fValue;
     }
     bool operator!=(const SkSVGPrimitiveTypeWrapper<T>& other) const {
         return !(*this == other);
     }
 
     const T& value() const { return fValue; }
     operator const T&() const { return fValue; }
 
 private:
     T fValue;
 };
 
 using SkSVGColorType      = SkSVGPrimitiveTypeWrapper<SkColor >;
 using SkSVGNumberType     = SkSVGPrimitiveTypeWrapper<SkScalar>;
+using SkSVGStringType     = SkSVGPrimitiveTypeWrapper<SkString>;
 using SkSVGViewBoxType    = SkSVGPrimitiveTypeWrapper<SkRect  >;
 using SkSVGTransformType  = SkSVGPrimitiveTypeWrapper<SkMatrix>;
 using SkSVGPointsType     = SkSVGPrimitiveTypeWrapper<SkTDArray<SkPoint>>;
 
 class SkSVGLength {
 public:
     enum class Unit {
         kUnknown,
         kNumber,
         kPercentage,
@@ skipping 26 matching lines @@
     Unit     fUnit;
 };
 
 class SkSVGPaint {
 public:
     enum class Type {
         kNone,
         kCurrentColor,
         kColor,
         kInherit,
+        kIRI,
     };
 
-    constexpr SkSVGPaint() : fType(Type::kInherit), fColor(SK_ColorBLACK) {}
-    explicit constexpr SkSVGPaint(Type t) : fType(t), fColor(SK_ColorBLACK) {}
-    explicit constexpr SkSVGPaint(const SkSVGColorType& c) : fType(Type::kColor), fColor(c) {}
+    SkSVGPaint() : fType(Type::kInherit), fColor(SK_ColorBLACK) {}
+    explicit SkSVGPaint(Type t) : fType(t), fColor(SK_ColorBLACK) {}
+    explicit SkSVGPaint(const SkSVGColorType& c) : fType(Type::kColor), fColor(c) {}
+    explicit SkSVGPaint(const SkString& iri)
+        : fType(Type::kIRI), fColor(SK_ColorBLACK), fIRI(iri) {}
 
     SkSVGPaint(const SkSVGPaint&)            = default;
     SkSVGPaint& operator=(const SkSVGPaint&) = default;
 
     bool operator==(const SkSVGPaint& other) const {
-        return fType == other.fType && fColor == other.fColor;
+        return fType == other.fType && fColor == other.fColor && fIRI == other.fIRI;
     }
     bool operator!=(const SkSVGPaint& other) const { return !(*this == other); }
 
     Type type() const { return fType; }
     const SkSVGColorType& color() const { SkASSERT(fType == Type::kColor); return fColor; }
+    const SkString& iri() const { SkASSERT(fType == Type::kIRI); return fIRI; }
 
 private:
     Type fType;
 
+    // Logical union.
     SkSVGColorType fColor;
+    SkString       fIRI;
 };
 
 class SkSVGLineCap {
 public:
     enum class Type {
         kButt,
         kRound,
         kSquare,
         kInherit,
     };
@@ skipping 31 matching lines @@
     bool operator==(const SkSVGLineJoin& other) const { return fType == other.fType; }
     bool operator!=(const SkSVGLineJoin& other) const { return !(*this == other); }
 
     Type type() const { return fType; }
 
 private:
     Type fType;
 };
 
 #endif // SkSVGTypes_DEFINED