Remove OwnPtr from Blink.

third_party/WebKit/Source/wtf/VectorTest.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "wtf/Vector.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/HashSet.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
 namespace WTF {
 
 namespace {
 
 TEST(VectorTest, Basic)
 {
     Vector<int> intVector;
@@ skipping 113 matching lines @@
     { }
 
     ~DestructCounter() { ++(*m_destructNumber); }
     int get() const { return m_i; }
 
 private:
     int m_i;
     int* m_destructNumber;
 };
 
-typedef WTF::Vector<OwnPtr<DestructCounter>> OwnPtrVector;
+typedef WTF::Vector<std::unique_ptr<DestructCounter>> OwnPtrVector;
 
 TEST(VectorTest, OwnPtr)
 {
     int destructNumber = 0;
     OwnPtrVector vector;
-    vector.append(adoptPtr(new DestructCounter(0, &destructNumber)));
-    vector.append(adoptPtr(new DestructCounter(1, &destructNumber)));
+    vector.append(wrapUnique(new DestructCounter(0, &destructNumber)));
+    vector.append(wrapUnique(new DestructCounter(1, &destructNumber)));
     EXPECT_EQ(2u, vector.size());
 
-    OwnPtr<DestructCounter>& counter0 = vector.first();
+    std::unique_ptr<DestructCounter>& counter0 = vector.first();
     ASSERT_EQ(0, counter0->get());
     int counter1 = vector.last()->get();
     ASSERT_EQ(1, counter1);
     ASSERT_EQ(0, destructNumber);
 
     size_t index = 0;
     for (OwnPtrVector::iterator iter = vector.begin(); iter != vector.end(); ++iter) {
-        OwnPtr<DestructCounter>* refCounter = iter;
+        std::unique_ptr<DestructCounter>* refCounter = iter;
         EXPECT_EQ(index, static_cast<size_t>(refCounter->get()->get()));
         EXPECT_EQ(index, static_cast<size_t>((*refCounter)->get()));
         index++;
     }
     EXPECT_EQ(0, destructNumber);
 
     for (index = 0; index < vector.size(); index++) {
-        OwnPtr<DestructCounter>& refCounter = vector[index];
+        std::unique_ptr<DestructCounter>& refCounter = vector[index];
         EXPECT_EQ(index, static_cast<size_t>(refCounter->get()));
     }
     EXPECT_EQ(0, destructNumber);
 
     EXPECT_EQ(0, vector[0]->get());
     EXPECT_EQ(1, vector[1]->get());
     vector.remove(0);
     EXPECT_EQ(1, vector[0]->get());
     EXPECT_EQ(1u, vector.size());
     EXPECT_EQ(1, destructNumber);
 
-    OwnPtr<DestructCounter> ownCounter1 = std::move(vector[0]);
+    std::unique_ptr<DestructCounter> ownCounter1 = std::move(vector[0]);
     vector.remove(0);
     ASSERT_EQ(counter1, ownCounter1->get());
     ASSERT_EQ(0u, vector.size());
     ASSERT_EQ(1, destructNumber);
 
     ownCounter1.reset();
     EXPECT_EQ(2, destructNumber);
 
     size_t count = 1025;
     destructNumber = 0;
     for (size_t i = 0; i < count; i++)
-        vector.prepend(adoptPtr(new DestructCounter(i, &destructNumber)));
+        vector.prepend(wrapUnique(new DestructCounter(i, &destructNumber)));
 
-    // Vector relocation must not destruct OwnPtr element.
+    // Vector relocation must not destruct std::unique_ptr element.
     EXPECT_EQ(0, destructNumber);
     EXPECT_EQ(count, vector.size());
 
     OwnPtrVector copyVector;
     vector.swap(copyVector);
     EXPECT_EQ(0, destructNumber);
     EXPECT_EQ(count, copyVector.size());
     EXPECT_EQ(0u, vector.size());
 
     copyVector.clear();
@@ skipping 457 matching lines @@
     vector3 = {1, 2, 3};
     ASSERT_EQ(3u, vector3.size());
     EXPECT_EQ(1, vector3[0]);
     EXPECT_EQ(2, vector3[1]);
     EXPECT_EQ(3, vector3[2]);
 }
 
 } // anonymous namespace
 
 } // namespace WTF