AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

remove SkDebugWStream and other cleanups

Browse Source 
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>
This commit is contained in:
Mike Reed 2017-01-07 16:16:02 -05:00 committed by Skia Commit-Bot
parent d052042580
commit c3063e54cb
6 changed files with 125 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/core/SkStream.h
View File

@ -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

9
include/xml/SkDOM.h
View File

@ -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;

1
include/xml/SkXMLWriter.h
View File

@ -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;

29
src/core/SkStream.cpp
View File

@ -70,11 +70,6 @@ SkWStream::~SkWStream()
{
}
void SkWStream::newline()
{
this->write("\n", 1);
}
void SkWStream::flush()
{
}
@ -784,31 +779,7 @@ SkStreamAsset* SkDynamicMemoryWStream::detachAsStream() {
}
///////////////////////////////////////////////////////////////////////////////
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);

185
src/xml/SkDOM.cpp
View File

@ -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

175
src/xml/SkXMLWriter.cpp
View File

@ -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