Rename es => exceptionState in other than bindings/

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
@@ skipping 880 matching lines @@
         handleError(XMLErrors::fatal, "Encoding error", position);
     }
 }
 
 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& es)
+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++) {
         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, es))
+        if (!Element::parseAttributeName(parsedName, XMLNSNames::xmlnsNamespaceURI, namespaceQName, exceptionState))
             return;
 
         prefixedAttributes.append(Attribute(parsedName, namespaceURI));
     }
 }
 
 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& es)
+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++) {
         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, es))
+        if (!Element::parseAttributeName(parsedName, attrURI, attrQName, exceptionState))
             return;
 
         prefixedAttributes.append(Attribute(parsedName, attrValue));
     }
 }
 
 void XMLDocumentParser::startElementNs(const AtomicString& localName, const AtomicString& prefix, const AtomicString& uri, int nbNamespaces,
     const xmlChar** libxmlNamespaces, int nbAttributes, int nbDefaulted, const xmlChar** libxmlAttributes)
 {
     if (isStopped())
@@ skipping 19 matching lines @@
     m_sawFirstElement = true;
 
     QualifiedName qName(prefix, localName, adjustedURI);
     RefPtr<Element> newElement = m_currentNode->document().createElement(qName, true);
     if (!newElement) {
         stopParsing();
         return;
     }
 
     Vector<Attribute> prefixedAttributes;
-    TrackExceptionState es;
-    handleNamespaceAttributes(prefixedAttributes, libxmlNamespaces, nbNamespaces, es);
-    if (es.hadException()) {
+    TrackExceptionState exceptionState;
+    handleNamespaceAttributes(prefixedAttributes, libxmlNamespaces, nbNamespaces, exceptionState);
+    if (exceptionState.hadException()) {
         setAttributes(newElement.get(), prefixedAttributes, parserContentPolicy());
         stopParsing();
         return;
     }
 
-    handleElementAttributes(prefixedAttributes, libxmlAttributes, nbAttributes, es);
+    handleElementAttributes(prefixedAttributes, libxmlAttributes, nbAttributes, exceptionState);
     setAttributes(newElement.get(), prefixedAttributes, parserContentPolicy());
-    if (es.hadException()) {
+    if (exceptionState.hadException()) {
         stopParsing();
         return;
     }
 
     newElement->beginParsingChildren();
 
     ScriptLoader* scriptLoader = toScriptLoaderIfPossible(newElement.get());
     if (scriptLoader)
         m_scriptStartPosition = textPosition();
 
@@ skipping 136 matching lines @@
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks.append(adoptPtr(new PendingProcessingInstructionCallback(target ,data)));
         return;
     }
 
     exitText();
 
     // ### handle exceptions
-    TrackExceptionState es;
-    RefPtr<ProcessingInstruction> pi = m_currentNode->document().createProcessingInstruction(target, data, es);
-    if (es.hadException())
+    TrackExceptionState exceptionState;
+    RefPtr<ProcessingInstruction> pi = m_currentNode->document().createProcessingInstruction(target, data, exceptionState);
+    if (exceptionState.hadException())
         return;
 
     pi->setCreatedByParser(true);
 
     m_currentNode->parserAppendChild(pi.get());
 
     pi->finishParsingChildren();
 
     if (pi->isCSS())
         m_sawCSS = true;
@@ skipping 476 matching lines @@
     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