remove SkDebugWStream and other cleanups

BUG=skia:

Change-Id: I06c07559b24411bd8bc4cba55bd8880f56486f76
Reviewed-on: https://skia-review.googlesource.com/6729
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>

2 files changed, 120 insertions, 240 deletions

diff --git a/src/xml/SkDOM.cpp b/src/xml/SkDOM.cpp
index 38ba669bb7..b1cf1d5360 100644
--- a/src/xml/SkDOM.cpp
+++ b/src/xml/SkDOM.cpp
@@ -8,31 +8,32 @@
 
 #include "SkDOM.h"
 #include "SkStream.h"
+#include "SkXMLParser.h"
 #include "SkXMLWriter.h"
 
-/////////////////////////////////////////////////////////////////////////
-
-#include "SkXMLParser.h"
-bool SkXMLParser::parse(const SkDOM& dom, const SkDOMNode* node)
-{
+bool SkXMLParser::parse(const SkDOM& dom, const SkDOMNode* node) {
     const char* elemName = dom.getName(node);
 
-    if (this->startElement(elemName))
+    if (this->startElement(elemName)) {
         return false;
+    }
 
     SkDOM::AttrIter iter(dom, node);
     const char*     name, *value;
 
-    while ((name = iter.next(&value)) != nullptr)
-        if (this->addAttribute(name, value))
+    while ((name = iter.next(&value)) != nullptr) {
+        if (this->addAttribute(name, value)) {
             return false;
+        }
+    }
 
-    if ((node = dom.getFirstChild(node)) != nullptr)
+    if ((node = dom.getFirstChild(node)) != nullptr) {
         do {
-            if (!this->parse(dom, node))
+            if (!this->parse(dom, node)) {
                 return false;
+            }
         } while ((node = dom.getNextSibling(node)) != nullptr);
-
+    }
     return !this->endElement(elemName);
 }
 
@@ -51,12 +52,11 @@ struct SkDOMNode {
     uint8_t     fType;
     uint8_t     fPad;
 
-    const SkDOMAttr* attrs() const
-    {
+    const SkDOMAttr* attrs() const {
         return (const SkDOMAttr*)(this + 1);
     }
-    SkDOMAttr* attrs()
-    {
+
+    SkDOMAttr* attrs() {
         return (SkDOMAttr*)(this + 1);
     }
 };
@@ -65,68 +65,60 @@ struct SkDOMNode {
 
 #define kMinChunkSize   512
 
-SkDOM::SkDOM() : fAlloc(kMinChunkSize), fRoot(nullptr)
-{
-}
+SkDOM::SkDOM() : fAlloc(kMinChunkSize), fRoot(nullptr) {}
 
-SkDOM::~SkDOM()
-{
-}
+SkDOM::~SkDOM() {}
 
-const SkDOM::Node* SkDOM::getRootNode() const
-{
+const SkDOM::Node* SkDOM::getRootNode() const {
     return fRoot;
 }
 
-const SkDOM::Node* SkDOM::getFirstChild(const Node* node, const char name[]) const
-{
+const SkDOM::Node* SkDOM::getFirstChild(const Node* node, const char name[]) const {
     SkASSERT(node);
     const Node* child = node->fFirstChild;
 
-    if (name)
-    {
-        for (; child != nullptr; child = child->fNextSibling)
-            if (!strcmp(name, child->fName))
+    if (name) {
+        for (; child != nullptr; child = child->fNextSibling) {
+            if (!strcmp(name, child->fName)) {
                 break;
+            }
+        }
     }
     return child;
 }
 
-const SkDOM::Node* SkDOM::getNextSibling(const Node* node, const char name[]) const
-{
+const SkDOM::Node* SkDOM::getNextSibling(const Node* node, const char name[]) const {
     SkASSERT(node);
     const Node* sibling = node->fNextSibling;
-    if (name)
-    {
-        for (; sibling != nullptr; sibling = sibling->fNextSibling)
-            if (!strcmp(name, sibling->fName))
+    if (name) {
+        for (; sibling != nullptr; sibling = sibling->fNextSibling) {
+            if (!strcmp(name, sibling->fName)) {
                 break;
+            }
+        }
     }
     return sibling;
 }
 
-SkDOM::Type SkDOM::getType(const Node* node) const
-{
+SkDOM::Type SkDOM::getType(const Node* node) const {
     SkASSERT(node);
     return (Type)node->fType;
 }
 
-const char* SkDOM::getName(const Node* node) const
-{
+const char* SkDOM::getName(const Node* node) const {
     SkASSERT(node);
     return node->fName;
 }
 
-const char* SkDOM::findAttr(const Node* node, const char name[]) const
-{
+const char* SkDOM::findAttr(const Node* node, const char name[]) const {
     SkASSERT(node);
     const Attr* attr = node->attrs();
     const Attr* stop = attr + node->fAttrCount;
 
-    while (attr < stop)
-    {
-        if (!strcmp(attr->fName, name))
+    while (attr < stop) {
+        if (!strcmp(attr->fName, name)) {
             return attr->fValue;
+        }
         attr += 1;
     }
     return nullptr;
@@ -134,28 +126,25 @@ const char* SkDOM::findAttr(const Node* node, const char name[]) const
 
 /////////////////////////////////////////////////////////////////////////////////////
 
-const SkDOM::Attr* SkDOM::getFirstAttr(const Node* node) const
-{
+const SkDOM::Attr* SkDOM::getFirstAttr(const Node* node) const {
     return node->fAttrCount ? node->attrs() : nullptr;
 }
 
-const SkDOM::Attr* SkDOM::getNextAttr(const Node* node, const Attr* attr) const
-{
+const SkDOM::Attr* SkDOM::getNextAttr(const Node* node, const Attr* attr) const {
     SkASSERT(node);
-    if (attr == nullptr)
+    if (attr == nullptr) {
         return nullptr;
+    }
     return (attr - node->attrs() + 1) < node->fAttrCount ? attr + 1 : nullptr;
 }
 
-const char* SkDOM::getAttrName(const Node* node, const Attr* attr) const
-{
+const char* SkDOM::getAttrName(const Node* node, const Attr* attr) const {
     SkASSERT(node);
     SkASSERT(attr);
     return attr->fName;
 }
 
-const char* SkDOM::getAttrValue(const Node* node, const Attr* attr) const
-{
+const char* SkDOM::getAttrValue(const Node* node, const Attr* attr) const {
     SkASSERT(node);
     SkASSERT(attr);
     return attr->fValue;
@@ -163,19 +152,16 @@ const char* SkDOM::getAttrValue(const Node* node, const Attr* attr) const
 
 /////////////////////////////////////////////////////////////////////////////////////
 
-SkDOM::AttrIter::AttrIter(const SkDOM&, const SkDOM::Node* node)
-{
+SkDOM::AttrIter::AttrIter(const SkDOM&, const SkDOM::Node* node) {
     SkASSERT(node);
     fAttr = node->attrs();
     fStop = fAttr + node->fAttrCount;
 }
 
-const char* SkDOM::AttrIter::next(const char** value)
-{
+const char* SkDOM::AttrIter::next(const char** value) {
     const char* name = nullptr;
 
-    if (fAttr < fStop)
-    {
+    if (fAttr < fStop) {
         name = fAttr->fName;
         if (value)
             *value = fAttr->fValue;
@@ -189,8 +175,7 @@ const char* SkDOM::AttrIter::next(const char** value)
 #include "SkXMLParser.h"
 #include "SkTDArray.h"
 
-static char* dupstr(SkChunkAlloc* chunk, const char src[])
-{
+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);
@@ -200,8 +185,7 @@ static char* dupstr(SkChunkAlloc* chunk, const char src[])
 
 class SkDOMParser : public SkXMLParser {
 public:
-    SkDOMParser(SkChunkAlloc* chunk) : SkXMLParser(&fParserError), fAlloc(chunk)
-    {
+    SkDOMParser(SkChunkAlloc* chunk) : SkXMLParser(&fParserError), fAlloc(chunk) {
         fAlloc->reset();
         fRoot = nullptr;
         fLevel = 0;
@@ -211,8 +195,7 @@ public:
     SkXMLParserError fParserError;
 
 protected:
-    void flushAttributes()
-    {
+    void flushAttributes() {
         SkASSERT(fLevel > 0);
 
         int attrCount = fAttrs.count();
@@ -225,13 +208,10 @@ protected:
         node->fAttrCount = SkToU16(attrCount);
         node->fType = fElemType;
 
-        if (fRoot == nullptr)
-        {
+        if (fRoot == nullptr) {
             node->fNextSibling = nullptr;
             fRoot = node;
-        }
-        else    // this adds siblings in reverse order. gets corrected in onEndElement()
-        {
+        } else { // this adds siblings in reverse order. gets corrected in onEndElement()
             SkDOM::Node* parent = fParentStack.top();
             SkASSERT(fRoot && parent);
             node->fNextSibling = parent->fFirstChild;
@@ -268,8 +248,7 @@ protected:
 
         SkDOM::Node* child = parent->fFirstChild;
         SkDOM::Node* prev = nullptr;
-        while (child)
-        {
+        while (child) {
             SkDOM::Node* next = child->fNextSibling;
             child->fNextSibling = prev;
             prev = child;
@@ -289,9 +268,9 @@ protected:
 
 private:
     void startCommon(const char elem[], SkDOM::Type type) {
-        if (fLevel > 0 && fNeedToFlush)
+        if (fLevel > 0 && fNeedToFlush) {
             this->flushAttributes();
-
+        }
         fNeedToFlush = true;
         fElemName = dupstr(fAlloc, elem);
         fElemType = type;
@@ -325,8 +304,7 @@ const SkDOM::Node* SkDOM::build(SkStream& docStream) {
 
 ///////////////////////////////////////////////////////////////////////////
 
-static void walk_dom(const SkDOM& dom, const SkDOM::Node* node, SkXMLParser* parser)
-{
+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);
@@ -352,8 +330,7 @@ static void walk_dom(const SkDOM& dom, const SkDOM::Node* node, SkXMLParser* par
     parser->endElement(elem);
 }
 
-const SkDOM::Node* SkDOM::copy(const SkDOM& dom, const SkDOM::Node* node)
-{
+const SkDOM::Node* SkDOM::copy(const SkDOM& dom, const SkDOM::Node* node) {
     SkDOMParser parser(&fAlloc);
 
     walk_dom(dom, node, &parser);
@@ -379,13 +356,11 @@ const SkDOM::Node* SkDOM::finishParsing() {
 
 //////////////////////////////////////////////////////////////////////////
 
-int SkDOM::countChildren(const Node* node, const char elem[]) const
-{
+int SkDOM::countChildren(const Node* node, const char elem[]) const {
     int count = 0;
 
     node = this->getFirstChild(node, elem);
-    while (node)
-    {
+    while (node) {
         count += 1;
         node = this->getNextSibling(node, elem);
     }
@@ -396,82 +371,56 @@ int SkDOM::countChildren(const Node* node, const char elem[]) const
 
 #include "SkParse.h"
 
-bool SkDOM::findS32(const Node* node, const char name[], int32_t* value) const
-{
+bool SkDOM::findS32(const Node* node, const char name[], int32_t* value) const {
     const char* vstr = this->findAttr(node, name);
     return vstr && SkParse::FindS32(vstr, value);
 }
 
-bool SkDOM::findScalars(const Node* node, const char name[], SkScalar value[], int count) const
-{
+bool SkDOM::findScalars(const Node* node, const char name[], SkScalar value[], int count) const {
     const char* vstr = this->findAttr(node, name);
     return vstr && SkParse::FindScalars(vstr, value, count);
 }
 
-bool SkDOM::findHex(const Node* node, const char name[], uint32_t* value) const
-{
+bool SkDOM::findHex(const Node* node, const char name[], uint32_t* value) const {
     const char* vstr = this->findAttr(node, name);
     return vstr && SkParse::FindHex(vstr, value);
 }
 
-bool SkDOM::findBool(const Node* node, const char name[], bool* value) const
-{
+bool SkDOM::findBool(const Node* node, const char name[], bool* value) const {
     const char* vstr = this->findAttr(node, name);
     return vstr && SkParse::FindBool(vstr, value);
 }
 
-int SkDOM::findList(const Node* node, const char name[], const char list[]) const
-{
+int SkDOM::findList(const Node* node, const char name[], const char list[]) const {
     const char* vstr = this->findAttr(node, name);
     return vstr ? SkParse::FindList(vstr, list) : -1;
 }
 
-bool SkDOM::hasAttr(const Node* node, const char name[], const char value[]) const
-{
+bool SkDOM::hasAttr(const Node* node, const char name[], const char value[]) const {
     const char* vstr = this->findAttr(node, name);
     return vstr && !strcmp(vstr, value);
 }
 
-bool SkDOM::hasS32(const Node* node, const char name[], int32_t target) const
-{
+bool SkDOM::hasS32(const Node* node, const char name[], int32_t target) const {
     const char* vstr = this->findAttr(node, name);
     int32_t     value;
     return vstr && SkParse::FindS32(vstr, &value) && value == target;
 }
 
-bool SkDOM::hasScalar(const Node* node, const char name[], SkScalar target) const
-{
+bool SkDOM::hasScalar(const Node* node, const char name[], SkScalar target) const {
     const char* vstr = this->findAttr(node, name);
     SkScalar    value;
     return vstr && SkParse::FindScalar(vstr, &value) && value == target;
 }
 
-bool SkDOM::hasHex(const Node* node, const char name[], uint32_t target) const
-{
+bool SkDOM::hasHex(const Node* node, const char name[], uint32_t target) const {
     const char* vstr = this->findAttr(node, name);
     uint32_t    value;
     return vstr && SkParse::FindHex(vstr, &value) && value == target;
 }
 
-bool SkDOM::hasBool(const Node* node, const char name[], bool target) const
-{
+bool SkDOM::hasBool(const Node* node, const char name[], bool target) const {
     const char* vstr = this->findAttr(node, name);
     bool        value;
     return vstr && SkParse::FindBool(vstr, &value) && value == target;
 }
-
-//////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-
-void SkDOM::dump(const Node* node, int level) const
-{
-    if (node == nullptr)
-        node = this->getRootNode();
-
-    SkDebugWStream debugStream;
-    SkXMLStreamWriter xmlWriter(&debugStream);
-    xmlWriter.writeDOM(*this, node, false);
-}
-
-#endif
diff --git a/src/xml/SkXMLWriter.cpp b/src/xml/SkXMLWriter.cpp
index 5ee237ff68..3a2c3d40c9 100644
--- a/src/xml/SkXMLWriter.cpp
+++ b/src/xml/SkXMLWriter.cpp
@@ -9,41 +9,35 @@
 #include "SkStream.h"
 
 SkXMLWriter::SkXMLWriter(bool doEscapeMarkup) : fDoEscapeMarkup(doEscapeMarkup)
-{
-}
+{}
 
-SkXMLWriter::~SkXMLWriter()
-{
+SkXMLWriter::~SkXMLWriter() {
     SkASSERT(fElems.count() == 0);
 }
 
-void SkXMLWriter::flush()
-{
-    while (fElems.count())
+void SkXMLWriter::flush() {
+    while (fElems.count()) {
         this->endElement();
+    }
 }
 
-void SkXMLWriter::addAttribute(const char name[], const char value[])
-{
+void SkXMLWriter::addAttribute(const char name[], const char value[]) {
     this->addAttributeLen(name, value, strlen(value));
 }
 
-void SkXMLWriter::addS32Attribute(const char name[], int32_t value)
-{
+void SkXMLWriter::addS32Attribute(const char name[], int32_t value) {
     SkString    tmp;
     tmp.appendS32(value);
     this->addAttribute(name, tmp.c_str());
 }
 
-void SkXMLWriter::addHexAttribute(const char name[], uint32_t value, int minDigits)
-{
+void SkXMLWriter::addHexAttribute(const char name[], uint32_t value, int minDigits) {
     SkString    tmp("0x");
     tmp.appendHex(value, minDigits);
     this->addAttribute(name, tmp.c_str());
 }
 
-void SkXMLWriter::addScalarAttribute(const char name[], SkScalar value)
-{
+void SkXMLWriter::addScalarAttribute(const char name[], SkScalar value) {
     SkString    tmp;
     tmp.appendScalar(value);
     this->addAttribute(name, tmp.c_str());
@@ -59,42 +53,37 @@ void SkXMLWriter::addText(const char text[], size_t length) {
     fElems.top()->fHasText = true;
 }
 
-void SkXMLWriter::doEnd(Elem* elem)
-{
+void SkXMLWriter::doEnd(Elem* elem) {
     delete elem;
 }
 
-bool SkXMLWriter::doStart(const char name[], size_t length)
-{
+bool SkXMLWriter::doStart(const char name[], size_t length) {
     int level = fElems.count();
     bool firstChild = level > 0 && !fElems[level-1]->fHasChildren;
-    if (firstChild)
+    if (firstChild) {
         fElems[level-1]->fHasChildren = true;
+    }
     Elem** elem = fElems.push();
     *elem = new Elem(name, length);
     return firstChild;
 }
 
-SkXMLWriter::Elem* SkXMLWriter::getEnd()
-{
+SkXMLWriter::Elem* SkXMLWriter::getEnd() {
     Elem* elem;
     fElems.pop(&elem);
     return elem;
 }
 
-const char* SkXMLWriter::getHeader()
-{
+const char* SkXMLWriter::getHeader() {
     static const char gHeader[] = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>";
     return gHeader;
 }
 
-void SkXMLWriter::startElement(const char name[])
-{
+void SkXMLWriter::startElement(const char name[]) {
     this->startElementLen(name, strlen(name));
 }
 
-static const char* escape_char(char c, char storage[2])
-{
+static const char* escape_char(char c, char storage[2]) {
     static const char* gEscapeChars[] = {
         "<&lt;",
         ">&gt;",
@@ -104,29 +93,26 @@ static const char* escape_char(char c, char storage[2])
     };
 
     const char** array = gEscapeChars;
-    for (unsigned i = 0; i < SK_ARRAY_COUNT(gEscapeChars); i++)
-    {
-        if (array[i][0] == c)
+    for (unsigned i = 0; i < SK_ARRAY_COUNT(gEscapeChars); i++) {
+        if (array[i][0] == c) {
             return &array[i][1];
+        }
     }
     storage[0] = c;
     storage[1] = 0;
     return storage;
 }
 
-static size_t escape_markup(char dst[], const char src[], size_t length)
-{
+static size_t escape_markup(char dst[], const char src[], size_t length) {
     size_t      extra = 0;
     const char* stop = src + length;
 
-    while (src < stop)
-    {
+    while (src < stop) {
         char        orig[2];
         const char* seq = escape_char(*src, orig);
         size_t      seqSize = strlen(seq);
 
-        if (dst)
-        {
+        if (dst) {
             memcpy(dst, seq, seqSize);
             dst += seqSize;
         }
@@ -140,15 +126,12 @@ static size_t escape_markup(char dst[], const char src[], size_t length)
     return extra;
 }
 
-void SkXMLWriter::addAttributeLen(const char name[], const char value[], size_t length)
-{
+void SkXMLWriter::addAttributeLen(const char name[], const char value[], size_t length) {
     SkString valueStr;
 
-    if (fDoEscapeMarkup)
-    {
+    if (fDoEscapeMarkup) {
         size_t   extra = escape_markup(nullptr, value, length);
-        if (extra)
-        {
+        if (extra) {
             valueStr.resize(length + extra);
             (void)escape_markup(valueStr.writable_str(), value, length);
             value = valueStr.c_str();
@@ -158,17 +141,14 @@ void SkXMLWriter::addAttributeLen(const char name[], const char value[], size_t
     this->onAddAttributeLen(name, value, length);
 }
 
-void SkXMLWriter::startElementLen(const char elem[], size_t length)
-{
+void SkXMLWriter::startElementLen(const char elem[], size_t length) {
     this->onStartElementLen(elem, length);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
 
-static void write_dom(const SkDOM& dom, const SkDOM::Node* node, SkXMLWriter* w, bool skipRoot)
-{
-    if (!skipRoot)
-    {
+static void write_dom(const SkDOM& dom, const SkDOM::Node* node, SkXMLWriter* w, bool skipRoot) {
+    if (!skipRoot) {
         const char* elem = dom.getName(node);
         if (dom.getType(node) == SkDOM::kText_Type) {
             SkASSERT(dom.countChildren(node) == 0);
@@ -181,50 +161,47 @@ static void write_dom(const SkDOM& dom, const SkDOM::Node* node, SkXMLWriter* w,
         SkDOM::AttrIter iter(dom, node);
         const char* name;
         const char* value;
-        while ((name = iter.next(&value)) != nullptr)
+        while ((name = iter.next(&value)) != nullptr) {
             w->addAttribute(name, value);
+        }
     }
 
     node = dom.getFirstChild(node, nullptr);
-    while (node)
-    {
+    while (node) {
         write_dom(dom, node, w, false);
         node = dom.getNextSibling(node, nullptr);
     }
 
-    if (!skipRoot)
+    if (!skipRoot) {
         w->endElement();
+    }
 }
 
-void SkXMLWriter::writeDOM(const SkDOM& dom, const SkDOM::Node* node, bool skipRoot)
-{
-    if (node)
+void SkXMLWriter::writeDOM(const SkDOM& dom, const SkDOM::Node* node, bool skipRoot) {
+    if (node) {
         write_dom(dom, node, this, skipRoot);
+    }
 }
 
 void SkXMLWriter::writeHeader()
-{
-}
+{}
 
 // SkXMLStreamWriter
 
-static void tab(SkWStream& stream, int level)
-{
-    for (int i = 0; i < level; i++)
+static void tab(SkWStream& stream, int level) {
+    for (int i = 0; i < level; i++) {
         stream.writeText("\t");
+    }
 }
 
 SkXMLStreamWriter::SkXMLStreamWriter(SkWStream* stream) : fStream(*stream)
-{
-}
+{}
 
-SkXMLStreamWriter::~SkXMLStreamWriter()
-{
+SkXMLStreamWriter::~SkXMLStreamWriter() {
     this->flush();
 }
 
-void SkXMLStreamWriter::onAddAttributeLen(const char name[], const char value[], size_t length)
-{
+void SkXMLStreamWriter::onAddAttributeLen(const char name[], const char value[], size_t length) {
     SkASSERT(!fElems.top()->fHasChildren && !fElems.top()->fHasText);
     fStream.writeText(" ");
     fStream.writeText(name);
@@ -246,11 +223,9 @@ void SkXMLStreamWriter::onAddText(const char text[], size_t length) {
     fStream.newline();
 }
 
-void SkXMLStreamWriter::onEndElement()
-{
+void SkXMLStreamWriter::onEndElement() {
     Elem* elem = getEnd();
-    if (elem->fHasChildren || elem->fHasText)
-    {
+    if (elem->fHasChildren || elem->fHasText) {
         tab(fStream, fElems.count());
         fStream.writeText("</");
         fStream.writeText(elem->fName.c_str());
@@ -262,11 +237,9 @@ void SkXMLStreamWriter::onEndElement()
     doEnd(elem);
 }
 
-void SkXMLStreamWriter::onStartElementLen(const char name[], size_t length)
-{
+void SkXMLStreamWriter::onStartElementLen(const char name[], size_t length) {
     int level = fElems.count();
-    if (this->doStart(name, length))
-    {
+    if (this->doStart(name, length)) {
         // the first child, need to close with >
         fStream.writeText(">");
         fStream.newline();
@@ -277,8 +250,7 @@ void SkXMLStreamWriter::onStartElementLen(const char name[], size_t length)
     fStream.write(name, length);
 }
 
-void SkXMLStreamWriter::writeHeader()
-{
+void SkXMLStreamWriter::writeHeader() {
     const char* header = getHeader();
     fStream.write(header, strlen(header));
     fStream.newline();
@@ -293,13 +265,11 @@ SkXMLParserWriter::SkXMLParserWriter(SkXMLParser* parser)
 {
 }
 
-SkXMLParserWriter::~SkXMLParserWriter()
-{
+SkXMLParserWriter::~SkXMLParserWriter() {
     this->flush();
 }
 
-void SkXMLParserWriter::onAddAttributeLen(const char name[], const char value[], size_t length)
-{
+void SkXMLParserWriter::onAddAttributeLen(const char name[], const char value[], size_t length) {
     SkASSERT(fElems.count() == 0 || (!fElems.top()->fHasChildren && !fElems.top()->fHasText));
     SkString str(value, length);
     fParser.addAttribute(name, str.c_str());
@@ -309,53 +279,14 @@ void SkXMLParserWriter::onAddText(const char text[], size_t length) {
     fParser.text(text, SkToInt(length));
 }
 
-void SkXMLParserWriter::onEndElement()
-{
+void SkXMLParserWriter::onEndElement() {
     Elem* elem = this->getEnd();
     fParser.endElement(elem->fName.c_str());
     this->doEnd(elem);
 }
 
-void SkXMLParserWriter::onStartElementLen(const char name[], size_t length)
-{
+void SkXMLParserWriter::onStartElementLen(const char name[], size_t length) {
     (void)this->doStart(name, length);
     SkString str(name, length);
     fParser.startElement(str.c_str());
 }
-
-
-////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////
-
-#ifdef SK_DEBUG
-
-void SkXMLStreamWriter::UnitTest()
-{
-#ifdef SK_SUPPORT_UNITTEST
-    SkDebugWStream  s;
-    SkXMLStreamWriter       w(&s);
-
-    w.startElement("elem0");
-    w.addAttribute("hello", "world");
-    w.addS32Attribute("dec", 42);
-    w.addHexAttribute("hex", 0x42, 3);
-    w.addScalarAttribute("scalar", -4.2f);
-    w.startElement("elem1");
-        w.endElement();
-        w.startElement("elem1");
-        w.addAttribute("name", "value");
-        w.endElement();
-        w.startElement("elem1");
-            w.startElement("elem2");
-                w.startElement("elem3");
-                w.addAttribute("name", "value");
-                w.endElement();
-            w.endElement();
-            w.startElement("elem2");
-            w.endElement();
-        w.endElement();
-    w.endElement();
-#endif
-}
-
-#endif