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>

diff --git a/include/core/SkStream.h b/include/core/SkStream.h
index 83eee4708b0fa8b259a2fd25d84c8884cd6e82d6..f3c99b72a3f5d748b3cecbd12cd921f58845ee13 100644 (file)
--- a/include/core/SkStream.h
+++ b/include/core/SkStream.h
@@ -187,7 +187,6 @@ public:
         @return true on success
     */
     virtual bool write(const void* buffer, size_t size) = 0;
-    virtual void newline();
     virtual void flush();
 
     virtual size_t bytesWritten() const = 0;
@@ -210,6 +209,9 @@ public:
         SkASSERT(text);
         return this->write(text, strlen(text));
     }
+
+    bool newline() { return this->write("\n", strlen("\n")); }
+
     bool    writeDecAsText(int32_t);
     bool    writeBigDecAsText(int64_t, int minDigits = 0);
     bool    writeHexAsText(uint32_t, int minDigits = 0);
@@ -420,22 +422,4 @@ private:
     typedef SkWStream INHERITED;
 };
 
-
-class SK_API SkDebugWStream : public SkWStream {
-public:
-    SkDebugWStream() : fBytesWritten(0) {}
-
-    // overrides
-    bool write(const void* buffer, size_t size) override;
-    void newline() override;
-    size_t bytesWritten() const override { return fBytesWritten; }
-
-private:
-    size_t fBytesWritten;
-    typedef SkWStream INHERITED;
-};
-
-// for now
-typedef SkFILEStream SkURLStream;
-
 #endif

diff --git a/include/xml/SkDOM.h b/include/xml/SkDOM.h
index 7d7eafdc2dd9cccea7553fb49a2f3dd2973e768e..aa7ea784f6d758eefd533fc1938734620e4b192e 100644 (file)
--- a/include/xml/SkDOM.h
+++ b/include/xml/SkDOM.h
@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2006 The Android Open Source Project
  *
@@ -6,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-
 #ifndef SkDOM_DEFINED
 #define SkDOM_DEFINED
 
@@ -44,7 +42,7 @@ public:
         kElement_Type,
         kText_Type
     };
-    Type    getType(const Node*) const;
+    Type getType(const Node*) const;
 
     const char* getName(const Node*) const;
     const Node* getFirstChild(const Node*, const char elem[] = NULL) const;
@@ -66,8 +64,7 @@ public:
     bool findBool(const Node*, const char name[], bool*) const;
     int  findList(const Node*, const char name[], const char list[]) const;
 
-    bool findScalar(const Node* node, const char name[], SkScalar value[]) const
-    {
+    bool findScalar(const Node* node, const char name[], SkScalar value[]) const {
         return this->findScalars(node, name, value, 1);
     }
 
@@ -86,8 +83,6 @@ public:
         const Attr* fStop;
     };
 
-    SkDEBUGCODE(void dump(const Node* node = NULL, int tabLevel = 0) const;)
-
 private:
     SkChunkAlloc                 fAlloc;
     Node*                        fRoot;

diff --git a/include/xml/SkXMLWriter.h b/include/xml/SkXMLWriter.h
index 32901267de58c399fdc55a32c8adb992720fa710..b1d513c50830949916eda6824a977bb3e1da6fc4 100644 (file)
--- a/include/xml/SkXMLWriter.h
+++ b/include/xml/SkXMLWriter.h
@@ -66,7 +66,6 @@ public:
     SkXMLStreamWriter(SkWStream*);
     virtual ~SkXMLStreamWriter();
     void writeHeader() override;
-    SkDEBUGCODE(static void UnitTest();)
 
 protected:
     void onStartElementLen(const char elem[], size_t length) override;

diff --git a/src/core/SkStream.cpp b/src/core/SkStream.cpp
index e5fcc877d67012b289b68b06d1d68f6b20969ed7..202762a93dc4aed29a9549f9cbe69d277d52dc7a 100644 (file)
--- a/src/core/SkStream.cpp
+++ b/src/core/SkStream.cpp
@@ -70,11 +70,6 @@ SkWStream::~SkWStream()
 {
 }
 
-void SkWStream::newline()
-{
-    this->write("\n", 1);
-}
-
 void SkWStream::flush()
 {
 }
@@ -783,33 +778,9 @@ SkStreamAsset* SkDynamicMemoryWStream::detachAsStream() {
     return stream.release();
 }
 
-///////////////////////////////////////////////////////////////////////////////
-
-void SkDebugWStream::newline()
-{
-#if defined(SK_DEBUG)
-    SkDebugf("\n");
-    fBytesWritten++;
-#endif
-}
-
-bool SkDebugWStream::write(const void* buffer, size_t size)
-{
-#if defined(SK_DEBUG)
-    char* s = new char[size+1];
-    memcpy(s, buffer, size);
-    s[size] = 0;
-    SkDebugf("%s", s);
-    delete[] s;
-    fBytesWritten += size;
-#endif
-    return true;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-
 static sk_sp<SkData> mmap_filename(const char path[]) {
     FILE* file = sk_fopen(path, kRead_SkFILE_Flag);
     if (nullptr == file) {

diff --git a/src/xml/SkDOM.cpp b/src/xml/SkDOM.cpp
index 38ba669bb71327fb94e5a04b230328522fab0f56..b1cf1d53606147febf38878b13c897601a7418f7 100644 (file)
--- 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 5ee237ff68b40de0fa4c51638d0e6b59b06b3d65..3a2c3d40c9e658ad8c27618165f9f0d7f2a8771b 100644 (file)
--- 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