Fix style errors in core/xml/.

Source/core/xml/parser/XMLDocumentParser.cpp

 /*
  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Holger Hans Peter Freyther
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/xml/parser/XMLDocumentParser.h"
 
-#include <libxml/catalog.h>
-#include <libxml/parser.h>
-#include <libxml/parserInternals.h>
-#include <libxslt/xslt.h>
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "bindings/v8/ScriptController.h"
 #include "bindings/v8/ScriptSourceCode.h"
 #include "core/FetchInitiatorTypeNames.h"
 #include "core/HTMLNames.h"
 #include "core/XMLNSNames.h"
 #include "core/dom/CDATASection.h"
 #include "core/dom/Comment.h"
 #include "core/dom/Document.h"
@@ skipping 21 matching lines @@
 #include "platform/SharedBuffer.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/StringExtras.h"
 #include "wtf/TemporaryChange.h"
 #include "wtf/Threading.h"
 #include "wtf/Vector.h"
 #include "wtf/unicode/UTF8.h"
+#include <libxml/catalog.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxslt/xslt.h>
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // FIXME: HTMLConstructionSite has a limit of 512, should these match?
 static const unsigned maxXMLTreeDepth = 5000;
 
 static inline String toString(const xmlChar* string, size_t length)
 {
@@ skipping 37 matching lines @@
     PendingStartElementNSCallback(const AtomicString& localName, const AtomicString& prefix, const AtomicString& uri,
         int namespaceCount, const xmlChar** namespaces, int attributeCount, int defaultedCount, const xmlChar** attributes)
         : m_localName(localName)
         , m_prefix(prefix)
         , m_uri(uri)
         , m_namespaceCount(namespaceCount)
         , m_attributeCount(attributeCount)
         , m_defaultedCount(defaultedCount)
     {
         m_namespaces = static_cast<xmlChar**>(xmlMalloc(sizeof(xmlChar*) * namespaceCount * 2));
-        for (int i = 0; i < namespaceCount * 2 ; i++)
+        for (int i = 0; i < namespaceCount * 2 ; ++i)
             m_namespaces[i] = xmlStrdup(namespaces[i]);
         m_attributes = static_cast<xmlChar**>(xmlMalloc(sizeof(xmlChar*) * attributeCount * 5));
-        for (int i = 0; i < attributeCount; i++) {
+        for (int i = 0; i < attributeCount; ++i) {
             // Each attribute has 5 elements in the array:
             // name, prefix, uri, value and an end pointer.
-            for (int j = 0; j < 3; j++)
+            for (int j = 0; j < 3; ++j)
                 m_attributes[i * 5 + j] = xmlStrdup(attributes[i * 5 + j]);
             int length = attributes[i * 5 + 4] - attributes[i * 5 + 3];
             m_attributes[i * 5 + 3] = xmlStrndup(attributes[i * 5 + 3], length);
             m_attributes[i * 5 + 4] = m_attributes[i * 5 + 3] + length;
         }
     }
 
     virtual ~PendingStartElementNSCallback()
     {
-        for (int i = 0; i < m_namespaceCount * 2; i++)
+        for (int i = 0; i < m_namespaceCount * 2; ++i)
             xmlFree(m_namespaces[i]);
         xmlFree(m_namespaces);
-        for (int i = 0; i < m_attributeCount; i++)
-            for (int j = 0; j < 4; j++)
+        for (int i = 0; i < m_attributeCount; ++i)
+            for (int j = 0; j < 4; ++j)
                 xmlFree(m_attributes[i * 5 + j]);
         xmlFree(m_attributes);
     }
 
     virtual void call(XMLDocumentParser* parser) OVERRIDE
     {
         parser->startElementNs(m_localName, m_prefix, m_uri,
-                                  m_namespaceCount, const_cast<const xmlChar**>(m_namespaces),
-                                  m_attributeCount, m_defaultedCount, const_cast<const xmlChar**>(m_attributes));
+            m_namespaceCount, const_cast<const xmlChar**>(m_namespaces),
+            m_attributeCount, m_defaultedCount, const_cast<const xmlChar**>(m_attributes));
     }
 
 private:
     AtomicString m_localName;
     AtomicString m_prefix;
     AtomicString m_uri;
     int m_namespaceCount;
     xmlChar** m_namespaces;
     int m_attributeCount;
     int m_defaultedCount;
@@ skipping 126 matching lines @@
 {
     ASSERT(n);
     ASSERT(m_currentNode);
 #if !ENABLE(OILPAN)
     if (n != document())
         n->ref();
 #endif
     m_currentNodeStack.append(m_currentNode);
     m_currentNode = n;
     if (m_currentNodeStack.size() > maxXMLTreeDepth)
-        handleError(XMLErrors::fatal, "Excessive node nesting.", textPosition());
+        handleError(XMLErrors::ErrorTypeFatal, "Excessive node nesting.", textPosition());
 }
 
 void XMLDocumentParser::popCurrentNode()
 {
     if (!m_currentNode)
         return;
     ASSERT(m_currentNodeStack.size());
 #if !ENABLE(OILPAN)
     if (m_currentNode != document())
         m_currentNode->deref();
@@ skipping 44 matching lines @@
     // JavaScript can detach the parser. Make sure this is not released
     // before the end of this method.
     RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
 
     doWrite(source.toString());
 }
 
 void XMLDocumentParser::handleError(XMLErrors::ErrorType type, const char* formattedMessage, TextPosition position)
 {
     m_xmlErrors.handleError(type, formattedMessage, position);
-    if (type != XMLErrors::warning)
+    if (type != XMLErrors::ErrorTypeWarning)
         m_sawError = true;
-    if (type == XMLErrors::fatal)
+    if (type == XMLErrors::ErrorTypeFatal)
         stopParsing();
 }
 
 void XMLDocumentParser::enterText()
 {
     ASSERT(m_bufferedText.size() == 0);
     ASSERT(!m_leafTextNode);
     m_leafTextNode = Text::create(m_currentNode->document(), "");
     m_currentNode->parserAppendChild(m_leafTextNode.get());
 }
@@ skipping 27 matching lines @@
 
     // doEnd() call above can detach the parser and null out its document.
     // In that case, we just bail out.
     if (isDetached())
         return;
 
     // doEnd() could process a script tag, thus pausing parsing.
     if (m_parserPaused)
         return;
 
-    if (m_sawError)
+    if (m_sawError) {
         insertErrorMessageBlock();
-    else {
+    } else {
         exitText();
         document()->styleResolverChanged();
     }
 
     if (isParsing())
         prepareToStopParsing();
     document()->setReadyState(Document::Interactive);
     clearCurrentNodeStack();
     document()->finishedParsing();
 }
@@ skipping 25 matching lines @@
 
     m_pendingScript->removeClient(this);
     m_pendingScript = 0;
 
     RefPtrWillBeRawPtr<Element> e = m_scriptElement;
     m_scriptElement = nullptr;
 
     ScriptLoader* scriptLoader = toScriptLoaderIfPossible(e.get());
     ASSERT(scriptLoader);
 
-    // JavaScript can detach this parser, make sure it's kept alive even if detached.
+    // JavaScript can detach this parser, make sure it's kept alive even if
+    // detached.
     RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
 
-    if (errorOccurred)
+    if (errorOccurred) {
         scriptLoader->dispatchErrorEvent();
-    else if (!wasCanceled) {
+    } else if (!wasCanceled) {
         scriptLoader->executeScript(sourceCode);
         scriptLoader->dispatchLoadEvent();
     }
 
     m_scriptElement = nullptr;
 
     if (!isDetached() && !m_requestingScript)
         resumeParsing();
 }
 
 bool XMLDocumentParser::isWaitingForScripts() const
 {
     return m_pendingScript;
 }
 
 void XMLDocumentParser::pauseParsing()
 {
-    if (m_parsingFragment)
-        return;
-
-    m_parserPaused = true;
+    if (!m_parsingFragment)
+        m_parserPaused = true;
 }
 
 bool XMLDocumentParser::parseDocumentFragment(const String& chunk, DocumentFragment* fragment, Element* contextElement, ParserContentPolicy parserContentPolicy)
 {
     if (!chunk.length())
         return true;
 
     // FIXME: We need to implement the HTML5 XML Fragment parsing algorithm:
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-xhtml-syntax.html#xml-fragment-parsing-algorithm
     // For now we have a hack for script/style innerHTML support:
     if (contextElement && (contextElement->hasLocalName(HTMLNames::scriptTag) || contextElement->hasLocalName(HTMLNames::styleTag))) {
         fragment->parserAppendChild(fragment->document().createTextNode(chunk));
         return true;
     }
 
     RefPtrWillBeRawPtr<XMLDocumentParser> parser = XMLDocumentParser::create(fragment, contextElement, parserContentPolicy);
     bool wellFormed = parser->appendFragmentSource(chunk);
-    // Do not call finish().  Current finish() and doEnd() implementations touch the main Document/loader
-    // and can cause crashes in the fragment case.
-    parser->detach(); // Allows ~DocumentParser to assert it was detached before destruction.
-    return wellFormed; // appendFragmentSource()'s wellFormed is more permissive than wellFormed().
+
+    // Do not call finish(). Current finish() and doEnd() implementations touch
+    // the main Document/loader and can cause crashes in the fragment case.
+
+    // Allows ~DocumentParser to assert it was detached before destruction.
+    parser->detach();
+    // appendFragmentSource()'s wellFormed is more permissive than wellFormed().
+    return wellFormed;
 }
 
 static int globalDescriptor = 0;
 static ThreadIdentifier libxmlLoaderThread = 0;
 
 static int matchFunc(const char*)
 {
-    // Only match loads initiated due to uses of libxml2 from within XMLDocumentParser to avoid
-    // interfering with client applications that also use libxml2.  http://bugs.webkit.org/show_bug.cgi?id=17353
+    // Only match loads initiated due to uses of libxml2 from within
+    // XMLDocumentParser to avoid interfering with client applications that also
+    // use libxml2. http://bugs.webkit.org/show_bug.cgi?id=17353
     return XMLDocumentParserScope::currentFetcher && currentThread() == libxmlLoaderThread;
 }
 
 static inline void setAttributes(Element* element, Vector<Attribute>& attributeVector, ParserContentPolicy parserContentPolicy)
 {
     if (!scriptingContentIsAllowed(parserContentPolicy))
         element->stripScriptingAttributes(attributeVector);
     element->parserSetAttributes(attributeVector);
 }
 
 static void switchEncoding(xmlParserCtxtPtr ctxt, bool is8Bit)
 {
     // Hack around libxml2's lack of encoding overide support by manually
-    // resetting the encoding to UTF-16 before every chunk.  Otherwise libxml
-    // will detect <?xml version="1.0" encoding="<encoding name>"?> blocks
-    // and switch encodings, causing the parse to fail.
+    // resetting the encoding to UTF-16 before every chunk. Otherwise libxml
+    // will detect <?xml version="1.0" encoding="<encoding name>"?> blocks and
+    // switch encodings, causing the parse to fail.
     if (is8Bit) {
         xmlSwitchEncoding(ctxt, XML_CHAR_ENCODING_8859_1);
         return;
     }
 
     const UChar BOM = 0xFEFF;
     const unsigned char BOMHighByte = *reinterpret_cast<const unsigned char*>(&BOM);
     xmlSwitchEncoding(ctxt, BOMHighByte == 0xFF ? XML_CHAR_ENCODING_UTF16LE : XML_CHAR_ENCODING_UTF16BE);
 }
 
@@ skipping 29 matching lines @@
 
 static bool shouldAllowExternalLoad(const KURL& url)
 {
     String urlString = url.string();
 
     // This isn't really necessary now that initializeLibXMLIfNecessary
     // disables catalog support in libxml, but keeping it for defense in depth.
     if (isLibxmlDefaultCatalogFile(url))
         return false;
 
-    // The most common DTD.  There isn't much point in hammering www.w3c.org
-    // by requesting this URL for every XHTML document.
+    // The most common DTD. There isn't much point in hammering www.w3c.org by
+    // requesting this URL for every XHTML document.
     if (urlString.startsWith("http://www.w3.org/TR/xhtml", false))
         return false;
 
     // Similarly, there isn't much point in requesting the SVG DTD.
     if (urlString.startsWith("http://www.w3.org/Graphics/SVG", false))
         return false;
 
-    // The libxml doesn't give us a lot of context for deciding whether to
-    // allow this request.  In the worst case, this load could be for an
-    // external entity and the resulting document could simply read the
-    // retrieved content.  If we had more context, we could potentially allow
-    // the parser to load a DTD.  As things stand, we take the conservative
-    // route and allow same-origin requests only.
+    // The libxml doesn't give us a lot of context for deciding whether to allow
+    // this request. In the worst case, this load could be for an external
+    // entity and the resulting document could simply read the retrieved
+    // content. If we had more context, we could potentially allow the parser to
+    // load a DTD. As things stand, we take the conservative route and allow
+    // same-origin requests only.
     if (!XMLDocumentParserScope::currentFetcher->document()->securityOrigin()->canRequest(url)) {
         XMLDocumentParserScope::currentFetcher->printAccessDeniedMessage(url);
         return false;
     }
 
     return true;
 }
 
 static void* openFunc(const char* uri)
 {
@@ skipping 240 matching lines @@
 
 void XMLDocumentParser::doWrite(const String& parseString)
 {
     ASSERT(!isDetached());
     if (!m_context)
         initializeParserContext();
 
     // Protect the libxml context from deletion during a callback
     RefPtr<XMLParserContext> context = m_context;
 
-    // libXML throws an error if you try to switch the encoding for an empty string.
+    // libXML throws an error if you try to switch the encoding for an empty
+    // string.
     if (parseString.length()) {
         // JavaScript may cause the parser to detach during parseChunk
         // keep this alive until this function is done.
         RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
 
         XMLDocumentParserScope scope(document()->fetcher());
         TemporaryChange<bool> encodingScope(m_isCurrentlyParsing8BitChunk, parseString.is8Bit());
         parseChunk(context->context(), parseString);
 
         // JavaScript (which may be run under the parseChunk callstack) may
         // cause the parser to be stopped or detached.
         if (isStopped())
             return;
     }
 
-    // FIXME: Why is this here?  And why is it after we process the passed source?
+    // FIXME: Why is this here? And why is it after we process the passed
+    // source?
     if (document()->sawDecodingError()) {
         // If the decoder saw an error, report it as fatal (stops parsing)
         TextPosition position(OrdinalNumber::fromOneBasedInt(context->context()->input->line), OrdinalNumber::fromOneBasedInt(context->context()->input->col));
-        handleError(XMLErrors::fatal, "Encoding error", position);
+        handleError(XMLErrors::ErrorTypeFatal, "Encoding error", position);
     }
 }
 
-struct _xmlSAX2Namespace {
+struct xmlSAX2Namespace {
     const xmlChar* prefix;
     const xmlChar* uri;
 };
-typedef struct _xmlSAX2Namespace xmlSAX2Namespace;
 
 static inline void handleNamespaceAttributes(Vector<Attribute>& prefixedAttributes, const xmlChar** libxmlNamespaces, int nbNamespaces, ExceptionState& exceptionState)
 {
     xmlSAX2Namespace* namespaces = reinterpret_cast<xmlSAX2Namespace*>(libxmlNamespaces);
-    for (int i = 0; i < nbNamespaces; i++) {
+    for (int i = 0; i < nbNamespaces; ++i) {
         AtomicString namespaceQName = xmlnsAtom;
         AtomicString namespaceURI = toAtomicString(namespaces[i].uri);
         if (namespaces[i].prefix)
             namespaceQName = "xmlns:" + toString(namespaces[i].prefix);
 
         QualifiedName parsedName = anyName;
         if (!Element::parseAttributeName(parsedName, XMLNSNames::xmlnsNamespaceURI, namespaceQName, exceptionState))
             return;
 
         prefixedAttributes.append(Attribute(parsedName, namespaceURI));
     }
 }
 
-struct _xmlSAX2Attributes {
+struct xmlSAX2Attributes {
     const xmlChar* localname;
     const xmlChar* prefix;
     const xmlChar* uri;
     const xmlChar* value;
     const xmlChar* end;
 };
-typedef struct _xmlSAX2Attributes xmlSAX2Attributes;
 
 static inline void handleElementAttributes(Vector<Attribute>& prefixedAttributes, const xmlChar** libxmlAttributes, int nbAttributes, ExceptionState& exceptionState)
 {
     xmlSAX2Attributes* attributes = reinterpret_cast<xmlSAX2Attributes*>(libxmlAttributes);
-    for (int i = 0; i < nbAttributes; i++) {
+    for (int i = 0; i < nbAttributes; ++i) {
         int valueLength = static_cast<int>(attributes[i].end - attributes[i].value);
         AtomicString attrValue = toAtomicString(attributes[i].value, valueLength);
         String attrPrefix = toString(attributes[i].prefix);
         AtomicString attrURI = attrPrefix.isEmpty() ? AtomicString() : toAtomicString(attributes[i].uri);
         AtomicString attrQName = attrPrefix.isEmpty() ? toAtomicString(attributes[i].localname) : attrPrefix + ":" + toString(attributes[i].localname);
 
         QualifiedName parsedName = anyName;
         if (!Element::parseAttributeName(parsedName, attrURI, attrQName, exceptionState))
             return;
 
@@ skipping 72 matching lines @@
 void XMLDocumentParser::endElementNs()
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks.append(adoptPtr(new PendingEndElementNSCallback()));
         return;
     }
 
-    // JavaScript can detach the parser.  Make sure this is not released
-    // before the end of this method.
+    // JavaScript can detach the parser. Make sure this is not released before
+    // the end of this method.
     RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
 
     exitText();
 
     RefPtrWillBeRawPtr<ContainerNode> n = m_currentNode;
     if (m_currentNode->isElementNode())
         toElement(n.get())->finishParsingChildren();
 
     if (!scriptingContentIsAllowed(parserContentPolicy()) && n->isElementNode() && toScriptLoaderIfPossible(toElement(n))) {
         popCurrentNode();
@@ skipping 29 matching lines @@
         // FIXME: Script execution should be shared between
         // the libxml2 and Qt XMLDocumentParser implementations.
 
         if (scriptLoader->readyToBeParserExecuted()) {
             scriptLoader->executeScript(ScriptSourceCode(scriptLoader->scriptContent(), document()->url(), m_scriptStartPosition));
         } else if (scriptLoader->willBeParserExecuted()) {
             m_pendingScript = scriptLoader->resource();
             m_scriptElement = element;
             m_pendingScript->addClient(this);
 
-            // m_pendingScript will be 0 if script was already loaded and addClient() executed it.
+            // m_pendingScript will be 0 if script was already loaded and
+            // addClient() executed it.
             if (m_pendingScript)
                 pauseParsing();
         } else {
             m_scriptElement = nullptr;
         }
 
         // JavaScript may have detached the parser
         if (isDetached())
             return;
     }
@@ skipping 31 matching lines @@
 
     handleError(type, formattedMessage, textPosition());
 }
 
 void XMLDocumentParser::processingInstruction(const String& target, const String& data)
 {
     if (isStopped())
         return;
 
     if (m_parserPaused) {
-        m_pendingCallbacks.append(adoptPtr(new PendingProcessingInstructionCallback(target ,data)));
+        m_pendingCallbacks.append(adoptPtr(new PendingProcessingInstructionCallback(target, data)));
         return;
     }
 
     exitText();
 
     // ### handle exceptions
     TrackExceptionState exceptionState;
     RefPtrWillBeRawPtr<ProcessingInstruction> pi = m_currentNode->document().createProcessingInstruction(target, data, exceptionState);
     if (exceptionState.hadException())
         return;
 
     pi->setCreatedByParser(true);
 
     m_currentNode->parserAppendChild(pi.get());
 
     pi->setCreatedByParser(false);
 
     if (pi->isCSS())
         m_sawCSS = true;
 
     if (!RuntimeEnabledFeatures::xsltEnabled())
         return;
 
     m_sawXSLTransform = !m_sawFirstElement && pi->isXSL();
     if (m_sawXSLTransform && !document()->transformSourceDocument()) {
-        // This behavior is very tricky. We call stopParsing() here because we want to stop processing the document
-        // until we're ready to apply the transform, but we actually still want to be fed decoded string pieces to
-        // accumulate in m_originalSourceForTransform. So, we call stopParsing() here and
-        // check isStopped() in element callbacks.
+        // This behavior is very tricky. We call stopParsing() here because we
+        // want to stop processing the document until we're ready to apply the
+        // transform, but we actually still want to be fed decoded string pieces
+        // to accumulate in m_originalSourceForTransform. So, we call
+        // stopParsing() here and check isStopped() in element callbacks.
         // FIXME: This contradicts the contract of DocumentParser.
         stopParsing();
     }
 }
 
 void XMLDocumentParser::cdataBlock(const String& text)
 {
     if (isStopped())
         return;
 
@@ skipping 24 matching lines @@
 
 enum StandaloneInfo {
     StandaloneUnspecified = -2,
     NoXMlDeclaration,
     StandaloneNo,
     StandaloneYes
 };
 
 void XMLDocumentParser::startDocument(const String& version, const String& encoding, int standalone)
 {
-    StandaloneInfo standaloneInfo = (StandaloneInfo)standalone;
+    StandaloneInfo standaloneInfo = static_cast<StandaloneInfo>(standalone);
     if (standaloneInfo == NoXMlDeclaration) {
         document()->setHasXMLDeclaration(false);
         return;
     }
 
     if (!version.isNull())
         document()->setXMLVersion(version, ASSERT_NO_EXCEPTION);
     if (standalone != StandaloneUnspecified)
         document()->setXMLStandalone(standaloneInfo == StandaloneYes, ASSERT_NO_EXCEPTION);
     if (!encoding.isNull())
@@ skipping 54 matching lines @@
 static void commentHandler(void* closure, const xmlChar* text)
 {
     getParser(closure)->comment(toString(text));
 }
 
 WTF_ATTRIBUTE_PRINTF(2, 3)
 static void warningHandler(void* closure, const char* message, ...)
 {
     va_list args;
     va_start(args, message);
-    getParser(closure)->error(XMLErrors::warning, message, args);
+    getParser(closure)->error(XMLErrors::ErrorTypeWarning, message, args);
     va_end(args);
 }
 
 WTF_ATTRIBUTE_PRINTF(2, 3)
 static void fatalErrorHandler(void* closure, const char* message, ...)
 {
     va_list args;
     va_start(args, message);
-    getParser(closure)->error(XMLErrors::fatal, message, args);
+    getParser(closure)->error(XMLErrors::ErrorTypeFatal, message, args);
     va_end(args);
 }
 
 WTF_ATTRIBUTE_PRINTF(2, 3)
 static void normalErrorHandler(void* closure, const char* message, ...)
 {
     va_list args;
     va_start(args, message);
-    getParser(closure)->error(XMLErrors::nonFatal, message, args);
+    getParser(closure)->error(XMLErrors::ErrorTypeNonFatal, message, args);
     va_end(args);
 }
 
-// Using a static entity and marking it XML_INTERNAL_PREDEFINED_ENTITY is
-// a hack to avoid malloc/free. Using a global variable like this could cause trouble
+// Using a static entity and marking it XML_INTERNAL_PREDEFINED_ENTITY is a hack
+// to avoid malloc/free. Using a global variable like this could cause trouble
 // if libxml implementation details were to change
 static xmlChar sharedXHTMLEntityResult[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
 
 static xmlEntityPtr sharedXHTMLEntity()
 {
     static xmlEntity entity;
     if (!entity.type) {
         entity.type = XML_ENTITY_DECL;
         entity.orig = sharedXHTMLEntityResult;
         entity.content = sharedXHTMLEntityResult;
@@ skipping 71 matching lines @@
 
 static void internalSubsetHandler(void* closure, const xmlChar* name, const xmlChar* externalID, const xmlChar* systemID)
 {
     getParser(closure)->internalSubset(toString(name), toString(externalID), toString(systemID));
     xmlSAX2InternalSubset(closure, name, externalID, systemID);
 }
 
 static void externalSubsetHandler(void* closure, const xmlChar*, const xmlChar* externalId, const xmlChar*)
 {
     String extId = toString(externalId);
-    if ((extId == "-//W3C//DTD XHTML 1.0 Transitional//EN")
-        || (extId == "-//W3C//DTD XHTML 1.1//EN")
-        || (extId == "-//W3C//DTD XHTML 1.0 Strict//EN")
-        || (extId == "-//W3C//DTD XHTML 1.0 Frameset//EN")
-        || (extId == "-//W3C//DTD XHTML Basic 1.0//EN")
-        || (extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN")
-        || (extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN")
-        || (extId == "-//WAPFORUM//DTD XHTML Mobile 1.0//EN")
-        || (extId == "-//WAPFORUM//DTD XHTML Mobile 1.1//EN")
-        || (extId == "-//WAPFORUM//DTD XHTML Mobile 1.2//EN"))
-        getParser(closure)->setIsXHTMLDocument(true); // controls if we replace entities or not.
+    if (extId == "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        || extId == "-//W3C//DTD XHTML 1.1//EN"
+        || extId == "-//W3C//DTD XHTML 1.0 Strict//EN"
+        || extId == "-//W3C//DTD XHTML 1.0 Frameset//EN"
+        || extId == "-//W3C//DTD XHTML Basic 1.0//EN"
+        || extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN"
+        || extId == "-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN"
+        || extId == "-//WAPFORUM//DTD XHTML Mobile 1.0//EN"
+        || extId == "-//WAPFORUM//DTD XHTML Mobile 1.1//EN"
+        || extId == "-//WAPFORUM//DTD XHTML Mobile 1.2//EN") {
+        // Controls if we replace entities or not.
+        getParser(closure)->setIsXHTMLDocument(true);
+    }
 }
 
 static void ignorableWhitespaceHandler(void*, const xmlChar*, int)
 {
-    // nothing to do, but we need this to work around a crasher
+    // Nothing to do, but we need this to work around a crasher.
     // http://bugzilla.gnome.org/show_bug.cgi?id=172255
     // http://bugs.webkit.org/show_bug.cgi?id=5792
 }
 
 void XMLDocumentParser::initializeParserContext(const CString& chunk)
 {
     xmlSAXHandler sax;
     memset(&sax, 0, sizeof(sax));
 
     sax.error = normalErrorHandler;
@@ skipping 13 matching lines @@
     sax.ignorableWhitespace = ignorableWhitespaceHandler;
     sax.entityDecl = xmlSAX2EntityDecl;
     sax.initialized = XML_SAX2_MAGIC;
     DocumentParser::startParsing();
     m_sawError = false;
     m_sawCSS = false;
     m_sawXSLTransform = false;
     m_sawFirstElement = false;
 
     XMLDocumentParserScope scope(document()->fetcher());
-    if (m_parsingFragment)
+    if (m_parsingFragment) {
         m_context = XMLParserContext::createMemoryParser(&sax, this, chunk);
-    else {
+    } else {
         ASSERT(!chunk.data());
         m_context = XMLParserContext::createStringParser(&sax, this);
     }
 }
 
 void XMLDocumentParser::doEnd()
 {
     if (!isStopped()) {
         if (m_context) {
             // Tell libxml we're done.
             {
                 XMLDocumentParserScope scope(document()->fetcher());
                 finishParsing(context());
             }
 
             m_context = nullptr;
         }
     }
 
     bool xmlViewerMode = !m_sawError && !m_sawCSS && !m_sawXSLTransform && hasNoStyleInformation(document());
     if (xmlViewerMode) {
         XMLTreeViewer xmlTreeViewer(document());
         xmlTreeViewer.transformDocumentToTreeView();
     } else if (m_sawXSLTransform) {
         xmlDocPtr doc = xmlDocPtrForString(document()->fetcher(), m_originalSourceForTransform.toString(), document()->url().string());
         document()->setTransformSource(adoptPtr(new TransformSource(doc)));
-
-        document()->setParsing(false); // Make the document think it's done, so it will apply XSL stylesheets.
+        // Make the document think it's done, so it will apply XSL stylesheets.
+        document()->setParsing(false);
         document()->styleResolverChanged();
 
-        // styleResolverChanged() call can detach the parser and null out its document.
-        // In that case, we just bail out.
+        // styleResolverChanged() call can detach the parser and null out its
+        // document. In that case, we just bail out.
         if (isDetached())
             return;
 
         document()->setParsing(true);
         DocumentParser::stopParsing();
     }
 }
 
 xmlDocPtr xmlDocPtrForString(ResourceFetcher* fetcher, const String& source, const String& url)
 {
     if (source.isEmpty())
         return 0;
     // Parse in a single chunk into an xmlDocPtr
-    // FIXME: Hook up error handlers so that a failure to parse the main document results in
-    // good error messages.
+    // FIXME: Hook up error handlers so that a failure to parse the main
+    // document results in good error messages.
     XMLDocumentParserScope scope(fetcher, errorFunc, 0);
     XMLParserInput input(source);
     return xmlReadMemory(input.data(), input.size(), url.latin1().data(), input.encoding(), XSLT_PARSE_OPTIONS);
 }
 
 OrdinalNumber XMLDocumentParser::lineNumber() const
 {
     return OrdinalNumber::fromOneBasedInt(context() ? context()->input->line : 1);
 }
 
 OrdinalNumber XMLDocumentParser::columnNumber() const
 {
     return OrdinalNumber::fromOneBasedInt(context() ? context()->input->col : 1);
 }
 
 TextPosition XMLDocumentParser::textPosition() const
 {
     xmlParserCtxtPtr context = this->context();
     if (!context)
         return TextPosition::minimumPosition();
-    return TextPosition(OrdinalNumber::fromOneBasedInt(context->input->line),
-                        OrdinalNumber::fromOneBasedInt(context->input->col));
+    return TextPosition(OrdinalNumber::fromOneBasedInt(context->input->line), OrdinalNumber::fromOneBasedInt(context->input->col));
 }
 
 void XMLDocumentParser::stopParsing()
 {
     DocumentParser::stopParsing();
     if (context())
         xmlStopParser(context());
 }
 
 void XMLDocumentParser::resumeParsing()
@@ skipping 27 matching lines @@
         end();
 }
 
 bool XMLDocumentParser::appendFragmentSource(const String& chunk)
 {
     ASSERT(!m_context);
     ASSERT(m_parsingFragment);
 
     CString chunkAsUtf8 = chunk.utf8();
 
-    // libxml2 takes an int for a length, and therefore can't handle XML chunks larger than 2 GiB.
+    // libxml2 takes an int for a length, and therefore can't handle XML chunks
+    // larger than 2 GiB.
     if (chunkAsUtf8.length() > INT_MAX)
         return false;
 
     initializeParserContext(chunkAsUtf8);
     xmlParseContent(context());
     endDocument(); // Close any open text nodes.
 
-    // FIXME: If this code is actually needed, it should probably move to finish()
-    // XMLDocumentParserQt has a similar check (m_stream.error() == QXmlStreamReader::PrematureEndOfDocumentError) in doEnd().
-    // Check if all the chunk has been processed.
+    // FIXME: If this code is actually needed, it should probably move to
+    // finish()
+    // XMLDocumentParserQt has a similar check (m_stream.error() ==
+    // QXmlStreamReader::PrematureEndOfDocumentError) in doEnd(). Check if all
+    // the chunk has been processed.
     long bytesProcessed = xmlByteConsumed(context());
-    if (bytesProcessed == -1 || ((unsigned long)bytesProcessed) != chunkAsUtf8.length()) {
-        // FIXME: I don't believe we can hit this case without also having seen an error or a null byte.
-        // If we hit this ASSERT, we've found a test case which demonstrates the need for this code.
+    if (bytesProcessed == -1 || static_cast<unsigned long>(bytesProcessed) != chunkAsUtf8.length()) {
+        // FIXME: I don't believe we can hit this case without also having seen
+        // an error or a null byte. If we hit this ASSERT, we've found a test
+        // case which demonstrates the need for this code.
         ASSERT(m_sawError || (bytesProcessed >= 0 && !chunkAsUtf8.data()[bytesProcessed]));
         return false;
     }
 
     // No error if the chunk is well formed or it is not but we have no error.
     return context()->wellFormed || !xmlCtxtGetLastError(context());
 }
 
 // --------------------------------
 
 struct AttributeParseState {
     HashMap<String, String> attributes;
     bool gotAttributes;
 };
 
 static void attributesStartElementNsHandler(void* closure, const xmlChar* xmlLocalName, const xmlChar* /*xmlPrefix*/,
     const xmlChar* /*xmlURI*/, int /*nbNamespaces*/, const xmlChar** /*namespaces*/,
     int nbAttributes, int /*nbDefaulted*/, const xmlChar** libxmlAttributes)
 {
     if (strcmp(reinterpret_cast<const char*>(xmlLocalName), "attrs") != 0)
         return;
 
     xmlParserCtxtPtr ctxt = static_cast<xmlParserCtxtPtr>(closure);
     AttributeParseState* state = static_cast<AttributeParseState*>(ctxt->_private);
 
     state->gotAttributes = true;
 
     xmlSAX2Attributes* attributes = reinterpret_cast<xmlSAX2Attributes*>(libxmlAttributes);
-    for (int i = 0; i < nbAttributes; i++) {
+    for (int i = 0; i < nbAttributes; ++i) {
         String attrLocalName = toString(attributes[i].localname);
         int valueLength = (int) (attributes[i].end - attributes[i].value);
         String attrValue = toString(attributes[i].value, valueLength);
         String attrPrefix = toString(attributes[i].prefix);
         String attrQName = attrPrefix.isEmpty() ? attrLocalName : attrPrefix + ":" + attrLocalName;
 
         state->attributes.set(attrQName, attrValue);
     }
 }
 
 HashMap<String, String> parseAttributes(const String& string, bool& attrsOK)
 {
     AttributeParseState state;
     state.gotAttributes = false;
 
     xmlSAXHandler sax;
     memset(&sax, 0, sizeof(sax));
     sax.startElementNs = attributesStartElementNsHandler;
     sax.initialized = XML_SAX2_MAGIC;
     RefPtr<XMLParserContext> parser = XMLParserContext::createStringParser(&sax, &state);
     String parseString = "<?xml version=\"1.0\"?><attrs " + string + " />";
     parseChunk(parser->context(), parseString);
     finishParsing(parser->context());
     attrsOK = state.gotAttributes;
     return state.attributes;
 }
 
 } // namespace WebCore