Remove OwnPtr from Blink.

third_party/WebKit/Source/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * 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 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef WTF_HashTable_h
 #define WTF_HashTable_h
 
 #include "wtf/Alignment.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/ConditionalDestructor.h"
 #include "wtf/HashTraits.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/allocator/PartitionAllocator.h"
+#include <memory>
 
 #define DUMP_HASHTABLE_STATS 0
 #define DUMP_HASHTABLE_STATS_PER_TABLE 0
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
 #include "wtf/DataLog.h"
 #endif
 
 #if DUMP_HASHTABLE_STATS
 #if DUMP_HASHTABLE_STATS_PER_TABLE
@@ skipping 533 matching lines @@
     unsigned m_queueFlag:1;
     unsigned m_accessForbidden:1;
     unsigned m_modifications;
 #else
     unsigned m_deletedCount:31;
     unsigned m_queueFlag:1;
 #endif
 
 #if DUMP_HASHTABLE_STATS_PER_TABLE
 public:
-    mutable OwnPtr<Stats> m_stats;
+    mutable std::unique_ptr<Stats> m_stats;
 #endif
 
     template <WeakHandlingFlag x, typename T, typename U, typename V, typename W, typename X, typename Y, typename Z> friend struct WeakProcessingHashTableHelper;
     template <typename T, typename U, typename V, typename W> friend class LinkedHashSet;
 };
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 inline HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable()
     : m_table(nullptr)
     , m_tableSize(0)
     , m_keyCount(0)
     , m_deletedCount(0)
     , m_queueFlag(false)
 #if ENABLE(ASSERT)
     , m_accessForbidden(false)
     , m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-    , m_stats(adoptPtr(new Stats))
+    , m_stats(wrapUnique(new Stats))
 #endif
 {
     static_assert(Allocator::isGarbageCollected || (!IsPointerToGarbageCollectedType<Key>::value && !IsPointerToGarbageCollectedType<Value>::value), "Cannot put raw pointers to garbage-collected classes into an off-heap collection.");
 }
 
 inline unsigned doubleHash(unsigned key)
 {
     key = ~key + (key >> 23);
     key ^= (key << 12);
     key ^= (key >> 7);
@@ skipping 616 matching lines @@
     : m_table(nullptr)
     , m_tableSize(0)
     , m_keyCount(0)
     , m_deletedCount(0)
     , m_queueFlag(false)
 #if ENABLE(ASSERT)
     , m_accessForbidden(false)
     , m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-    , m_stats(adoptPtr(new Stats(*other.m_stats)))
+    , m_stats(wrapUnique(new Stats(*other.m_stats)))
 #endif
 {
     // Copy the hash table the dumb way, by adding each element to the new
     // table.  It might be more efficient to copy the table slots, but it's not
     // clear that efficiency is needed.
     const_iterator end = other.end();
     for (const_iterator it = other.begin(); it != end; ++it)
         add(*it);
 }
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::HashTable(HashTable&& other)
     : m_table(nullptr)
     , m_tableSize(0)
     , m_keyCount(0)
     , m_deletedCount(0)
     , m_queueFlag(false)
 #if ENABLE(ASSERT)
     , m_accessForbidden(false)
     , m_modifications(0)
 #endif
 #if DUMP_HASHTABLE_STATS_PER_TABLE
-    , m_stats(adoptPtr(new Stats(*other.m_stats)))
+    , m_stats(wrapUnique(new Stats(*other.m_stats)))
 #endif
 {
     swap(other);
 }
 
 
 template <typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
 void HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>::swap(HashTable& other)
 {
     ASSERT(!m_accessForbidden);
@@ skipping 263 matching lines @@
     CollectionIterator end(toBeRemoved.end());
     for (CollectionIterator it(toBeRemoved.begin()); it != end; ++it)
         collection.remove(*it);
 }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h