Convert //base to use std::unique_ptr

base/memory/weak_ptr_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/memory/weak_ptr.h"
 
+#include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/location.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 template <class T>
 class OffThreadObjectCreator {
@@ skipping 297 matching lines @@
     WeakPtr<int> ptr = factory.GetWeakPtr();
     EXPECT_TRUE(factory.HasWeakPtrs());
   }
   EXPECT_FALSE(factory.HasWeakPtrs());
 }
 
 TEST(WeakPtrTest, ObjectAndWeakPtrOnDifferentThreads) {
   // Test that it is OK to create an object that supports WeakPtr on one thread,
   // but use it on another.  This tests that we do not trip runtime checks that
   // ensure that a WeakPtr is not used by multiple threads.
-  scoped_ptr<Target> target(OffThreadObjectCreator<Target>::NewObject());
+  std::unique_ptr<Target> target(OffThreadObjectCreator<Target>::NewObject());
   WeakPtr<Target> weak_ptr = target->AsWeakPtr();
   EXPECT_EQ(target.get(), weak_ptr.get());
 }
 
 TEST(WeakPtrTest, WeakPtrInitiateAndUseOnDifferentThreads) {
   // Test that it is OK to create an object that has a WeakPtr member on one
   // thread, but use it on another.  This tests that we do not trip runtime
   // checks that ensure that a WeakPtr is not used by multiple threads.
-  scoped_ptr<Arrow> arrow(OffThreadObjectCreator<Arrow>::NewObject());
+  std::unique_ptr<Arrow> arrow(OffThreadObjectCreator<Arrow>::NewObject());
   Target target;
   arrow->target = target.AsWeakPtr();
   EXPECT_EQ(&target, arrow->target.get());
 }
 
 TEST(WeakPtrTest, MoveOwnershipImplicitly) {
   // Move object ownership to another thread by releasing all weak pointers
   // on the original thread first, and then establish WeakPtr on a different
   // thread.
   BackgroundThread background;
@@ skipping 52 matching lines @@
   }
 
   delete arrow;
 }
 
 TEST(WeakPtrTest, MoveOwnershipAfterInvalidate) {
   BackgroundThread background;
   background.Start();
 
   Arrow arrow;
-  scoped_ptr<TargetWithFactory> target(new TargetWithFactory);
+  std::unique_ptr<TargetWithFactory> target(new TargetWithFactory);
 
   // Bind to main thread.
   arrow.target = target->factory.GetWeakPtr();
   EXPECT_EQ(target.get(), arrow.target.get());
 
   target->factory.InvalidateWeakPtrs();
   EXPECT_EQ(NULL, arrow.target.get());
 
   arrow.target = target->factory.GetWeakPtr();
   // Re-bind to background thread.
@@ skipping 149 matching lines @@
   BackgroundThread background;
   background.Start();
   ASSERT_DEATH(background.DeRef(&arrow), "");
 }
 
 TEST(WeakPtrDeathTest, NonOwnerThreadDeletesWeakPtrAfterReference) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
-  scoped_ptr<Target> target(new Target());
+  std::unique_ptr<Target> target(new Target());
 
   // Main thread creates an arrow referencing the Target.
   Arrow arrow;
   arrow.target = target->AsWeakPtr();
 
   // Background thread tries to deref target, binding it to the thread.
   BackgroundThread background;
   background.Start();
   background.DeRef(&arrow);
 
   // Main thread deletes Target, violating thread binding.
   ASSERT_DEATH(target.reset(), "");
 
   // |target.reset()| died so |target| still holds the object, so we
   // must pass it to the background thread to teardown.
   background.DeleteTarget(target.release());
 }
 
 TEST(WeakPtrDeathTest, NonOwnerThreadDeletesObjectAfterReference) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
-  scoped_ptr<Target> target(new Target());
+  std::unique_ptr<Target> target(new Target());
 
   // Main thread creates an arrow referencing the Target, and references it, so
   // that it becomes bound to the thread.
   Arrow arrow;
   arrow.target = target->AsWeakPtr();
   arrow.target.get();
 
   // Background thread tries to delete target, volating thread binding.
   BackgroundThread background;
   background.Start();
   ASSERT_DEATH(background.DeleteTarget(target.release()), "");
 }
 
 TEST(WeakPtrDeathTest, NonOwnerThreadReferencesObjectAfterDeletion) {
   // The default style "fast" does not support multi-threaded tests
   // (introduces deadlock on Linux).
   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 
-  scoped_ptr<Target> target(new Target());
+  std::unique_ptr<Target> target(new Target());
 
   // Main thread creates an arrow referencing the Target.
   Arrow arrow;
   arrow.target = target->AsWeakPtr();
 
   // Background thread tries to delete target, binding the object to the thread.
   BackgroundThread background;
   background.Start();
   background.DeleteTarget(target.release());
 
   // Main thread attempts to dereference the target, violating thread binding.
   ASSERT_DEATH(arrow.target.get(), "");
 }
 
 #endif
 
 }  // namespace base