base: Use std::move() instead of Pass() for real movable types.

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 <sstream>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 66 matching lines @@
 
  private:
   static int g_new_count;
   static int g_delete_count;
 };
 
 int OverloadedNewAndDelete::g_new_count = 0;
 int OverloadedNewAndDelete::g_delete_count = 0;
 
 scoped_ptr<ConDecLogger> PassThru(scoped_ptr<ConDecLogger> logger) {
-  return logger.Pass();
+  return logger;
 }
 
 void GrabAndDrop(scoped_ptr<ConDecLogger> logger) {
 }
 
 // Do not delete this function!  It's existence is to test that you can
 // return a temporarily constructed version of the scoper.
 scoped_ptr<ConDecLogger> TestReturnOfType(int* constructed) {
   return scoped_ptr<ConDecLogger>(new ConDecLogger(constructed));
 }
@@ skipping 73 matching lines @@
 
 TEST(ScopedPtrTest, ScopedPtrDepthSubtyping) {
   int constructed = 0;
 
   // Test construction from a scoped_ptr to a derived class.
   {
     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper.get());
 
-    scoped_ptr<ConDecLoggerParent> scoper_parent(scoper.Pass());
+    scoped_ptr<ConDecLoggerParent> scoper_parent(std::move(scoper));
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper_parent.get());
     EXPECT_FALSE(scoper.get());
 
     EXPECT_EQ(10, scoper_parent->SomeMeth(10));
     EXPECT_EQ(10, scoper_parent.get()->SomeMeth(10));
     EXPECT_EQ(10, (*scoper_parent).SomeMeth(10));
   }
   EXPECT_EQ(0, constructed);
 
   // Test assignment from a scoped_ptr to a derived class.
   {
     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper.get());
 
     scoped_ptr<ConDecLoggerParent> scoper_parent;
-    scoper_parent = scoper.Pass();
+    scoper_parent = std::move(scoper);
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper_parent.get());
     EXPECT_FALSE(scoper.get());
   }
   EXPECT_EQ(0, constructed);
 
   // Test construction of a scoped_ptr with an additional const annotation.
   {
     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper.get());
 
-    scoped_ptr<const ConDecLogger> scoper_const(scoper.Pass());
+    scoped_ptr<const ConDecLogger> scoper_const(std::move(scoper));
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper_const.get());
     EXPECT_FALSE(scoper.get());
 
     EXPECT_EQ(10, scoper_const->SomeMeth(10));
     EXPECT_EQ(10, scoper_const.get()->SomeMeth(10));
     EXPECT_EQ(10, (*scoper_const).SomeMeth(10));
   }
   EXPECT_EQ(0, constructed);
 
   // Test assignment to a scoped_ptr with an additional const annotation.
   {
     scoped_ptr<ConDecLogger> scoper(new ConDecLogger(&constructed));
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper.get());
 
     scoped_ptr<const ConDecLogger> scoper_const;
-    scoper_const = scoper.Pass();
+    scoper_const = std::move(scoper);
     EXPECT_EQ(1, constructed);
     EXPECT_TRUE(scoper_const.get());
     EXPECT_FALSE(scoper.get());
   }
   EXPECT_EQ(0, constructed);
 
   // Test assignment to a scoped_ptr deleter of parent type.
   {
     // Custom deleters never touch these value.
     double dummy_value, dummy_value2;
     int deletes = 0;
     int alternate_deletes = 0;
     scoped_ptr<double, CountingDeleter> scoper(&dummy_value,
                                                CountingDeleter(&deletes));
     scoped_ptr<double, CountingDeleterChild> scoper_child(
         &dummy_value2, CountingDeleterChild(&alternate_deletes));
 
     EXPECT_TRUE(scoper);
     EXPECT_TRUE(scoper_child);
     EXPECT_EQ(0, deletes);
     EXPECT_EQ(0, alternate_deletes);
 
     // Test this compiles and correctly overwrites the deleter state.
-    scoper = scoper_child.Pass();
+    scoper = std::move(scoper_child);
     EXPECT_TRUE(scoper);
     EXPECT_FALSE(scoper_child);
     EXPECT_EQ(1, deletes);
     EXPECT_EQ(0, alternate_deletes);
 
     scoper.reset();
     EXPECT_FALSE(scoper);
     EXPECT_FALSE(scoper_child);
     EXPECT_EQ(1, deletes);
     EXPECT_EQ(1, alternate_deletes);
 
     scoper_child.reset(&dummy_value);
     EXPECT_TRUE(scoper_child);
     EXPECT_EQ(1, deletes);
     EXPECT_EQ(1, alternate_deletes);
-    scoped_ptr<double, CountingDeleter> scoper_construct(scoper_child.Pass());
+    scoped_ptr<double, CountingDeleter> scoper_construct(
+        std::move(scoper_child));
     EXPECT_TRUE(scoper_construct);
     EXPECT_FALSE(scoper_child);
     EXPECT_EQ(1, deletes);
     EXPECT_EQ(1, alternate_deletes);
 
     scoper_construct.reset();
     EXPECT_EQ(1, deletes);
     EXPECT_EQ(2, alternate_deletes);
   }
 }
