Revert "Remove OwnPtr from Blink."

third_party/WebKit/Source/wtf/VectorTraits.h

 /*
  * Copyright (C) 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
  * 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_VectorTraits_h
 #define WTF_VectorTraits_h
 
+#include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/TypeTraits.h"
-#include <memory>
 #include <type_traits>
 #include <utility>
 
 namespace WTF {
 
 class AtomicString;
 
 template <typename T>
 struct VectorTraitsBase {
     static const bool needsDestruction = !IsTriviallyDestructible<T>::value;
@@ skipping 24 matching lines @@
 // instead of constructors, copy operators, etc for initialization, move and
 // comparison.
 template <typename T>
 struct SimpleClassVectorTraits : VectorTraitsBase<T> {
     static const bool canInitializeWithMemset = true;
     static const bool canClearUnusedSlotsWithMemset = true;
     static const bool canMoveWithMemcpy = true;
     static const bool canCompareWithMemcmp = true;
 };
 
-// We know std::unique_ptr and RefPtr are simple enough that initializing to 0 and moving
+// We know OwnPtr and RefPtr are simple enough that initializing to 0 and moving
 // with memcpy (and then not destructing the original) will totally work.
 template <typename P>
 struct VectorTraits<RefPtr<P>> : SimpleClassVectorTraits<RefPtr<P>> {};
 
 template <typename P>
-struct VectorTraits<std::unique_ptr<P>> : SimpleClassVectorTraits<std::unique_ptr<P>> {
-    // std::unique_ptr -> std::unique_ptr has a very particular structure that tricks the
+struct VectorTraits<OwnPtr<P>> : SimpleClassVectorTraits<OwnPtr<P>> {
+    // OwnPtr -> PassOwnPtr has a very particular structure that tricks the
     // normal type traits into thinking that the class is "trivially copyable".
     static const bool canCopyWithMemcpy = false;
 };
 static_assert(VectorTraits<RefPtr<int>>::canInitializeWithMemset, "inefficient RefPtr Vector");
 static_assert(VectorTraits<RefPtr<int>>::canMoveWithMemcpy, "inefficient RefPtr Vector");
 static_assert(VectorTraits<RefPtr<int>>::canCompareWithMemcmp, "inefficient RefPtr Vector");
-static_assert(VectorTraits<std::unique_ptr<int>>::canInitializeWithMemset, "inefficient std::unique_ptr Vector");
-static_assert(VectorTraits<std::unique_ptr<int>>::canMoveWithMemcpy, "inefficient std::unique_ptr Vector");
-static_assert(VectorTraits<std::unique_ptr<int>>::canCompareWithMemcmp, "inefficient std::unique_ptr Vector");
+static_assert(VectorTraits<OwnPtr<int>>::canInitializeWithMemset, "inefficient OwnPtr Vector");
+static_assert(VectorTraits<OwnPtr<int>>::canMoveWithMemcpy, "inefficient OwnPtr Vector");
+static_assert(VectorTraits<OwnPtr<int>>::canCompareWithMemcmp, "inefficient OwnPtr Vector");
 
 template <typename First, typename Second>
 struct VectorTraits<std::pair<First, Second>> {
     typedef VectorTraits<First> FirstTraits;
     typedef VectorTraits<Second> SecondTraits;
 
     static const bool needsDestruction = FirstTraits::needsDestruction || SecondTraits::needsDestruction;
     static const bool canInitializeWithMemset = FirstTraits::canInitializeWithMemset && SecondTraits::canInitializeWithMemset;
     static const bool canMoveWithMemcpy = FirstTraits::canMoveWithMemcpy && SecondTraits::canMoveWithMemcpy;
     static const bool canCopyWithMemcpy = FirstTraits::canCopyWithMemcpy && SecondTraits::canCopyWithMemcpy;
@@ skipping 46 matching lines @@
 struct VectorTraits<ClassName> : VectorTraitsBase<ClassName> \
 { \
     static const bool canClearUnusedSlotsWithMemset = true; \
 }; \
 }
 
 using WTF::VectorTraits;
 using WTF::SimpleClassVectorTraits;
 
 #endif // WTF_VectorTraits_h