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

base/containers/scoped_ptr_map_unittest.cc

 // Copyright 2015 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/containers/scoped_ptr_map.h"
 
 #include <functional>
 #include <map>
 #include <utility>
 
@@ skipping 149 matching lines @@
   scoped_map1.insert(0, make_scoped_ptr(new int(0)));
   scoped_map1.insert(1, make_scoped_ptr(new int(0)));
 
   auto it = scoped_map1.begin();
   EXPECT_EQ(1, it->first);
   ++it;
   EXPECT_EQ(0, it->first);
 
   // Test the move constructor.
   ScopedPtrMap<int, scoped_ptr<int>, std::greater<int>> scoped_map2(
-      scoped_map1.Pass());
+      std::move(scoped_map1));
   EXPECT_EQ(2u, scoped_map2.size());
   EXPECT_TRUE(scoped_map1.empty());
 
   // Test move assignment.
-  scoped_map1 = scoped_map2.Pass();
+  scoped_map1 = std::move(scoped_map2);
   EXPECT_EQ(2u, scoped_map1.size());
   EXPECT_TRUE(scoped_map2.empty());
 
   // Test swap.
   scoped_map2.swap(scoped_map1);
   EXPECT_EQ(2u, scoped_map2.size());
   EXPECT_TRUE(scoped_map1.empty());
 }
 
 TEST(ScopedPtrMapTest, Scope) {
@@ skipping 10 matching lines @@
   bool destroyed = false;
   {
     ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
     ScopedDestroyer* elem = new ScopedDestroyer(&destroyed);
     scoped_map.insert(0, make_scoped_ptr(elem));
     EXPECT_EQ(elem, scoped_map.find(0)->second);
     EXPECT_FALSE(destroyed);
     EXPECT_FALSE(scoped_map.empty());
 
     ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map_copy(
-        scoped_map.Pass());
+        std::move(scoped_map));
     EXPECT_TRUE(scoped_map.empty());
     EXPECT_FALSE(scoped_map_copy.empty());
     EXPECT_EQ(elem, scoped_map_copy.find(0)->second);
     EXPECT_FALSE(destroyed);
   }
   EXPECT_TRUE(destroyed);
 }
 
 TEST(ScopedPtrMapTest, MoveAssign) {
   bool destroyed = false;
   {
     ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map;
     ScopedDestroyer* elem = new ScopedDestroyer(&destroyed);
     scoped_map.insert(0, make_scoped_ptr(elem));
     EXPECT_EQ(elem, scoped_map.find(0)->second);
     EXPECT_FALSE(destroyed);
     EXPECT_FALSE(scoped_map.empty());
 
     ScopedPtrMap<int, scoped_ptr<ScopedDestroyer>> scoped_map_assign;
-    scoped_map_assign = scoped_map.Pass();
+    scoped_map_assign = std::move(scoped_map);
     EXPECT_TRUE(scoped_map.empty());
     EXPECT_FALSE(scoped_map_assign.empty());
     EXPECT_EQ(elem, scoped_map_assign.find(0)->second);
     EXPECT_FALSE(destroyed);
   }
   EXPECT_TRUE(destroyed);
 }
 
 template <typename Key, typename ScopedPtr>
 ScopedPtrMap<Key, ScopedPtr> PassThru(ScopedPtrMap<Key, ScopedPtr> scoper) {
@@ skipping 26 matching lines @@
 // Test that using a value type from a namespace containing an ignore_result
 // function compiles correctly.
 TEST(ScopedPtrMapTest, IgnoreResultCompile) {
   ScopedPtrMap<int, scoped_ptr<namespace_with_ignore_result::Value>> scoped_map;
   scoped_map.insert(1,
                     make_scoped_ptr(new namespace_with_ignore_result::Value));
 }
 
 }  // namespace
 }  // namespace base