[SVGDom] <polygon> & <polyline> support

experimental/svg/model/SkSVGDOM.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 "SkCanvas.h"
 #include "SkDOM.h"
 #include "SkParsePath.h"
 #include "SkString.h"
 #include "SkSVGAttributeParser.h"
 #include "SkSVGDOM.h"
 #include "SkSVGG.h"
 #include "SkSVGNode.h"
 #include "SkSVGPath.h"
+#include "SkSVGPoly.h"
 #include "SkSVGRect.h"
 #include "SkSVGRenderContext.h"
 #include "SkSVGSVG.h"
 #include "SkSVGTypes.h"
 #include "SkSVGValue.h"
 #include "SkTSearch.h"
 
 namespace {
 
 bool SetPaintAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
@@ skipping 88 matching lines @@
     SkSVGLineJoin lineJoin;
     SkSVGAttributeParser parser(stringValue);
     if (!parser.parseLineJoin(&lineJoin)) {
         return false;
     }
 
     node->setAttribute(attr, SkSVGLineJoinValue(lineJoin));
     return true;
 }
 
+bool SetPointsAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
+                        const char* stringValue) {
+    SkSVGPointsType points;
+    SkSVGAttributeParser parser(stringValue);
+    if (!parser.parsePoints(&points)) {
+        return false;
+    }
+
+    node->setAttribute(attr, SkSVGPointsValue(points));
+    return true;
+}
+
 SkString TrimmedString(const char* first, const char* last) {
     SkASSERT(first);
     SkASSERT(last);
     SkASSERT(first <= last);
 
     while (first <= last && *first <= ' ') { first++; }
     while (first <= last && *last  <= ' ') { last--; }
 
     SkASSERT(last - first + 1 >= 0);
     return SkString(first, SkTo<size_t>(last - first + 1));
@@ skipping 62 matching lines @@
 struct AttrParseInfo {
     SkSVGAttribute fAttr;
     bool (*fSetter)(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr, const char* stringValue);
 };
 
 SortedDictionaryEntry<AttrParseInfo> gAttributeParseInfo[] = {
     { "d"              , { SkSVGAttribute::kD             , SetPathDataAttribute  }},
     { "fill"           , { SkSVGAttribute::kFill          , SetPaintAttribute     }},
     { "fill-opacity"   , { SkSVGAttribute::kFillOpacity   , SetNumberAttribute    }},
     { "height"         , { SkSVGAttribute::kHeight        , SetLengthAttribute    }},
+    { "points"         , { SkSVGAttribute::kPoints        , SetPointsAttribute    }},
     { "rx"             , { SkSVGAttribute::kRx            , SetLengthAttribute    }},
     { "ry"             , { SkSVGAttribute::kRy            , SetLengthAttribute    }},
     { "stroke"         , { SkSVGAttribute::kStroke        , SetPaintAttribute     }},
     { "stroke-linecap" , { SkSVGAttribute::kStrokeLineCap , SetLineCapAttribute   }},
     { "stroke-linejoin", { SkSVGAttribute::kStrokeLineJoin, SetLineJoinAttribute  }},
     { "stroke-opacity" , { SkSVGAttribute::kStrokeOpacity , SetNumberAttribute    }},
     { "stroke-width"   , { SkSVGAttribute::kStrokeWidth   , SetLengthAttribute    }},
     { "style"          , { SkSVGAttribute::kUnknown       , SetStyleAttributes    }},
     { "transform"      , { SkSVGAttribute::kTransform     , SetTransformAttribute }},
     { "viewBox"        , { SkSVGAttribute::kViewBox       , SetViewBoxAttribute   }},
     { "width"          , { SkSVGAttribute::kWidth         , SetLengthAttribute    }},
     { "x"              , { SkSVGAttribute::kX             , SetLengthAttribute    }},
     { "y"              , { SkSVGAttribute::kY             , SetLengthAttribute    }},
 };
 
 SortedDictionaryEntry<sk_sp<SkSVGNode>(*)()> gTagFactories[] = {
-    { "g"   , []() -> sk_sp<SkSVGNode> { return SkSVGG::Make();    }},
-    { "path", []() -> sk_sp<SkSVGNode> { return SkSVGPath::Make(); }},
-    { "rect", []() -> sk_sp<SkSVGNode> { return SkSVGRect::Make(); }},
-    { "svg" , []() -> sk_sp<SkSVGNode> { return SkSVGSVG::Make();  }},
+    { "g"       , []() -> sk_sp<SkSVGNode> { return SkSVGG::Make();            }},
+    { "path"    , []() -> sk_sp<SkSVGNode> { return SkSVGPath::Make();         }},
+    { "polygon" , []() -> sk_sp<SkSVGNode> { return SkSVGPoly::MakePolygon();  }},
+    { "polyline", []() -> sk_sp<SkSVGNode> { return SkSVGPoly::MakePolyline(); }},
+    { "rect"    , []() -> sk_sp<SkSVGNode> { return SkSVGRect::Make();         }},
+    { "svg"     , []() -> sk_sp<SkSVGNode> { return SkSVGSVG::Make();          }},
 };
 
 struct ConstructionContext {
     ConstructionContext() : fParent(nullptr) { }
     ConstructionContext(const ConstructionContext& other, const sk_sp<SkSVGNode>& newParent)
         : fParent(newParent.get()) { }
 
     const SkSVGNode* fParent;
 };
 
@@ skipping 95 matching lines @@
                                SkSVGLengthContext(fContainerSize),
                                SkSVGPresentationContext());
         fRoot->render(ctx);
     }
 }
 
 void SkSVGDOM::setContainerSize(const SkSize& containerSize) {
     // TODO: inval
     fContainerSize = containerSize;
 }