Rename es => exceptionState in other than bindings/

Source/core/svg/properties/SVGListProperty.h

 /*
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * 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
@@ skipping 31 matching lines @@
 class SVGListProperty : public SVGProperty {
 public:
     typedef SVGListProperty<PropertyType> Self;
 
     typedef typename SVGPropertyTraits<PropertyType>::ListItemType ListItemType;
     typedef SVGPropertyTearOff<ListItemType> ListItemTearOff;
     typedef PassRefPtr<ListItemTearOff> PassListItemTearOff;
     typedef SVGAnimatedListPropertyTearOff<PropertyType> AnimatedListPropertyTearOff;
     typedef typename SVGAnimatedListPropertyTearOff<PropertyType>::ListWrapperCache ListWrapperCache;
 
-    bool canAlterList(ExceptionState& es) const
+    bool canAlterList(ExceptionState& exceptionState) const
     {
         if (m_role == AnimValRole) {
-            es.throwUninformativeAndGenericDOMException(NoModificationAllowedError);
+            exceptionState.throwUninformativeAndGenericDOMException(NoModificationAllowedError);
             return false;
         }
 
         return true;
     }
 
     static void detachListWrappersAndResize(ListWrapperCache* wrappers, unsigned newListSize = 0)
     {
         // See SVGPropertyTearOff::detachWrapper() for an explanation about what's happening here.
         ASSERT(wrappers);
@@ skipping 24 matching lines @@
         ASSERT(m_role == AnimValRole);
         if (m_ownsValues)
             delete m_values;
         m_values = values;
         m_ownsValues = shouldOwnValues;
         m_wrappers = wrappers;
         ASSERT(m_values->size() == m_wrappers->size());
     }
 
     // SVGList::clear()
-    void clearValues(ExceptionState& es)
+    void clearValues(ExceptionState& exceptionState)
     {
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return;
 
         m_values->clear();
         commitChange();
     }
 
-    void clearValuesAndWrappers(ExceptionState& es)
+    void clearValuesAndWrappers(ExceptionState& exceptionState)
     {
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return;
 
         detachListWrappers(0);
         m_values->clear();
         commitChange();
     }
 
     // SVGList::numberOfItems()
     unsigned numberOfItems() const
     {
         return m_values->size();
     }
 
     // SVGList::initialize()
-    ListItemType initializeValues(const ListItemType& newItem, ExceptionState& es)
+    ListItemType initializeValues(const ListItemType& newItem, ExceptionState& exceptionState)
     {
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return ListItemType();
 
         // Spec: If the inserted item is already in a list, it is removed from its previous list before it is inserted into this list.
         processIncomingListItemValue(newItem, 0);
 
         // Spec: Clears all existing current items from the list and re-initializes the list to hold the single item specified by the parameter.
         m_values->clear();
         m_values->append(newItem);
 
         commitChange();
         return newItem;
     }
 
-    PassListItemTearOff initializeValuesAndWrappers(PassListItemTearOff passNewItem, ExceptionState& es)
+    PassListItemTearOff initializeValuesAndWrappers(PassListItemTearOff passNewItem, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return 0;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
-            es.throwUninformativeAndGenericTypeError();
+            exceptionState.throwUninformativeAndGenericTypeError();
             return 0;
         }
 
         RefPtr<ListItemTearOff> newItem = passNewItem;
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Spec: If the inserted item is already in a list, it is removed from its previous list before it is inserted into this list.
         processIncomingListItemWrapper(newItem, 0);
 
         // Spec: Clears all existing current items from the list and re-initializes the list to hold the single item specified by the parameter.
         detachListWrappers(0);
         m_values->clear();
 
         m_values->append(newItem->propertyReference());
         m_wrappers->append(newItem);
 
         commitChange();
         return newItem.release();
     }
 
     // SVGList::getItem()
-    bool canGetItem(unsigned index, ExceptionState& es)
+    bool canGetItem(unsigned index, ExceptionState& exceptionState)
     {
         if (index >= m_values->size()) {
-            es.throwUninformativeAndGenericDOMException(IndexSizeError);
+            exceptionState.throwUninformativeAndGenericDOMException(IndexSizeError);
             return false;
         }
 
         return true;
     }
 
-    ListItemType getItemValues(unsigned index, ExceptionState& es)
+    ListItemType getItemValues(unsigned index, ExceptionState& exceptionState)
     {
-        if (!canGetItem(index, es))
+        if (!canGetItem(index, exceptionState))
             return ListItemType();
 
         // Spec: Returns the specified item from the list. The returned item is the item itself and not a copy.
         return m_values->at(index);
     }
 
-    PassListItemTearOff getItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionState& es)
+    PassListItemTearOff getItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
-        if (!canGetItem(index, es))
+        if (!canGetItem(index, exceptionState))
             return 0;
 
         // Spec: Returns the specified item from the list. The returned item is the item itself and not a copy.
         // Any changes made to the item are immediately reflected in the list.
         ASSERT(m_values->size() == m_wrappers->size());
         RefPtr<ListItemTearOff> wrapper = m_wrappers->at(index);
         if (!wrapper) {
             // Create new wrapper, which is allowed to directly modify the item in the list, w/o copying and cache the wrapper in our map.
             // It is also associated with our animated property, so it can notify the SVG Element which holds the SVGAnimated*List
             // that it has been modified (and thus can call svgAttributeChanged(associatedAttributeName)).
             wrapper = ListItemTearOff::create(animatedList, UndefinedRole, m_values->at(index));
             m_wrappers->at(index) = wrapper;
         }
 
         return wrapper.release();
     }
 
     // SVGList::insertItemBefore()
-    ListItemType insertItemBeforeValues(const ListItemType& newItem, unsigned index, ExceptionState& es)
+    ListItemType insertItemBeforeValues(const ListItemType& newItem, unsigned index, ExceptionState& exceptionState)
     {
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return ListItemType();
 
         // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
         if (index > m_values->size())
             index = m_values->size();
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         if (!processIncomingListItemValue(newItem, &index)) {
             // Inserting the item before itself is a no-op.
             return newItem;
         }
 
         // Spec: Inserts a new item into the list at the specified position. The index of the item before which the new item is to be
         // inserted. The first item is number 0. If the index is equal to 0, then the new item is inserted at the front of the list.
         m_values->insert(index, newItem);
 
         commitChange();
         return newItem;
     }
 
-    PassListItemTearOff insertItemBeforeValuesAndWrappers(PassListItemTearOff passNewItem, unsigned index, ExceptionState& es)
+    PassListItemTearOff insertItemBeforeValuesAndWrappers(PassListItemTearOff passNewItem, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return 0;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
-            es.throwUninformativeAndGenericTypeError();
+            exceptionState.throwUninformativeAndGenericTypeError();
             return 0;
         }
 
         // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.
         if (index > m_values->size())
              index = m_values->size();
 
         RefPtr<ListItemTearOff> newItem = passNewItem;
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         if (!processIncomingListItemWrapper(newItem, &index))
             return newItem.release();
 
         // Spec: Inserts a new item into the list at the specified position. The index of the item before which the new item is to be
         // inserted. The first item is number 0. If the index is equal to 0, then the new item is inserted at the front of the list.
         m_values->insert(index, newItem->propertyReference());
 
         // Store new wrapper at position 'index', change its underlying value, so mutations of newItem, directly affect the item in the list.
         m_wrappers->insert(index, newItem);
 
         commitChange();
         return newItem.release();
     }
 
     // SVGList::replaceItem()
-    bool canReplaceItem(unsigned index, ExceptionState& es)
+    bool canReplaceItem(unsigned index, ExceptionState& exceptionState)
     {
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return false;
 
         if (index >= m_values->size()) {
-            es.throwUninformativeAndGenericDOMException(IndexSizeError);
+            exceptionState.throwUninformativeAndGenericDOMException(IndexSizeError);
             return false;
         }
 
         return true;
     }
 
-    ListItemType replaceItemValues(const ListItemType& newItem, unsigned index, ExceptionState& es)
+    ListItemType replaceItemValues(const ListItemType& newItem, unsigned index, ExceptionState& exceptionState)
     {
-        if (!canReplaceItem(index, es))
+        if (!canReplaceItem(index, exceptionState))
             return ListItemType();
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         // Spec: If the item is already in this list, note that the index of the item to replace is before the removal of the item.
         if (!processIncomingListItemValue(newItem, &index)) {
             // Replacing the item with itself is a no-op.
             return newItem;
         }
 
         if (m_values->isEmpty()) {
             // 'newItem' already lived in our list, we removed it, and now we're empty, which means there's nothing to replace.
-            es.throwUninformativeAndGenericDOMException(IndexSizeError);
+            exceptionState.throwUninformativeAndGenericDOMException(IndexSizeError);
             return ListItemType();
         }
 
         // Update the value at the desired position 'index'.
         m_values->at(index) = newItem;
 
         commitChange();
         return newItem;
     }
 
-    PassListItemTearOff replaceItemValuesAndWrappers(PassListItemTearOff passNewItem, unsigned index, ExceptionState& es)
+    PassListItemTearOff replaceItemValuesAndWrappers(PassListItemTearOff passNewItem, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
-        if (!canReplaceItem(index, es))
+        if (!canReplaceItem(index, exceptionState))
             return 0;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
-            es.throwUninformativeAndGenericTypeError();
+            exceptionState.throwUninformativeAndGenericTypeError();
             return 0;
         }
 
         ASSERT(m_values->size() == m_wrappers->size());
         RefPtr<ListItemTearOff> newItem = passNewItem;
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         // Spec: If the item is already in this list, note that the index of the item to replace is before the removal of the item.
         if (!processIncomingListItemWrapper(newItem, &index))
             return newItem.release();
 
         if (m_values->isEmpty()) {
             ASSERT(m_wrappers->isEmpty());
             // 'passNewItem' already lived in our list, we removed it, and now we're empty, which means there's nothing to replace.
-            es.throwUninformativeAndGenericDOMException(IndexSizeError);
+            exceptionState.throwUninformativeAndGenericDOMException(IndexSizeError);
             return 0;
         }
 
         // Detach the existing wrapper.
         RefPtr<ListItemTearOff> oldItem = m_wrappers->at(index);
         if (oldItem)
             oldItem->detachWrapper();
 
         // Update the value and the wrapper at the desired position 'index'.
         m_values->at(index) = newItem->propertyReference();
         m_wrappers->at(index) = newItem;
 
         commitChange();
         return newItem.release();
     }
 
     // SVGList::removeItem()
-    bool canRemoveItem(unsigned index, ExceptionState& es)
+    bool canRemoveItem(unsigned index, ExceptionState& exceptionState)
     {
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return false;
 
         if (index >= m_values->size()) {
-            es.throwUninformativeAndGenericDOMException(IndexSizeError);
+            exceptionState.throwUninformativeAndGenericDOMException(IndexSizeError);
             return false;
         }
 
         return true;
     }
 
-    ListItemType removeItemValues(unsigned index, ExceptionState& es)
+    ListItemType removeItemValues(unsigned index, ExceptionState& exceptionState)
     {
-        if (!canRemoveItem(index, es))
+        if (!canRemoveItem(index, exceptionState))
             return ListItemType();
 
         ListItemType oldItem = m_values->at(index);
         m_values->remove(index);
 
         commitChange();
         return oldItem;
     }
 
-    PassListItemTearOff removeItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionState& es)
+    PassListItemTearOff removeItemValuesAndWrappers(AnimatedListPropertyTearOff* animatedList, unsigned index, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
-        if (!canRemoveItem(index, es))
+        if (!canRemoveItem(index, exceptionState))
             return 0;
 
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Detach the existing wrapper.
         RefPtr<ListItemTearOff> oldItem = m_wrappers->at(index);
         if (!oldItem)
             oldItem = ListItemTearOff::create(animatedList, UndefinedRole, m_values->at(index));
 
         oldItem->detachWrapper();
         m_wrappers->remove(index);
         m_values->remove(index);
 
         commitChange();
         return oldItem.release();
     }
 
     // SVGList::appendItem()
-    ListItemType appendItemValues(const ListItemType& newItem, ExceptionState& es)
+    ListItemType appendItemValues(const ListItemType& newItem, ExceptionState& exceptionState)
     {
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return ListItemType();
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         processIncomingListItemValue(newItem, 0);
 
         // Append the value at the end of the list.
         m_values->append(newItem);
 
         commitChange(ListModificationAppend);
         return newItem;
     }
 
-    PassListItemTearOff appendItemValuesAndWrappers(PassListItemTearOff passNewItem, ExceptionState& es)
+    PassListItemTearOff appendItemValuesAndWrappers(PassListItemTearOff passNewItem, ExceptionState& exceptionState)
     {
         ASSERT(m_wrappers);
-        if (!canAlterList(es))
+        if (!canAlterList(exceptionState))
             return 0;
 
         // Not specified, but FF/Opera do it this way, and it's just sane.
         if (!passNewItem) {
-            es.throwUninformativeAndGenericTypeError();
+            exceptionState.throwUninformativeAndGenericTypeError();
             return 0;
         }
 
         RefPtr<ListItemTearOff> newItem = passNewItem;
         ASSERT(m_values->size() == m_wrappers->size());
 
         // Spec: If newItem is already in a list, it is removed from its previous list before it is inserted into this list.
         processIncomingListItemWrapper(newItem, 0);
 
         // Append the value and wrapper at the end of the list.
@@ skipping 42 matching lines @@
 
     SVGPropertyRole m_role;
     bool m_ownsValues;
     PropertyType* m_values;
     ListWrapperCache* m_wrappers;
 };
 
 }
 
 #endif // SVGListProperty_h