Add std::unique_ptr conversions to scoped_ptr.

base/memory/scoped_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/scoped_ptr.h"
 
+#include <memory>
 #include <sstream>
+#include <utility>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // Used to test depth subtyping.
 class ConDecLoggerParent {
@@ skipping 701 matching lines @@
   // Go again, but this time, break the cycle by invoking |a|'s destructor. This
   // tests that the implementation of ~scoped_ptr doesn't infinitely recurse
   // into the destructors of |a| and |a->b|. Note, deleting |a| instead will
   // cause |a| to be double-free'd because |a->b| owns |a| and deletes it via
   // its destructor.
   a = new StructA;
   a->b.reset(new StructB);
   a->b->a.reset(a);
   a->~StructA();
 }
+
+TEST(ScopedPtrTest, UniquePtrToScopedPtr) {
+  {
+    std::unique_ptr<int> u(new int(8));
+    scoped_ptr<int> s(std::move(u));
+    EXPECT_EQ(8, *s);
+  }
+
+  {
+    std::unique_ptr<int> u(new int(8));
+    scoped_ptr<int> s;
+    s = std::move(u);
+    EXPECT_EQ(8, *s);
+  }
+}
+
+TEST(ScopedPtrTest, UniquePtrToScopedPtrWithCustomDeleter) {
+  double dummy, dummy2;
+  int deletes = 0;
+
+  {
+    std::unique_ptr<double, CountingDeleterChild> u(
+        &dummy, CountingDeleterChild(&deletes));
+    scoped_ptr<double, CountingDeleter> s(std::move(u));
+    EXPECT_EQ(&dummy, s.get());
+  }
+  EXPECT_EQ(1, deletes);
+
+  int deletes2 = 0;
+  {
+    std::unique_ptr<double, CountingDeleterChild> u(
+        &dummy, CountingDeleterChild(&deletes));
+    scoped_ptr<double, CountingDeleter> s(&dummy2, CountingDeleter(&deletes2));
+    s = std::move(u);
+    EXPECT_EQ(&dummy, s.get());
+  }
+  EXPECT_EQ(2, deletes);
+  EXPECT_EQ(1, deletes2);
+}
+
+TEST(ScopedPtrTest, ScopedPtrToUniquePtr) {
+  {
+    scoped_ptr<int> s(new int(9));
+    std::unique_ptr<int> u(std::move(s));
+    EXPECT_EQ(9, *u);
+  }
+
+  {
+    scoped_ptr<int> s(new int(9));
+    std::unique_ptr<int> u;
+    u = std::move(s);
+    EXPECT_EQ(9, *u);
+  }
+}
+
+TEST(ScopedPtrTest, ScopedPtrToUniquePtrWithCustomDeleter) {
+  double dummy, dummy2;
+  int deletes = 0;
+
+  {
+    scoped_ptr<double, CountingDeleterChild> s(&dummy,
+                                               CountingDeleterChild(&deletes));
+    std::unique_ptr<double, CountingDeleter> u(std::move(s));
+    EXPECT_EQ(&dummy, u.get());
+  }
+  EXPECT_EQ(1, deletes);
+
+  int deletes2 = 0;
+  {
+    scoped_ptr<double, CountingDeleterChild> s(&dummy,
+                                               CountingDeleterChild(&deletes));
+    std::unique_ptr<double, CountingDeleter> u(&dummy2,
+                                               CountingDeleter(&deletes2));
+    u = std::move(s);
+    EXPECT_EQ(&dummy, u.get());
+  }
+  EXPECT_EQ(2, deletes);
+  EXPECT_EQ(1, deletes2);
+}