[SVGDom] Parse style attributes

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 "SkParse.h"
 #include "SkParsePath.h"
+#include "SkString.h"
 #include "SkSVGDOM.h"
 #include "SkSVGG.h"
 #include "SkSVGNode.h"
 #include "SkSVGPath.h"
 #include "SkSVGSVG.h"
 #include "SkSVGValue.h"
 #include "SkTSearch.h"
 
 namespace {
 
@@ skipping 89 matching lines @@
     node->setAttribute(attr, SkSVGPathValue(path));
     return true;
 }
 
 bool SetTransformAttribute(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr,
                            const char* stringValue) {
     node->setAttribute(attr, SkSVGTransformValue(ParseTransform(stringValue)));
     return true;
 }
 
+// Breaks a "foo: bar; baz: ..." string into key:value pairs.
+class StyleIterator {
+public:
+    StyleIterator(const char* str) : fPos(str) { }
+
+    std::tuple<SkString, SkString> next() {
+        SkString name, value;
+
+        if (fPos) {
+            const char* sep = this->nextSeparator();
+            SkASSERT(*sep == ';' || *sep == '\0');
+
+            const char* valueSep = strchr(fPos, ':');
+            if (valueSep && valueSep < sep) {
+                name.set(fPos, valueSep - fPos);
+                value.set(valueSep + 1, sep - valueSep - 1);
+            }
+
+            fPos = *sep ? sep + 1 : nullptr;
+        }
+
+        return std::make_tuple(name, value);
+    }
+
+private:
+    const char* nextSeparator() const {
+        const char* sep = fPos;
+        while (*sep != ';' && *sep != '\0') {
+            sep++;
+        }
+        return sep;
+    }
+
+    const char* fPos;
+};
+
+void set_string_attribute(const sk_sp<SkSVGNode>& node, const char* name, const char* value);
+
+bool SetStyleAttributes(const sk_sp<SkSVGNode>& node, SkSVGAttribute,
+                        const char* stringValue) {
+
+    SkString name, value;
+    StyleIterator iter(stringValue);
+    for (;;) {
+        std::tie(name, value) = iter.next();
+        if (name.isEmpty()) {
+            break;
+        }
+        set_string_attribute(node, name.c_str(), value.c_str());
+    }
+
+    return true;
+}
+
 template<typename T>
 struct SortedDictionaryEntry {
     const char* fKey;
     const T     fValue;
 };
 
 struct AttrParseInfo {
     SkSVGAttribute fAttr;
     bool (*fSetter)(const sk_sp<SkSVGNode>& node, SkSVGAttribute attr, const char* stringValue);
 };
 
 SortedDictionaryEntry<AttrParseInfo> gAttributeParseInfo[] = {
-    { "d",         { SkSVGAttribute::d,         SetPathDataAttribute  }},
-    { "fill",      { SkSVGAttribute::fill,      SetPaintAttribute     }},
-    { "stroke",    { SkSVGAttribute::stroke,    SetPaintAttribute     }},
-    { "transform", { SkSVGAttribute::transform, SetTransformAttribute }},
+    { "d",         { SkSVGAttribute::kD,         SetPathDataAttribute  }},
+    { "fill",      { SkSVGAttribute::kFill,      SetPaintAttribute     }},
+    { "stroke",    { SkSVGAttribute::kStroke,    SetPaintAttribute     }},
+    { "style",     { SkSVGAttribute::kUnknown,   SetStyleAttributes    }},
+    { "transform", { SkSVGAttribute::kTransform, SetTransformAttribute }},
 };
 
 SortedDictionaryEntry<sk_sp<SkSVGNode>(*)()> gTagFactories[] = {
     { "g"   , []() -> sk_sp<SkSVGNode> { return SkSVGG::Make();    }},
     { "path", []() -> sk_sp<SkSVGNode> { return SkSVGPath::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;
 };
 
+void set_string_attribute(const sk_sp<SkSVGNode>& node, const char* name, const char* value) {
+    const int attrIndex = SkStrSearch(&gAttributeParseInfo[0].fKey,
+                                      SkTo<int>(SK_ARRAY_COUNT(gAttributeParseInfo)),
+                                      name, sizeof(gAttributeParseInfo[0]));
+    if (attrIndex < 0) {
+        SkDebugf("unhandled attribute: %s\n", name);
+        return;
+    }
+
+    SkASSERT(SkTo<size_t>(attrIndex) < SK_ARRAY_COUNT(gAttributeParseInfo));
+    const auto& attrInfo = gAttributeParseInfo[attrIndex].fValue;
+    if (!attrInfo.fSetter(node, attrInfo.fAttr, value)) {
+        SkDebugf("could not parse attribute: '%s=\"%s\"'\n", name, value);
+    }
+}
+
 void parse_node_attributes(const SkDOM& xmlDom, const SkDOM::Node* xmlNode,
                            const sk_sp<SkSVGNode>& svgNode) {
     const char* name, *value;
     SkDOM::AttrIter attrIter(xmlDom, xmlNode);
     while ((name = attrIter.next(&value))) {
-        const int attrIndex = SkStrSearch(&gAttributeParseInfo[0].fKey,
-                                          SkTo<int>(SK_ARRAY_COUNT(gAttributeParseInfo)),
-                                          name, sizeof(gAttributeParseInfo[0]));
-        if (attrIndex < 0) {
-            SkDebugf("unhandled attribute: %s\n", name);
-            continue;
-        }
-
-        SkASSERT(SkTo<size_t>(attrIndex) < SK_ARRAY_COUNT(gAttributeParseInfo));
-        const auto& attrInfo = gAttributeParseInfo[attrIndex].fValue;
-        if (!attrInfo.fSetter(svgNode, attrInfo.fAttr, value)) {
-            SkDebugf("could not parse attribute: '%s=\"%s\"'\n", name, value);
-        }
+        set_string_attribute(svgNode, name, value);
     }
 }
 
 sk_sp<SkSVGNode> construct_svg_node(const SkDOM& dom, const ConstructionContext& ctx,
                                     const SkDOM::Node* xmlNode) {
     const char* elem = dom.getName(xmlNode);
     const SkDOM::Type elemType = dom.getType(xmlNode);
 
     if (elemType == SkDOM::kText_Type) {
         SkASSERT(dom.countChildren(xmlNode) == 0);
@@ skipping 54 matching lines @@
 void SkSVGDOM::render(SkCanvas* canvas) const {
     if (fRoot) {
         fRoot->render(canvas);
     }
 }
 
 void SkSVGDOM::setContainerSize(const SkSize& containerSize) {
     // TODO: inval
     fContainerSize = containerSize;
 }