Move parts of core/dom to C++11

Source/core/dom/AttributeCollection.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 24 matching lines @@
 
 #include "core/dom/Attr.h"
 #include "core/dom/Attribute.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 template <typename Container, typename ContainerMemberType = Container>
 class AttributeCollectionGeneric {
 public:
-    typedef typename Container::ValueType ValueType;
-    typedef ValueType* iterator;
+    using ValueType = typename Container::ValueType;
+    using iterator = ValueType*;
 
     AttributeCollectionGeneric(Container& attributes)
         : m_attributes(attributes)
     { }
 
     ValueType& operator[](unsigned index) const { return at(index); }
     ValueType& at(unsigned index) const
     {
         RELEASE_ASSERT(index < size());
         return begin()[index];
@@ skipping 12 matching lines @@
     size_t findIndex(Attr*) const;
 
 protected:
     size_t findSlowCase(const AtomicString& name, bool shouldIgnoreAttributeCase) const;
 
     ContainerMemberType m_attributes;
 };
 
 class AttributeArray {
 public:
-    typedef const Attribute ValueType;
+    using ValueType = const Attribute;
 
     AttributeArray(const Attribute* array, unsigned size)
         : m_array(array)
         , m_size(size)
     { }
 
     const Attribute* data() const { return m_array; }
     unsigned size() const { return m_size; }
 
 private:
     const Attribute* m_array;
     unsigned m_size;
 };
 
 class AttributeCollection : public AttributeCollectionGeneric<const AttributeArray> {
 public:
     AttributeCollection()
         : AttributeCollectionGeneric<const AttributeArray>(AttributeArray(nullptr, 0))
     { }
 
     AttributeCollection(const Attribute* array, unsigned size)
         : AttributeCollectionGeneric<const AttributeArray>(AttributeArray(array, size))
     { }
 };
 
-typedef Vector<Attribute, 4> AttributeVector;
+using AttributeVector = Vector<Attribute, 4>;
 class MutableAttributeCollection : public AttributeCollectionGeneric<AttributeVector, AttributeVector&> {
 public:
     explicit MutableAttributeCollection(AttributeVector& attributes)
         : AttributeCollectionGeneric<AttributeVector, AttributeVector&>(attributes)
     { }
 
     // These functions do no error/duplicate checking.
     void append(const QualifiedName&, const AtomicString& value);
     void remove(unsigned index);
 };
 
 inline void MutableAttributeCollection::append(const QualifiedName& name, const AtomicString& value)
 {
     m_attributes.append(Attribute(name, value));
 }
 
 inline void MutableAttributeCollection::remove(unsigned index)
 {
     m_attributes.remove(index);
 }
 
 template <typename Container, typename ContainerMemberType>
 inline typename AttributeCollectionGeneric<Container, ContainerMemberType>::iterator AttributeCollectionGeneric<Container, ContainerMemberType>::find(const AtomicString& name, bool shouldIgnoreCase) const
 {
     size_t index = findIndex(name, shouldIgnoreCase);
-    return index != kNotFound ? &at(index) : 0;
+    return index != kNotFound ? &at(index) : nullptr;
 }
 
 template <typename Container, typename ContainerMemberType>
 inline size_t AttributeCollectionGeneric<Container, ContainerMemberType>::findIndex(const QualifiedName& name, bool shouldIgnoreCase) const
 {
     iterator end = this->end();
     unsigned index = 0;
     for (iterator it = begin(); it != end; ++it, ++index) {
         if (it->name().matchesPossiblyIgnoringCase(name, shouldIgnoreCase))
             return index;
@@ skipping 28 matching lines @@
 }
 
 template <typename Container, typename ContainerMemberType>
 inline typename AttributeCollectionGeneric<Container, ContainerMemberType>::iterator AttributeCollectionGeneric<Container, ContainerMemberType>::find(const QualifiedName& name) const
 {
     iterator end = this->end();
     for (iterator it = begin(); it != end; ++it) {
         if (it->name().matches(name))
             return it;
     }
-    return 0;
+    return nullptr;
 }
 
 template <typename Container, typename ContainerMemberType>
 size_t AttributeCollectionGeneric<Container, ContainerMemberType>::findIndex(Attr* attr) const
 {
     // This relies on the fact that Attr's QualifiedName == the Attribute's name.
     iterator end = this->end();
     unsigned index = 0;
     for (iterator it = begin(); it != end; ++it, ++index) {
         if (it->name() == attr->qualifiedName())
@@ skipping 21 matching lines @@
             if (equalPossiblyIgnoringCase(name, it->name().toString(), shouldIgnoreAttributeCase))
                 return index;
         }
     }
     return kNotFound;
 }
 
 } // namespace blink
 
 #endif // AttributeCollection_h