Rename es => exceptionState in other than bindings/

Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 202 matching lines @@
 {
     // The timer is stopped on m_domAgent destruction, so this method will never be called after m_domAgent has been destroyed.
     Vector<Element*> elements;
     for (HashSet<RefPtr<Element> >::iterator it = m_elements.begin(), end = m_elements.end(); it != end; ++it)
         elements.append(it->get());
     m_domAgent->styleAttributeInvalidated(elements);
 
     m_elements.clear();
 }
 
-String InspectorDOMAgent::toErrorString(ExceptionState& es)
+String InspectorDOMAgent::toErrorString(ExceptionState& exceptionState)
 {
-    if (es.hadException())
-        return DOMException::getErrorName(es.code());
+    if (exceptionState.hadException())
+        return DOMException::getErrorName(exceptionState.code());
     return "";
 }
 
 InspectorDOMAgent::InspectorDOMAgent(InstrumentingAgents* instrumentingAgents, InspectorPageAgent* pageAgent, InspectorCompositeState* inspectorState, InjectedScriptManager* injectedScriptManager, InspectorOverlay* overlay, InspectorClient* client)
     : InspectorBaseAgent<InspectorDOMAgent>("DOM", instrumentingAgents, inspectorState)
     , m_pageAgent(pageAgent)
     , m_injectedScriptManager(injectedScriptManager)
     , m_overlay(overlay)
     , m_client(client)
     , m_frontend(0)
