Rename es => exceptionState in other than bindings/

Source/core/inspector/InspectorCSSAgent.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * 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
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 300 matching lines @@
 
 class InspectorCSSAgent::SetStyleSheetTextAction : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(SetStyleSheetTextAction);
 public:
     SetStyleSheetTextAction(InspectorStyleSheet* styleSheet, const String& text)
         : InspectorCSSAgent::StyleSheetAction("SetStyleSheetText", styleSheet)
         , m_text(text)
     {
     }
 
-    virtual bool perform(ExceptionState& es)
+    virtual bool perform(ExceptionState& exceptionState)
     {
         if (!m_styleSheet->getText(&m_oldText))
             return false;
-        return redo(es);
+        return redo(exceptionState);
     }
 
-    virtual bool undo(ExceptionState& es)
+    virtual bool undo(ExceptionState& exceptionState)
     {
-        if (m_styleSheet->setText(m_oldText, es)) {
+        if (m_styleSheet->setText(m_oldText, exceptionState)) {
             m_styleSheet->reparseStyleSheet(m_oldText);
             return true;
         }
         return false;
     }
 
-    virtual bool redo(ExceptionState& es)
+    virtual bool redo(ExceptionState& exceptionState)
     {
-        if (m_styleSheet->setText(m_text, es)) {
+        if (m_styleSheet->setText(m_text, exceptionState)) {
             m_styleSheet->reparseStyleSheet(m_text);
             return true;
         }
         return false;
     }
 
     virtual String mergeId()
     {
         return String::format("SetStyleSheetText %s", m_styleSheet->id().utf8().data());
     }
@@ skipping 19 matching lines @@
         , m_cssId(cssId)
         , m_text(text)
     {
     }
 
     virtual String toString()
     {
         return mergeId() + ": " + m_oldText + " -> " + m_text;
     }
 
-    virtual bool perform(ExceptionState& es)
+    virtual bool perform(ExceptionState& exceptionState)
     {
-        return redo(es);
+        return redo(exceptionState);
     }
 
-    virtual bool undo(ExceptionState& es)
+    virtual bool undo(ExceptionState& exceptionState)
     {
         String placeholder;
-        return m_styleSheet->setStyleText(m_cssId, m_oldText, &placeholder, es);
+        return m_styleSheet->setStyleText(m_cssId, m_oldText, &placeholder, exceptionState);
     }
 
-    virtual bool redo(ExceptionState& es)
+    virtual bool redo(ExceptionState& exceptionState)
     {
-        return m_styleSheet->setStyleText(m_cssId, m_text, &m_oldText, es);
+        return m_styleSheet->setStyleText(m_cssId, m_text, &m_oldText, exceptionState);
     }
 
     virtual String mergeId()
     {
         return String::format("SetStyleText %s:%u", m_cssId.styleSheetId().utf8().data(), m_cssId.ordinal());
     }
 
     virtual void merge(PassOwnPtr<Action> action)
     {
         ASSERT(action->mergeId() == mergeId());
@@ skipping 18 matching lines @@
         , m_text(text)
         , m_overwrite(overwrite)
     {
     }
 
     virtual String toString()
     {
         return mergeId() + ": " + m_oldText + " -> " + m_text;
     }
 
-    virtual bool perform(ExceptionState& es)
+    virtual bool perform(ExceptionState& exceptionState)
     {
-        return redo(es);
+        return redo(exceptionState);
     }
 
-    virtual bool undo(ExceptionState& es)
+    virtual bool undo(ExceptionState& exceptionState)
     {
         String placeholder;
-        return m_styleSheet->setPropertyText(m_cssId, m_propertyIndex, m_overwrite ? m_oldText : "", true, &placeholder, es);
+        return m_styleSheet->setPropertyText(m_cssId, m_propertyIndex, m_overwrite ? m_oldText : "", true, &placeholder, exceptionState);
     }
 
-    virtual bool redo(ExceptionState& es)
+    virtual bool redo(ExceptionState& exceptionState)
     {
         String oldText;
-        bool result = m_styleSheet->setPropertyText(m_cssId, m_propertyIndex, m_text, m_overwrite, &oldText, es);
+        bool result = m_styleSheet->setPropertyText(m_cssId, m_propertyIndex, m_text, m_overwrite, &oldText, exceptionState);
         m_oldText = oldText.stripWhiteSpace();
         // FIXME: remove this once the model handles this case.
         if (!m_oldText.endsWith(';'))
             m_oldText.append(';');
         return result;
     }
 
     virtual String mergeId()
     {
         return String::format("SetPropertyText %s:%u:%s", m_styleSheet->id().utf8().data(), m_propertyIndex, m_overwrite ? "true" : "false");
@@ skipping 19 matching lines @@
     WTF_MAKE_NONCOPYABLE(TogglePropertyAction);
 public:
     TogglePropertyAction(InspectorStyleSheet* styleSheet, const InspectorCSSId& cssId, unsigned propertyIndex, bool disable)
         : InspectorCSSAgent::StyleSheetAction("ToggleProperty", styleSheet)
         , m_cssId(cssId)
         , m_propertyIndex(propertyIndex)
         , m_disable(disable)
     {
     }
 
-    virtual bool perform(ExceptionState& es)
+    virtual bool perform(ExceptionState& exceptionState)
     {
-        return redo(es);
+        return redo(exceptionState);
     }
 
-    virtual bool undo(ExceptionState& es)
+    virtual bool undo(ExceptionState& exceptionState)
     {
-        return m_styleSheet->toggleProperty(m_cssId, m_propertyIndex, !m_disable, es);
+        return m_styleSheet->toggleProperty(m_cssId, m_propertyIndex, !m_disable, exceptionState);
     }
 
-    virtual bool redo(ExceptionState& es)
+    virtual bool redo(ExceptionState& exceptionState)
     {
-        return m_styleSheet->toggleProperty(m_cssId, m_propertyIndex, m_disable, es);
+        return m_styleSheet->toggleProperty(m_cssId, m_propertyIndex, m_disable, exceptionState);
     }
 
 private:
     InspectorCSSId m_cssId;
     unsigned m_propertyIndex;
     bool m_disable;
 };
 
 class InspectorCSSAgent::SetRuleSelectorAction : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(SetRuleSelectorAction);
 public:
     SetRuleSelectorAction(InspectorStyleSheet* styleSheet, const InspectorCSSId& cssId, const String& selector)
         : InspectorCSSAgent::StyleSheetAction("SetRuleSelector", styleSheet)
         , m_cssId(cssId)
         , m_selector(selector)
     {
     }
 
-    virtual bool perform(ExceptionState& es)
+    virtual bool perform(ExceptionState& exceptionState)
     {
-        m_oldSelector = m_styleSheet->ruleSelector(m_cssId, es);
-        if (es.hadException())
+        m_oldSelector = m_styleSheet->ruleSelector(m_cssId, exceptionState);
+        if (exceptionState.hadException())
             return false;
-        return redo(es);
+        return redo(exceptionState);
     }
 
-    virtual bool undo(ExceptionState& es)
+    virtual bool undo(ExceptionState& exceptionState)
     {
-        return m_styleSheet->setRuleSelector(m_cssId, m_oldSelector, es);
+        return m_styleSheet->setRuleSelector(m_cssId, m_oldSelector, exceptionState);
     }
 
-    virtual bool redo(ExceptionState& es)
+    virtual bool redo(ExceptionState& exceptionState)
     {
-        return m_styleSheet->setRuleSelector(m_cssId, m_selector, es);
+        return m_styleSheet->setRuleSelector(m_cssId, m_selector, exceptionState);
     }
 
 private:
     InspectorCSSId m_cssId;
     String m_selector;
     String m_oldSelector;
 };
 
 class InspectorCSSAgent::AddRuleAction : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(AddRuleAction);
 public:
     AddRuleAction(InspectorStyleSheet* styleSheet, const String& selector)
         : InspectorCSSAgent::StyleSheetAction("AddRule", styleSheet)
         , m_selector(selector)
     {
     }
 
-    virtual bool perform(ExceptionState& es)
+    virtual bool perform(ExceptionState& exceptionState)
     {
-        return redo(es);
+        return redo(exceptionState);
     }
 
-    virtual bool undo(ExceptionState& es)
+    virtual bool undo(ExceptionState& exceptionState)
     {
-        return m_styleSheet->deleteRule(m_newId, es);
+        return m_styleSheet->deleteRule(m_newId, exceptionState);
     }
 
-    virtual bool redo(ExceptionState& es)
+    virtual bool redo(ExceptionState& exceptionState)
     {
-        CSSStyleRule* cssStyleRule = m_styleSheet->addRule(m_selector, es);
-        if (es.hadException())
+        CSSStyleRule* cssStyleRule = m_styleSheet->addRule(m_selector, exceptionState);
+        if (exceptionState.hadException())
             return false;
         m_newId = m_styleSheet->ruleId(cssStyleRule);
         return true;
     }
 
     InspectorCSSId newRuleId() { return m_newId; }
 
 private:
     InspectorCSSId m_newId;
     String m_selector;
@@ skipping 552 matching lines @@
 
     inspectorStyleSheet->getText(result);
 }
 
 void InspectorCSSAgent::setStyleSheetText(ErrorString* errorString, const String& styleSheetId, const String& text)
 {
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
     if (!inspectorStyleSheet)
         return;
 
-    TrackExceptionState es;
-    m_domAgent->history()->perform(adoptPtr(new SetStyleSheetTextAction(inspectorStyleSheet, text)), es);
-    *errorString = InspectorDOMAgent::toErrorString(es);
+    TrackExceptionState exceptionState;
+    m_domAgent->history()->perform(adoptPtr(new SetStyleSheetTextAction(inspectorStyleSheet, text)), exceptionState);
+    *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::setStyleText(ErrorString* errorString, const RefPtr<JSONObject>& fullStyleId, const String& text, RefPtr<TypeBuilder::CSS::CSSStyle>& result)
 {
     InspectorCSSId compoundId(fullStyleId);
     ASSERT(!compoundId.isEmpty());
 
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
     if (!inspectorStyleSheet)
         return;
 
-    TrackExceptionState es;
-    m_domAgent->history()->perform(adoptPtr(new SetStyleTextAction(inspectorStyleSheet, compoundId, text)), es);
-    if (!es.hadException())
+    TrackExceptionState exceptionState;
+    m_domAgent->history()->perform(adoptPtr(new SetStyleTextAction(inspectorStyleSheet, compoundId, text)), exceptionState);
+    if (!exceptionState.hadException())
         result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleForId(compoundId));
-    *errorString = InspectorDOMAgent::toErrorString(es);
+    *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::setPropertyText(ErrorString* errorString, const RefPtr<JSONObject>& fullStyleId, int propertyIndex, const String& text, bool overwrite, RefPtr<TypeBuilder::CSS::CSSStyle>& result)
 {
     InspectorCSSId compoundId(fullStyleId);
     ASSERT(!compoundId.isEmpty());
 
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
     if (!inspectorStyleSheet)
         return;
 
-    TrackExceptionState es;
-    bool success = m_domAgent->history()->perform(adoptPtr(new SetPropertyTextAction(inspectorStyleSheet, compoundId, propertyIndex, text, overwrite)), es);
+    TrackExceptionState exceptionState;
+    bool success = m_domAgent->history()->perform(adoptPtr(new SetPropertyTextAction(inspectorStyleSheet, compoundId, propertyIndex, text, overwrite)), exceptionState);
     if (success)
         result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleForId(compoundId));
-    *errorString = InspectorDOMAgent::toErrorString(es);
+    *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::toggleProperty(ErrorString* errorString, const RefPtr<JSONObject>& fullStyleId, int propertyIndex, bool disable, RefPtr<TypeBuilder::CSS::CSSStyle>& result)
 {
     InspectorCSSId compoundId(fullStyleId);
     ASSERT(!compoundId.isEmpty());
 
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
     if (!inspectorStyleSheet)
         return;
 
-    TrackExceptionState es;
-    bool success = m_domAgent->history()->perform(adoptPtr(new TogglePropertyAction(inspectorStyleSheet, compoundId, propertyIndex, disable)), es);
+    TrackExceptionState exceptionState;
+    bool success = m_domAgent->history()->perform(adoptPtr(new TogglePropertyAction(inspectorStyleSheet, compoundId, propertyIndex, disable)), exceptionState);
     if (success)
         result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleForId(compoundId));
-    *errorString = InspectorDOMAgent::toErrorString(es);
+    *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::setRuleSelector(ErrorString* errorString, const RefPtr<JSONObject>& fullRuleId, const String& selector, RefPtr<TypeBuilder::CSS::CSSRule>& result)
 {
     InspectorCSSId compoundId(fullRuleId);
     ASSERT(!compoundId.isEmpty());
 
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
     if (!inspectorStyleSheet)
         return;
 
-    TrackExceptionState es;
-    bool success = m_domAgent->history()->perform(adoptPtr(new SetRuleSelectorAction(inspectorStyleSheet, compoundId, selector)), es);
+    TrackExceptionState exceptionState;
+    bool success = m_domAgent->history()->perform(adoptPtr(new SetRuleSelectorAction(inspectorStyleSheet, compoundId, selector)), exceptionState);
 
     if (success) {
         CSSStyleRule* rule = inspectorStyleSheet->ruleForId(compoundId);
         result = inspectorStyleSheet->buildObjectForRule(rule, buildMediaListChain(rule));
     }
-    *errorString = InspectorDOMAgent::toErrorString(es);
+    *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::addRule(ErrorString* errorString, const int contextNodeId, const String& selector, RefPtr<TypeBuilder::CSS::CSSRule>& result)
 {
     Node* node = m_domAgent->assertNode(errorString, contextNodeId);
     if (!node)
         return;
 
     InspectorStyleSheet* inspectorStyleSheet = viaInspectorStyleSheet(&node->document(), true);
     if (!inspectorStyleSheet) {
         *errorString = "No target stylesheet found";
         return;
     }
 
-    TrackExceptionState es;
+    TrackExceptionState exceptionState;
     OwnPtr<AddRuleAction> action = adoptPtr(new AddRuleAction(inspectorStyleSheet, selector));
     AddRuleAction* rawAction = action.get();
-    bool success = m_domAgent->history()->perform(action.release(), es);
+    bool success = m_domAgent->history()->perform(action.release(), exceptionState);
     if (!success) {
-        *errorString = InspectorDOMAgent::toErrorString(es);
+        *errorString = InspectorDOMAgent::toErrorString(exceptionState);
         return;
     }
 
     InspectorCSSId ruleId = rawAction->newRuleId();
     CSSStyleRule* rule = inspectorStyleSheet->ruleForId(ruleId);
     result = inspectorStyleSheet->buildObjectForRule(rule, buildMediaListChain(rule));
 }
 
 void InspectorCSSAgent::getSupportedCSSProperties(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSPropertyInfo> >& cssProperties)
 {
@@ skipping 260 matching lines @@
         return 0;
     }
 
     if (!document->isHTMLDocument() && !document->isSVGDocument())
         return 0;
 
     RefPtr<InspectorStyleSheet> inspectorStyleSheet = m_documentToInspectorStyleSheet.get(document);
     if (inspectorStyleSheet || !createIfAbsent)
         return inspectorStyleSheet.get();
 
-    TrackExceptionState es;
-    RefPtr<Element> styleElement = document->createElement("style", es);
-    if (!es.hadException())
-        styleElement->setAttribute("type", "text/css", es);
-    if (!es.hadException()) {
+    TrackExceptionState exceptionState;
+    RefPtr<Element> styleElement = document->createElement("style", exceptionState);
+    if (!exceptionState.hadException())
+        styleElement->setAttribute("type", "text/css", exceptionState);
+    if (!exceptionState.hadException()) {
         ContainerNode* targetNode;
         // HEAD is absent in ImageDocuments, for example.
         if (document->head())
             targetNode = document->head();
         else if (document->body())
             targetNode = document->body();
         else
             return 0;
 
         InlineStyleOverrideScope overrideScope(document);
         m_creatingViaInspectorStyleSheet = true;
-        targetNode->appendChild(styleElement, es);
+        targetNode->appendChild(styleElement, exceptionState);
         // At this point the added stylesheet will get bound through the updateActiveStyleSheets() invocation.
         // We just need to pick the respective InspectorStyleSheet from m_documentToInspectorStyleSheet.
         m_creatingViaInspectorStyleSheet = false;
     }
-    if (es.hadException())
+    if (exceptionState.hadException())
         return 0;
 
     return m_documentToInspectorStyleSheet.get(document);
 }
 
 InspectorStyleSheet* InspectorCSSAgent::assertStyleSheetForId(ErrorString* errorString, const String& styleSheetId)
 {
     IdToInspectorStyleSheet::iterator it = m_idToInspectorStyleSheet.find(styleSheetId);
     if (it == m_idToInspectorStyleSheet.end()) {
         *errorString = "No style sheet with given id found";
@@ skipping 236 matching lines @@
             documentsToChange.add(element->ownerDocument());
     }
 
     m_nodeIdToForcedPseudoState.clear();
     for (HashSet<Document*>::iterator it = documentsToChange.begin(), end = documentsToChange.end(); it != end; ++it)
         (*it)->setNeedsStyleRecalc();
 }
 
 } // namespace WebCore