Convert //base to use std::unique_ptr

base/bind_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "base/bind.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace base {
@@ skipping 785 matching lines @@
 //   - Callback supports unbound arguments.
 template <typename T>
 class BindMoveOnlyTypeTest : public ::testing::Test {
 };
 
 struct CustomDeleter {
   void operator()(DeleteCounter* c) { delete c; }
 };
 
 using MoveOnlyTypesToTest =
-    ::testing::Types<scoped_ptr<DeleteCounter>,
+    ::testing::Types<std::unique_ptr<DeleteCounter>,
                      std::unique_ptr<DeleteCounter>,
                      std::unique_ptr<DeleteCounter, CustomDeleter>>;
 TYPED_TEST_CASE(BindMoveOnlyTypeTest, MoveOnlyTypesToTest);
 
 TYPED_TEST(BindMoveOnlyTypeTest, PassedToBoundCallback) {
   int deletes = 0;
 
   TypeParam ptr(new DeleteCounter(&deletes));
   Callback<TypeParam()> callback = Bind(&PassThru<TypeParam>, Passed(&ptr));
   EXPECT_FALSE(ptr.get());
@@ skipping 36 matching lines @@
 
 TYPED_TEST(BindMoveOnlyTypeTest, UnboundForwarding) {
   int deletes = 0;
   TypeParam ptr(new DeleteCounter(&deletes));
   // Test unbound argument forwarding.
   Callback<TypeParam(TypeParam)> cb_unbound = Bind(&PassThru<TypeParam>);
   cb_unbound.Run(std::move(ptr));
   EXPECT_EQ(1, deletes);
 }
 
-void VerifyVector(const std::vector<scoped_ptr<int>>& v) {
+void VerifyVector(const std::vector<std::unique_ptr<int>>& v) {
   ASSERT_EQ(1u, v.size());
   EXPECT_EQ(12345, *v[0]);
 }
 
-std::vector<scoped_ptr<int>> AcceptAndReturnMoveOnlyVector(
-    std::vector<scoped_ptr<int>> v) {
+std::vector<std::unique_ptr<int>> AcceptAndReturnMoveOnlyVector(
+    std::vector<std::unique_ptr<int>> v) {
   VerifyVector(v);
   return v;
 }
 
 // Test that a vector containing move-only types can be used with Callback.
 TEST_F(BindTest, BindMoveOnlyVector) {
-  using MoveOnlyVector = std::vector<scoped_ptr<int>>;
+  using MoveOnlyVector = std::vector<std::unique_ptr<int>>;
 
   MoveOnlyVector v;
-  v.push_back(make_scoped_ptr(new int(12345)));
+  v.push_back(WrapUnique(new int(12345)));
 
   // Early binding should work:
   base::Callback<MoveOnlyVector()> bound_cb =
       base::Bind(&AcceptAndReturnMoveOnlyVector, Passed(&v));
   MoveOnlyVector intermediate_result = bound_cb.Run();
   VerifyVector(intermediate_result);
 
   // As should passing it as an argument to Run():
   base::Callback<MoveOnlyVector(MoveOnlyVector)> unbound_cb =
       base::Bind(&AcceptAndReturnMoveOnlyVector);
@@ skipping 189 matching lines @@
   base::Callback<void(int)> null_cb;
   ASSERT_TRUE(null_cb.is_null());
   EXPECT_DEATH(base::Bind(null_cb, 42), "");
 }
 
 #endif  // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) &&
         //     GTEST_HAS_DEATH_TEST
 
 }  // namespace
 }  // namespace base