Remove OwnPtr from Blink.

third_party/WebKit/Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple 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,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 253 matching lines @@
     STATIC_ONLY(VectorComparer);
     static bool compare(const T* a, const T* b, size_t size)
     {
         ASSERT(a);
         ASSERT(b);
         return memcmp(a, b, sizeof(T) * size) == 0;
     }
 };
 
 template <typename T>
+struct VectorElementComparer {
+    STATIC_ONLY(VectorElementComparer);
+    template <typename U>
+    static bool compareElement(const T& left, const U& right)
+    {
+        return left == right;
+    }
+};
+
+template <typename T>
+struct VectorElementComparer<std::unique_ptr<T>> {
+    STATIC_ONLY(VectorElementComparer);
+    template <typename U>
+    static bool compareElement(const std::unique_ptr<T>& left, const U& right)
+    {
+        return left.get() == right;
+    }
+};
+
+template <typename T>
 struct VectorTypeOperations {
     STATIC_ONLY(VectorTypeOperations);
     static void destruct(T* begin, T* end)
     {
         VectorDestructor<VectorTraits<T>::needsDestruction, T>::destruct(begin, end);
     }
 
     static void initialize(T* begin, T* end)
     {
         VectorInitializer<VectorTraits<T>::canInitializeWithMemset, T>::initialize(begin, end);
@@ skipping 21 matching lines @@
 
     static void uninitializedFill(T* dst, T* dstEnd, const T& val)
     {
         VectorFiller<VectorTraits<T>::canFillWithMemset, T>::uninitializedFill(dst, dstEnd, val);
     }
 
     static bool compare(const T* a, const T* b, size_t size)
     {
         return VectorComparer<VectorTraits<T>::canCompareWithMemcmp, T>::compare(a, b, size);
     }
+
+    template <typename U>
+    static bool compareElement(const T& left, U&& right)
+    {
+        return VectorElementComparer<T>::compareElement(left, std::forward<U>(right));
+    }
 };
 
 template <typename T, bool hasInlineCapacity, typename Allocator>
 class VectorBufferBase {
     WTF_MAKE_NONCOPYABLE(VectorBufferBase);
     DISALLOW_NEW();
 public:
     void allocateBuffer(size_t newCapacity)
     {
         ASSERT(newCapacity);
@@ skipping 763 matching lines @@
     return find(value) != kNotFound;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 size_t Vector<T, inlineCapacity, Allocator>::find(const U& value) const
 {
     const T* b = begin();
     const T* e = end();
     for (const T* iter = b; iter < e; ++iter) {
-        if (*iter == value)
+        if (TypeOperations::compareElement(*iter, value))
             return iter - b;
     }
     return kNotFound;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 template <typename U>
 size_t Vector<T, inlineCapacity, Allocator>::reverseFind(const U& value) const
 {
     const T* b = begin();
     const T* iter = end();
     while (iter > b) {
         --iter;
-        if (*iter == value)
+        if (TypeOperations::compareElement(*iter, value))
             return iter - b;
     }
     return kNotFound;
 }
 
 template <typename T, size_t inlineCapacity, typename Allocator>
 void Vector<T, inlineCapacity, Allocator>::fill(const T& val, size_t newSize)
 {
     if (size() > newSize) {
         shrink(newSize);
@@ skipping 405 matching lines @@
             Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(visitor, *const_cast<T*>(bufferEntry));
         checkUnusedSlots(buffer() + size(), buffer() + capacity());
     }
 }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h