Remove OwnPtr from Blink.

third_party/WebKit/Source/wtf/TerminatedArray.h

 // Copyright 2014 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 TerminatedArray_h
 #define TerminatedArray_h
 
 #include "wtf/Allocator.h"
-#include "wtf/OwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/allocator/Partitions.h"
+#include <memory>
 
 namespace WTF {
 
 // TerminatedArray<T> represents a sequence of elements of type T in which each
 // element knows whether it is the last element in the sequence or not. For this
 // check type T must provide isLastInArray method.
 // TerminatedArray<T> can only be constructed by TerminatedArrayBuilder<T>.
 template<typename T>
 class TerminatedArray {
     DISALLOW_NEW();
@@ skipping 39 matching lines @@
     const_iterator end() const { return const_iterator(0); }
 
     size_t size() const
     {
         size_t count = 0;
         for (const_iterator it = begin(); it != end(); ++it)
             count++;
         return count;
     }
 
-    // Match Allocator semantics to be able to use OwnPtr<TerminatedArray>.
+    // Match Allocator semantics to be able to use std::unique_ptr<TerminatedArray>.
     void operator delete(void* p) { ::WTF::Partitions::fastFree(p); }
 
 private:
     // Allocator describes how TerminatedArrayBuilder should create new instances
     // of TerminateArray and manage their lifetimes.
     struct Allocator {
         STATIC_ONLY(Allocator);
-        using PassPtr = PassOwnPtr<TerminatedArray>;
-        using Ptr = OwnPtr<TerminatedArray>;
+        using PassPtr = std::unique_ptr<TerminatedArray>;
+        using Ptr = std::unique_ptr<TerminatedArray>;
 
         static PassPtr release(Ptr& ptr)
         {
             return ptr.release();
         }
 
         static PassPtr create(size_t capacity)
         {
-            return adoptPtr(static_cast<TerminatedArray*>(WTF::Partitions::fastMalloc(capacity * sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T))));
+            return wrapUnique(static_cast<TerminatedArray*>(WTF::Partitions::fastMalloc(capacity * sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T))));
         }
 
         static PassPtr resize(Ptr ptr, size_t capacity)
         {
-            return adoptPtr(static_cast<TerminatedArray*>(WTF::Partitions::fastRealloc(ptr.leakPtr(), capacity * sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T))));
+            return wrapUnique(static_cast<TerminatedArray*>(WTF::Partitions::fastRealloc(ptr.release(), capacity * sizeof(T), WTF_HEAP_PROFILER_TYPE_NAME(T))));
         }
     };
 
     // Prohibit construction. Allocator makes TerminatedArray instances for
     // TerminatedArrayBuilder by pointer casting.
     TerminatedArray();
 
     template<typename, template <typename> class> friend class TerminatedArrayBuilder;
 };
 
 } // namespace WTF
 
 using WTF::TerminatedArray;
 
 #endif // TerminatedArray_h