Use AtomicString instead of StringImpl* in PropertyHandle

third_party/WebKit/Source/core/animation/PropertyHandle.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PropertyHandle_h
 #define PropertyHandle_h
 
 #include "core/CSSPropertyNames.h"
 #include "core/CoreExport.h"
 #include "core/dom/QualifiedName.h"
@@ skipping 10 matching lines @@
                           bool isPresentationAttribute = false)
       : m_handleType(isPresentationAttribute ? HandlePresentationAttribute
                                              : HandleCSSProperty),
         m_cssProperty(property) {
     DCHECK_NE(property, CSSPropertyInvalid);
     DCHECK_NE(property, CSSPropertyVariable);
   }
 
   explicit PropertyHandle(const AtomicString& propertyName)
       : m_handleType(HandleCSSCustomProperty),
-        m_propertyName(propertyName.impl()) {}
+        m_svgAttribute(nullptr),
+        m_propertyName(propertyName) {}
 
   explicit PropertyHandle(const QualifiedName& attributeName)
       : m_handleType(HandleSVGAttribute), m_svgAttribute(&attributeName) {}
 
   bool operator==(const PropertyHandle&) const;
   bool operator!=(const PropertyHandle& other) const {
     return !(*this == other);
   }
 
   unsigned hash() const;
 
   bool isCSSProperty() const {
     return m_handleType == HandleCSSProperty || isCSSCustomProperty();
   }
   CSSPropertyID cssProperty() const {
     DCHECK(isCSSProperty());
     return m_handleType == HandleCSSProperty ? m_cssProperty
                                              : CSSPropertyVariable;
   }
 
   bool isCSSCustomProperty() const {
     return m_handleType == HandleCSSCustomProperty;
   }
-  AtomicString customPropertyName() const {
+  const AtomicString& customPropertyName() const {
     DCHECK(isCSSCustomProperty());
-    return AtomicString(m_propertyName);
+    return m_propertyName;
   }
 
   bool isPresentationAttribute() const {
     return m_handleType == HandlePresentationAttribute;
   }
   CSSPropertyID presentationAttribute() const {
     DCHECK(isPresentationAttribute());
     return m_cssProperty;
   }
 
@@ skipping 25 matching lines @@
   }
 
   bool isDeletedValueForHashTraits() {
     return m_handleType == HandleDeletedValueForHashTraits;
   }
 
   HandleType m_handleType;
   union {
     CSSPropertyID m_cssProperty;
     const QualifiedName* m_svgAttribute;
-    StringImpl* m_propertyName;
   };
+  AtomicString m_propertyName;
 
   friend struct ::WTF::HashTraits<blink::PropertyHandle>;
 };
 
 }  // namespace blink
 
 namespace WTF {
 
 template <>
 struct DefaultHash<blink::PropertyHandle> {
   struct Hash {
     STATIC_ONLY(Hash);
     static unsigned hash(const blink::PropertyHandle& handle) {
       return handle.hash();
     }
 
     static bool equal(const blink::PropertyHandle& a,
                       const blink::PropertyHandle& b) {
       return a == b;
     }
 
     static const bool safeToCompareToEmptyOrDeleted = true;
   };
 };
 
 template <>
 struct HashTraits<blink::PropertyHandle>
     : SimpleClassHashTraits<blink::PropertyHandle> {
-  static const bool needsDestruction = false;
+  static const bool needsDestruction = true;
   static void constructDeletedValue(blink::PropertyHandle& slot, bool) {
     new (NotNull, &slot) blink::PropertyHandle(
         blink::PropertyHandle::deletedValueForHashTraits());
   }
   static bool isDeletedValue(blink::PropertyHandle value) {
     return value.isDeletedValueForHashTraits();
   }
 
   static blink::PropertyHandle emptyValue() {
     return blink::PropertyHandle::emptyValueForHashTraits();
   }
 };
 
 }  // namespace WTF
 
 #endif  // PropertyHandle_h