Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/wtf/HashFunctions.h

 /*
  * Copyright (C) 2005, 2006, 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
  * 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_HashFunctions_h
 #define WTF_HashFunctions_h
 
+#include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/StdLibExtras.h"
 #include <memory>
 #include <stdint.h>
 #include <type_traits>
 
 namespace WTF {
 
 template <size_t size> struct IntTypes;
 template <> struct IntTypes<1> { typedef int8_t SignedType; typedef uint8_t UnsignedType; };
@@ skipping 113 matching lines @@
     static unsigned hash(const RefPtr<T>& key) { return hash(key.get()); }
     static unsigned hash(const PassRefPtr<T>& key) { return hash(key.get()); }
     using PtrHash<T>::equal;
     static bool equal(const RefPtr<T>& a, const RefPtr<T>& b) { return a == b; }
     static bool equal(T* a, const RefPtr<T>& b) { return a == b; }
     static bool equal(const RefPtr<T>& a, T* b) { return a == b; }
     static bool equal(const RefPtr<T>& a, const PassRefPtr<T>& b) { return a == b; }
 };
 
 template <typename T>
+struct OwnPtrHash : PtrHash<T> {
+    using PtrHash<T>::hash;
+    static unsigned hash(const OwnPtr<T>& key) { return hash(key.get()); }
+
+    static bool equal(const OwnPtr<T>& a, const OwnPtr<T>& b)
+    {
+        return a.get() == b.get();
+    }
+    static bool equal(const OwnPtr<T>& a, T* b) { return a == b; }
+};
+
+template <typename T>
 struct UniquePtrHash : PtrHash<T> {
     using PtrHash<T>::hash;
     static unsigned hash(const std::unique_ptr<T>& key) { return hash(key.get()); }
     static bool equal(const std::unique_ptr<T>& a, const std::unique_ptr<T>& b) { return a == b; }
     static bool equal(const std::unique_ptr<T>& a, const T* b) { return a.get() == b; }
     static bool equal(const T* a, const std::unique_ptr<T>& b) { return a == b.get(); }
 };
 
 // Default hash function for each type.
 template <typename T>
@@ skipping 28 matching lines @@
 // Specializations for pointer types.
 template <typename T>
 struct DefaultHash<T*> {
     using Hash = PtrHash<T>;
 };
 template <typename T>
 struct DefaultHash<RefPtr<T>> {
     using Hash = RefPtrHash<T>;
 };
 template <typename T>
+struct DefaultHash<OwnPtr<T>> {
+    using Hash = OwnPtrHash<T>;
+};
+template <typename T>
 struct DefaultHash<std::unique_ptr<T>> {
     using Hash = UniquePtrHash<T>;
 };
 
 // Specializations for pairs.
 
 // Generic case (T or U is non-integral):
 template <typename T, typename U, bool areBothIntegral>
 struct PairHashImpl {
     static unsigned hash(const std::pair<T, U>& p)
@@ skipping 28 matching lines @@
     using Hash = PairHash<T, U>;
 };
 
 } // namespace WTF
 
 using WTF::DefaultHash;
 using WTF::IntHash;
 using WTF::PtrHash;
 
 #endif // WTF_HashFunctions_h