Remove AtomicStringImpl.

Source/core/html/FormController.cpp

 /*
  * Copyright (C) 2006, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010, 2011, 2012 Google Inc. 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,
@@ skipping 64 matching lines @@
     state.m_values.reserveCapacity(valueSize);
     for (size_t i = 0; i < valueSize; ++i)
         state.append(stateVector[index++]);
     return state;
 }
 
 // ----------------------------------------------------------------------------
 
 class FormElementKey {
 public:
-    FormElementKey(AtomicStringImpl* = 0, AtomicStringImpl* = 0);
+    FormElementKey(StringImpl* = 0, StringImpl* = 0);
     ~FormElementKey();
     FormElementKey(const FormElementKey&);
     FormElementKey& operator=(const FormElementKey&);
 
-    AtomicStringImpl* name() const { return m_name; }
-    AtomicStringImpl* type() const { return m_type; }
+    StringImpl* name() const { return m_name; }
+    StringImpl* type() const { return m_type; }
 
     // Hash table deleted values, which are only constructed and never copied or destroyed.
     FormElementKey(WTF::HashTableDeletedValueType) : m_name(hashTableDeletedValue()) { }
     bool isHashTableDeletedValue() const { return m_name == hashTableDeletedValue(); }
 
 private:
     void ref() const;
     void deref() const;
 
-    static AtomicStringImpl* hashTableDeletedValue() { return reinterpret_cast<AtomicStringImpl*>(-1); }
+    static StringImpl* hashTableDeletedValue() { return reinterpret_cast<StringImpl*>(-1); }
 
-    AtomicStringImpl* m_name;
-    AtomicStringImpl* m_type;
+    StringImpl* m_name;
+    StringImpl* m_type;
 };
 
-FormElementKey::FormElementKey(AtomicStringImpl* name, AtomicStringImpl* type)
+FormElementKey::FormElementKey(StringImpl* name, StringImpl* type)
     : m_name(name)
     , m_type(type)
 {
     ref();
 }
 
 FormElementKey::~FormElementKey()
 {
     deref();
 }
@@ skipping 290 matching lines @@
     return stateMap.release();
 }
 
 Vector<String> FormController::formElementsState() const
 {
     OwnPtr<SavedFormStateMap> stateMap = createSavedFormStateMap(m_formElementsWithState);
     Vector<String> stateVector;
     stateVector.reserveInitialCapacity(m_formElementsWithState.size() * 4);
     stateVector.append(formStateSignature());
     for (SavedFormStateMap::const_iterator it = stateMap->begin(); it != stateMap->end(); ++it) {
-        stateVector.append(it->key.get());
+        stateVector.append(it->key);
         it->value->serializeTo(stateVector);
     }
     bool hasOnlySignature = stateVector.size() == 1;
     if (hasOnlySignature)
         stateVector.clear();
     return stateVector;
 }
 
 void FormController::setStateForNewFormElements(const Vector<String>& stateVector)
 {
@@ skipping 89 matching lines @@
     m_formElementsWithState.add(control);
 }
 
 void FormController::unregisterFormElementWithState(HTMLFormControlElementWithState* control)
 {
     RELEASE_ASSERT(m_formElementsWithState.contains(control));
     m_formElementsWithState.remove(control);
 }
 
 } // namespace WebCore