@@ skipping 75 matching lines @@
 
   {
     ConDecLogger* loggers = new ConDecLogger[kNumLoggers];
     scoped_ptr<ConDecLogger[]> scoper(loggers);
     EXPECT_TRUE(scoper);
     for (int i = 0; i < kNumLoggers; ++i) {
       scoper[i].SetPtr(&constructed);
     }
     EXPECT_EQ(kNumLoggers, constructed);
 
-    // Test Pass() with constructor;
-    scoped_ptr<ConDecLogger[]> scoper2(scoper.Pass());
+    // Test moving with constructor;
+    scoped_ptr<ConDecLogger[]> scoper2(std::move(scoper));
     EXPECT_EQ(kNumLoggers, constructed);
 
-    // Test Pass() with assignment;
+    // Test moving with assignment;
     scoped_ptr<ConDecLogger[]> scoper3;
-    scoper3 = scoper2.Pass();
+    scoper3 = std::move(scoper2);
     EXPECT_EQ(kNumLoggers, constructed);
     EXPECT_FALSE(scoper);
     EXPECT_FALSE(scoper2);
     EXPECT_TRUE(scoper3);
   }
   EXPECT_EQ(0, constructed);
 }
 
-TEST(ScopedPtrTest, PassBehavior) {
+TEST(ScopedPtrTest, MoveBehavior) {
   int constructed = 0;
   {
     ConDecLogger* logger = new ConDecLogger(&constructed);
     scoped_ptr<ConDecLogger> scoper(logger);
     EXPECT_EQ(1, constructed);
 
-    // Test Pass() with constructor;
-    scoped_ptr<ConDecLogger> scoper2(scoper.Pass());
+    // Test moving with constructor;
+    scoped_ptr<ConDecLogger> scoper2(std::move(scoper));
     EXPECT_EQ(1, constructed);
 
-    // Test Pass() with assignment;
+    // Test moving with assignment;
     scoped_ptr<ConDecLogger> scoper3;
-    scoper3 = scoper2.Pass();
+    scoper3 = std::move(scoper2);
     EXPECT_EQ(1, constructed);
     EXPECT_FALSE(scoper.get());
     EXPECT_FALSE(scoper2.get());
     EXPECT_TRUE(scoper3.get());
   }
 
-  // Test uncaught Pass() does not have side effects.
+  // Test uncaught Pass() does not have side effects, because Pass()
+  // is implemented by std::move().
+  // TODO(danakj): Remove this test case when we remove Pass().
   {
     ConDecLogger* logger = new ConDecLogger(&constructed);
     scoped_ptr<ConDecLogger> scoper(logger);
     EXPECT_EQ(1, constructed);
 
     // Should auto-destruct logger by end of scope.
     scoped_ptr<ConDecLogger>&& rvalue = scoper.Pass();
     // The Pass() function mimics std::move(), which does not have side-effects.
     EXPECT_TRUE(scoper.get());
     EXPECT_TRUE(rvalue);
   }
   EXPECT_EQ(0, constructed);
 
   // Test that passing to function which does nothing does not leak.
   {
     ConDecLogger* logger = new ConDecLogger(&constructed);
     scoped_ptr<ConDecLogger> scoper(logger);
     EXPECT_EQ(1, constructed);
 
     // Should auto-destruct logger by end of scope.
-    GrabAndDrop(scoper.Pass());
+    GrabAndDrop(std::move(scoper));
     EXPECT_FALSE(scoper.get());
   }
   EXPECT_EQ(0, constructed);
 }
 
 TEST(ScopedPtrTest, ReturnTypeBehavior) {
   int constructed = 0;
 
   // Test that we can return a scoped_ptr.
   {
     ConDecLogger* logger = new ConDecLogger(&constructed);
     scoped_ptr<ConDecLogger> scoper(logger);
     EXPECT_EQ(1, constructed);
 
-    PassThru(scoper.Pass());
+    PassThru(std::move(scoper));
     EXPECT_FALSE(scoper.get());
   }
   EXPECT_EQ(0, constructed);
 
   // Test uncaught return type not leak.
   {
     ConDecLogger* logger = new ConDecLogger(&constructed);
     scoped_ptr<ConDecLogger> scoper(logger);
     EXPECT_EQ(1, constructed);
 
     // Should auto-destruct logger by end of scope.
-    PassThru(scoper.Pass());
+    PassThru(std::move(scoper));
     EXPECT_FALSE(scoper.get());
   }
   EXPECT_EQ(0, constructed);
 
   // Call TestReturnOfType() so the compiler doesn't warn for an unused
   // function.
   {
     TestReturnOfType(&constructed);
   }
   EXPECT_EQ(0, constructed);
@@ skipping 70 matching lines @@
                                                CountingDeleter(&deletes));
     scoped_ptr<double, CountingDeleter> scoper2(
         &dummy_value2,
         CountingDeleter(&alternate_deletes));
     EXPECT_EQ(0, deletes);
     EXPECT_EQ(0, alternate_deletes);
 
     // Pass the second deleter through a constructor and an operator=. Then
     // reinitialize the empty scopers to ensure that each one is deleting
     // properly.
-    scoped_ptr<double, CountingDeleter> scoper3(scoper2.Pass());
-    scoper = scoper3.Pass();
+    scoped_ptr<double, CountingDeleter> scoper3(std::move(scoper2));
+    scoper = std::move(scoper3);
     EXPECT_EQ(1, deletes);
 
     scoper2.reset(&dummy_value2);
     scoper3.reset(&dummy_value2);
     EXPECT_EQ(0, alternate_deletes);
 
   }
   EXPECT_EQ(1, deletes);
   EXPECT_EQ(3, alternate_deletes);
 