@@ skipping 323 matching lines @@
     pushChildNodesToFrontend(nodeId, sanitizedDepth);
 }
 
 void InspectorDOMAgent::querySelector(ErrorString* errorString, int nodeId, const String& selectors, int* elementId)
 {
     *elementId = 0;
     Node* node = assertNode(errorString, nodeId);
     if (!node)
         return;
 
-    TrackExceptionState es;
-    RefPtr<Element> element = node->querySelector(selectors, es);
-    if (es.hadException()) {
+    TrackExceptionState exceptionState;
+    RefPtr<Element> element = node->querySelector(selectors, exceptionState);
+    if (exceptionState.hadException()) {
         *errorString = "DOM Error while querying";
         return;
     }
 
     if (element)
         *elementId = pushNodePathToFrontend(element.get());
 }
 
 void InspectorDOMAgent::querySelectorAll(ErrorString* errorString, int nodeId, const String& selectors, RefPtr<TypeBuilder::Array<int> >& result)
 {
     Node* node = assertNode(errorString, nodeId);
     if (!node)
         return;
 
-    TrackExceptionState es;
-    RefPtr<NodeList> nodes = node->querySelectorAll(selectors, es);
-    if (es.hadException()) {
+    TrackExceptionState exceptionState;
+    RefPtr<NodeList> nodes = node->querySelectorAll(selectors, exceptionState);
+    if (exceptionState.hadException()) {
         *errorString = "DOM Error while querying";
         return;
     }
 
     result = TypeBuilder::Array<int>::create();
 
     for (unsigned i = 0; i < nodes->length(); ++i)
         result->addItem(pushNodePathToFrontend(nodes->item(i)));
 }
 
@@ skipping 160 matching lines @@
 }
 
 void InspectorDOMAgent::setNodeName(ErrorString* errorString, int nodeId, const String& tagName, int* newId)
 {
     *newId = 0;
 
     Node* oldNode = nodeForId(nodeId);
     if (!oldNode || !oldNode->isElementNode())
         return;
 
-    TrackExceptionState es;
-    RefPtr<Element> newElem = oldNode->document().createElement(tagName, es);
-    if (es.hadException())
+    TrackExceptionState exceptionState;
+    RefPtr<Element> newElem = oldNode->document().createElement(tagName, exceptionState);
+    if (exceptionState.hadException())
         return;
 
     // Copy over the original node's attributes.
     newElem->cloneAttributesFromElement(*toElement(oldNode));
 
     // Copy over the original node's children.
     Node* child;
     while ((child = oldNode->firstChild())) {
         if (!m_domEditor->insertBefore(newElem.get(), child, 0, errorString))
             return;
@@ skipping 213 matching lines @@
                 break;
             }
             default:
                 break;
             }
         }
 
         // XPath evaluation
         for (Vector<Document*>::iterator it = docs.begin(); it != docs.end(); ++it) {
             Document* document = *it;
-            TrackExceptionState es;
-            RefPtr<XPathResult> result = DocumentXPathEvaluator::evaluate(document, whitespaceTrimmedQuery, document, 0, XPathResult::ORDERED_NODE_SNAPSHOT_TYPE, 0, es);
-            if (es.hadException() || !result)
+            TrackExceptionState exceptionState;
+            RefPtr<XPathResult> result = DocumentXPathEvaluator::evaluate(document, whitespaceTrimmedQuery, document, 0, XPathResult::ORDERED_NODE_SNAPSHOT_TYPE, 0, exceptionState);
+            if (exceptionState.hadException() || !result)
                 continue;
 
-            unsigned long size = result->snapshotLength(es);
-            for (unsigned long i = 0; !es.hadException() && i < size; ++i) {
-                Node* node = result->snapshotItem(i, es);
-                if (es.hadException())
+            unsigned long size = result->snapshotLength(exceptionState);
+            for (unsigned long i = 0; !exceptionState.hadException() && i < size; ++i) {
+                Node* node = result->snapshotItem(i, exceptionState);
+                if (exceptionState.hadException())
                     break;
 
                 if (node->nodeType() == Node::ATTRIBUTE_NODE)
                     node = toAttr(node)->ownerElement();
                 resultCollector.add(node);
             }
         }
 
         // Selector evaluation
         for (Vector<Document*>::iterator it = docs.begin(); it != docs.end(); ++it) {
             Document* document = *it;
-            TrackExceptionState es;
-            RefPtr<NodeList> nodeList = document->querySelectorAll(whitespaceTrimmedQuery, es);
-            if (es.hadException() || !nodeList)
+            TrackExceptionState exceptionState;
+            RefPtr<NodeList> nodeList = document->querySelectorAll(whitespaceTrimmedQuery, exceptionState);
+            if (exceptionState.hadException() || !nodeList)
                 continue;
 
             unsigned size = nodeList->length();
             for (unsigned i = 0; i < size; ++i)
                 resultCollector.add(nodeList->item(i));
         }
     }
 
     *searchId = IdentifiersFactory::createIdentifier();
     SearchResults::iterator resultsIt = m_searchResults.add(*searchId, Vector<RefPtr<Node> >()).iterator;
@@ skipping 236 matching lines @@
     }
 
     if (!m_domEditor->insertBefore(targetElement, node, anchorNode, errorString))
         return;
 
     *newNodeId = pushNodePathToFrontend(node);
 }
 
 void InspectorDOMAgent::undo(ErrorString* errorString)
 {
-    TrackExceptionState es;
-    m_history->undo(es);
-    *errorString = InspectorDOMAgent::toErrorString(es);
+    TrackExceptionState exceptionState;
+    m_history->undo(exceptionState);
+    *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorDOMAgent::redo(ErrorString* errorString)
 {
-    TrackExceptionState es;
-    m_history->redo(es);
-    *errorString = InspectorDOMAgent::toErrorString(es);
+    TrackExceptionState exceptionState;
+    m_history->redo(exceptionState);
+    *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorDOMAgent::markUndoableState(ErrorString*)
 {
     m_history->markUndoableState();
 }
 
 void InspectorDOMAgent::focus(ErrorString* errorString, int nodeId)
 {
     Element* element = assertElement(errorString, nodeId);
@@ skipping 712 matching lines @@
     if (!m_documentNodeToIdMap.contains(m_document)) {
         RefPtr<TypeBuilder::DOM::Node> root;
         getDocument(errorString, root);
         return errorString->isEmpty();
     }
     return true;
 }
 
 } // namespace WebCore