[SVGDevice] Text whitespace unittest

src/xml/SkDOM.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDOM.h"
+#include "SkStream.h"
+#include "SkXMLWriter.h"
 
 /////////////////////////////////////////////////////////////////////////
 
 #include "SkXMLParser.h"
-
 bool SkXMLParser::parse(const SkDOM& dom, const SkDOMNode* node)
 {
     const char* elemName = dom.getName(node);
 
     if (this->startElement(elemName))
         return false;
 
     SkDOM::AttrIter iter(dom, node);
     const char*     name, *value;
 
@@ skipping 166 matching lines @@
 static char* dupstr(SkChunkAlloc* chunk, const char src[])
 {
     SkASSERT(chunk && src);
     size_t  len = strlen(src);
     char*   dst = (char*)chunk->alloc(len + 1, SkChunkAlloc::kThrow_AllocFailType);
     memcpy(dst, src, len + 1);
     return dst;
 }
 
 class SkDOMParser : public SkXMLParser {
-    bool fNeedToFlush;
 public:
     SkDOMParser(SkChunkAlloc* chunk) : SkXMLParser(&fParserError), fAlloc(chunk)
     {
+        fAlloc->reset();
         fRoot = NULL;
         fLevel = 0;
         fNeedToFlush = true;
     }
     SkDOM::Node* getRoot() const { return fRoot; }
     SkXMLParserError fParserError;
+
 protected:
     void flushAttributes()
     {
+        SkASSERT(fLevel > 0);
+
         int attrCount = fAttrs.count();
 
         SkDOM::Node* node = (SkDOM::Node*)fAlloc->alloc(sizeof(SkDOM::Node) + attrCount * sizeof(SkDOM::Attr),
                                                         SkChunkAlloc::kThrow_AllocFailType);
 
         node->fName = fElemName;
         node->fFirstChild = NULL;
         node->fAttrCount = SkToU16(attrCount);
-        node->fType = SkDOM::kElement_Type;
+        node->fType = fElemType;
 
         if (fRoot == NULL)
         {
             node->fNextSibling = NULL;
             fRoot = node;
         }
         else    // this adds siblings in reverse order. gets corrected in onEndElement()
         {
             SkDOM::Node* parent = fParentStack.top();
             SkASSERT(fRoot && parent);
             node->fNextSibling = parent->fFirstChild;
             parent->fFirstChild = node;
         }
         *fParentStack.push() = node;
 
         memcpy(node->attrs(), fAttrs.begin(), attrCount * sizeof(SkDOM::Attr));
         fAttrs.reset();
 
     }
-    virtual bool onStartElement(const char elem[])
-    {
-        if (fLevel > 0 && fNeedToFlush)
-            this->flushAttributes();
-        fNeedToFlush = true;
-        fElemName = dupstr(fAlloc, elem);
-        ++fLevel;
+
+    bool onStartElement(const char elem[]) override {
+        this->startCommon(elem, SkDOM::kElement_Type);
         return false;
     }
-    virtual bool onAddAttribute(const char name[], const char value[])
-    {
+
+    bool onAddAttribute(const char name[], const char value[]) override {
         SkDOM::Attr* attr = fAttrs.append();
         attr->fName = dupstr(fAlloc, name);
         attr->fValue = dupstr(fAlloc, value);
         return false;
     }
-    virtual bool onEndElement(const char elem[])
-    {
+
+    bool onEndElement(const char elem[]) override {
         --fLevel;
         if (fNeedToFlush)
             this->flushAttributes();
         fNeedToFlush = false;
 
         SkDOM::Node* parent;
 
         fParentStack.pop(&parent);
 
         SkDOM::Node* child = parent->fFirstChild;
         SkDOM::Node* prev = NULL;
         while (child)
         {
             SkDOM::Node* next = child->fNextSibling;
             child->fNextSibling = prev;
             prev = child;
             child = next;
         }
         parent->fFirstChild = prev;
         return false;
     }
+
+    bool onText(const char text[], int len) override {
+        SkString str(text, len);
+        this->startCommon(str.c_str(), SkDOM::kText_Type);
+        this->SkDOMParser::onEndElement(str.c_str());
+
+        return false;
+    }
+
 private:
+    void startCommon(const char elem[], SkDOM::Type type) {
+        if (fLevel > 0 && fNeedToFlush)
+            this->flushAttributes();
+
+        fNeedToFlush = true;
+        fElemName = dupstr(fAlloc, elem);
+        fElemType = type;
+        ++fLevel;
+    }
+
     SkTDArray<SkDOM::Node*> fParentStack;
-    SkChunkAlloc*   fAlloc;
-    SkDOM::Node*    fRoot;
+    SkChunkAlloc*           fAlloc;
+    SkDOM::Node*            fRoot;
+    bool                    fNeedToFlush;
 
     // state needed for flushAttributes()
     SkTDArray<SkDOM::Attr>  fAttrs;
     char*                   fElemName;
+    SkDOM::Type             fElemType;
     int                     fLevel;
 };
 
 const SkDOM::Node* SkDOM::build(const char doc[], size_t len)
 {
-    fAlloc.reset();
     SkDOMParser parser(&fAlloc);
     if (!parser.parse(doc, len))
     {
         SkDEBUGCODE(SkDebugf("xml parse error, line %d\n", parser.fParserError.getLineNumber());)
         fRoot = NULL;
         fAlloc.reset();
         return NULL;
     }
     fRoot = parser.getRoot();
     return fRoot;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
 static void walk_dom(const SkDOM& dom, const SkDOM::Node* node, SkXMLParser* parser)
 {
     const char* elem = dom.getName(node);
+    if (dom.getType(node) == SkDOM::kText_Type) {
+        SkASSERT(dom.countChildren(node) == 0);
+        parser->text(elem, SkToInt(strlen(elem)));
+        return;
+    }
 
     parser->startElement(elem);
 
     SkDOM::AttrIter iter(dom, node);
     const char*     name;
     const char*     value;
     while ((name = iter.next(&value)) != NULL)
         parser->addAttribute(name, value);
 
     node = dom.getFirstChild(node, NULL);
     while (node)
     {
         walk_dom(dom, node, parser);
         node = dom.getNextSibling(node, NULL);
     }
 
     parser->endElement(elem);
 }
 
 const SkDOM::Node* SkDOM::copy(const SkDOM& dom, const SkDOM::Node* node)
 {
-    fAlloc.reset();
     SkDOMParser parser(&fAlloc);
 
     walk_dom(dom, node, &parser);
 
     fRoot = parser.getRoot();
     return fRoot;
 }
 
+SkXMLParser* SkDOM::beginParsing() {
+    SkASSERT(!fParser);
+    fParser.reset(SkNEW_ARGS(SkDOMParser, (&fAlloc)));
+
+    return fParser.get();
+}
+
+const SkDOM::Node* SkDOM::finishParsing() {
+    SkASSERT(fParser);
+    fRoot = fParser->getRoot();
+    fParser.free();
+
+    return fRoot;
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 int SkDOM::countChildren(const Node* node, const char elem[]) const
 {
     int count = 0;
 
     node = this->getFirstChild(node, elem);
     while (node)
     {
         count += 1;
@@ skipping 67 matching lines @@
 {
     const char* vstr = this->findAttr(node, name);
     bool        value;
     return vstr && SkParse::FindBool(vstr, &value) && value == target;
 }
 
 //////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 
-static void tab(int level)
-{
-    while (--level >= 0)
-        SkDebugf("\t");
-}
-
 void SkDOM::dump(const Node* node, int level) const
 {
     if (node == NULL)
         node = this->getRootNode();
-    if (node)
-    {
-        tab(level);
-        SkDebugf("<%s", this->getName(node));
 
-        const Attr* attr = node->attrs();
-        const Attr* stop = attr + node->fAttrCount;
-        for (; attr < stop; attr++)
-            SkDebugf(" %s=\"%s\"", attr->fName, attr->fValue);
-
-        const Node* child = this->getFirstChild(node);
-        if (child)
-        {
-            SkDebugf(">\n");
-            while (child)
-            {
-                this->dump(child, level+1);
-                child = this->getNextSibling(child);
-            }
-            tab(level);
-            SkDebugf("</%s>\n", node->fName);
-        }
-        else
-            SkDebugf("/>\n");
-    }
+    SkDebugWStream debugStream;
+    SkXMLStreamWriter xmlWriter(&debugStream);
+    xmlWriter.writeDOM(*this, node, false);
 }
 
 void SkDOM::UnitTest()
 {
 #ifdef SK_SUPPORT_UNITTEST
     static const char gDoc[] =
         "<root a='1' b='2'>"
             "<elem1 c='3' />"
             "<elem2 d='4' />"
             "<elem3 e='5'>"
@@ skipping 19 matching lines @@
     SkASSERT(v == NULL);
 
     SkASSERT(dom.getFirstChild(root, "elem1"));
     SkASSERT(!dom.getFirstChild(root, "subelem1"));
 
     dom.dump();
 #endif
 }
 
 #endif