@@ skipping 16 matching lines @@
 
     scoper2.swap(scoper1);
     EXPECT_EQ(&dummy_value, scoper2.get());
     EXPECT_FALSE(scoper1.get());
     EXPECT_FALSE(scoper1.get() == scoper2.get());
     EXPECT_TRUE(scoper1.get() != scoper2.get());
   }
 }
 
 // Sanity check test for overloaded new and delete operators. Does not do full
-// coverage of reset/release/Pass() operations as that is redundant with the
+// coverage of reset/release/move operations as that is redundant with the
 // above.
 TEST(ScopedPtrTest, OverloadedNewAndDelete) {
   {
     OverloadedNewAndDelete::ResetCounters();
     scoped_ptr<OverloadedNewAndDelete> scoper(new OverloadedNewAndDelete());
     EXPECT_TRUE(scoper.get());
 
-    scoped_ptr<OverloadedNewAndDelete> scoper2(scoper.Pass());
+    scoped_ptr<OverloadedNewAndDelete> scoper2(std::move(scoper));
   }
   EXPECT_EQ(1, OverloadedNewAndDelete::delete_count());
   EXPECT_EQ(1, OverloadedNewAndDelete::new_count());
 }
 
 scoped_ptr<int> NullIntReturn() {
   return nullptr;
 }
 
 TEST(ScopedPtrTest, Nullptr) {
@@ skipping 28 matching lines @@
 class Sub : public Super {};
 
 scoped_ptr<Sub> SubClassReturn() {
   return make_scoped_ptr(new Sub);
 }
 
 TEST(ScopedPtrTest, Conversion) {
   scoped_ptr<Sub> sub1(new Sub);
   scoped_ptr<Sub> sub2(new Sub);
 
-  // Upcast with Pass() works.
-  scoped_ptr<Super> super1 = sub1.Pass();
-  super1 = sub2.Pass();
+  // Upcast with move works.
+  scoped_ptr<Super> super1 = std::move(sub1);
+  super1 = std::move(sub2);
 
   // Upcast with an rvalue works.
   scoped_ptr<Super> super2 = SubClassReturn();
   super2 = SubClassReturn();
 }
 
 // Logging a scoped_ptr<T> to an ostream shouldn't convert it to a boolean
 // value first.
 TEST(ScopedPtrTest, LoggingDoesntConvertToBoolean) {
   scoped_ptr<int> x(new int);
@@ skipping 177 matching lines @@
   EXPECT_FALSE(p < nullptr);
   EXPECT_TRUE(nullptr < p);
   EXPECT_FALSE(pnull < nullptr);
   EXPECT_FALSE(nullptr < pnull);
 
   EXPECT_FALSE(p <= nullptr);
   EXPECT_TRUE(nullptr <= p);
   EXPECT_TRUE(pnull <= nullptr);
   EXPECT_TRUE(nullptr <= pnull);
 }