Convert Pass()→std::move() in //chromecast

chromecast/base/device_capabilities_impl_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 "chromecast/base/device_capabilities_impl.h"
 
 #include <string>
+#include <utility>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chromecast/base/serializers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
@@ skipping 20 matching lines @@
   // untouched.
   FakeCapabilityManagerSimple(DeviceCapabilities* capabilities,
                               const std::string& key,
                               scoped_ptr<base::Value> init_value,
                               bool accept_changes)
       : DeviceCapabilities::Validator(capabilities),
         key_(key),
         accept_changes_(accept_changes) {
     capabilities->Register(key, this);
     if (init_value)
-      SetValidatedValue(key, init_value.Pass());
+      SetValidatedValue(key, std::move(init_value));
   }
 
   // Unregisters itself as Validator.
   ~FakeCapabilityManagerSimple() override {
     capabilities()->Unregister(key_, this);
   }
 
   void Validate(const std::string& path,
                 scoped_ptr<base::Value> proposed_value) override {
     ASSERT_TRUE(path.find(key_) == 0);
     if (accept_changes_)
-      SetValidatedValue(path, proposed_value.Pass());
+      SetValidatedValue(path, std::move(proposed_value));
   }
 
  private:
   const std::string key_;
   const bool accept_changes_;
 };
 
 // Used to test that capabilities/validator can be read and written in
 // Validate() without encountering deadlocks/unexpected behavior.
 class FakeCapabilityManagerComplex : public DeviceCapabilities::Validator {
@@ skipping 126 matching lines @@
   EXPECT_EQ(capabilities->GetValidator(key), manager);
   // Read Capability
   EXPECT_TRUE(base::Value::Equals(capabilities->GetCapability(key).get(),
                                   init_value.get()));
   // Unregister
   delete manager;
 
   // Write capability again. Provides way of checking that this function
   // ran and was successful.
   scoped_ptr<base::Value> new_value = GetSampleDefaultCapabilityNewValue();
-  capabilities->SetCapability(key, new_value.Pass());
+  capabilities->SetCapability(key, std::move(new_value));
 }
 
 // See TestBasicOperations() comment.
 void AssertBasicOperationsSuccessful(const DeviceCapabilities* capabilities) {
   base::RunLoop().RunUntilIdle();
   std::string key;
   scoped_ptr<base::Value> init_value;
   GetSampleDefaultCapability(&key, &init_value);
   scoped_ptr<base::Value> value = capabilities->GetCapability(key);
   ASSERT_TRUE(value);
@@ skipping 175 matching lines @@
   FakeCapabilityManagerSimple manager(capabilities(), key,
                                       init_value->CreateDeepCopy(), true);
 
   // 2nd call
   capabilities()->SetCapability(key, GetSampleDefaultCapabilityNewValue());
 
   // Observer should not get called when value does not change
   capabilities()->SetCapability(key, GetSampleDefaultCapabilityNewValue());
 
   // 3rd call
-  capabilities()->SetCapability(key, init_value.Pass());
+  capabilities()->SetCapability(key, std::move(init_value));
   base::RunLoop().RunUntilIdle();
 }
 
 // Test adding dynamic capabilities
 TEST_F(DeviceCapabilitiesImplTest, SetCapabilityDynamic) {
   std::string key;
   scoped_ptr<base::Value> init_value;
   GetSampleDynamicCapability(&key, &init_value);
 
   ASSERT_FALSE(capabilities()->GetCapability(key));
@@ skipping 14 matching lines @@
                                *new_value));
 }
 
 // Tests that SetCapability() works with expanded paths when there is a
 // capability of type DictionaryValue.
 TEST_F(DeviceCapabilitiesImplTest, SetCapabilityDictionary) {
   std::string key("dummy_dictionary_key");
   scoped_ptr<base::Value> init_value =
       DeserializeFromJson(kSampleDictionaryCapability);
   ASSERT_TRUE(init_value);
-  FakeCapabilityManagerSimple manager(capabilities(), key, init_value.Pass(),
-                                      true);
+  FakeCapabilityManagerSimple manager(capabilities(), key,
+                                      std::move(init_value), true);
 
   capabilities()->SetCapability(
       "dummy_dictionary_key.dummy_field_bool",
       make_scoped_ptr(new base::FundamentalValue(false)));
   base::RunLoop().RunUntilIdle();
   bool value_bool = true;
   scoped_ptr<base::Value> value =
       capabilities()->GetCapability("dummy_dictionary_key.dummy_field_bool");
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->GetAsBoolean(&value_bool));
@@ skipping 10 matching lines @@
   EXPECT_EQ(value_int, 100);
 }
 
 // Tests that SetCapability() works with expanded paths when there is a
 // capability of type DictionaryValue and invalid changes are proposed.
 TEST_F(DeviceCapabilitiesImplTest, SetCapabilityDictionaryInvalid) {
   std::string key("dummy_dictionary_key");
   scoped_ptr<base::Value> init_value =
       DeserializeFromJson(kSampleDictionaryCapability);
   ASSERT_TRUE(init_value);
-  FakeCapabilityManagerSimple manager(capabilities(), key, init_value.Pass(),
-                                      false);
+  FakeCapabilityManagerSimple manager(capabilities(), key,
+                                      std::move(init_value), false);
 
   capabilities()->SetCapability(
       "dummy_dictionary_key.dummy_field_bool",
       make_scoped_ptr(new base::FundamentalValue(false)));
   base::RunLoop().RunUntilIdle();
   bool value_bool = false;
   scoped_ptr<base::Value> value =
       capabilities()->GetCapability("dummy_dictionary_key.dummy_field_bool");
   ASSERT_TRUE(value);
   EXPECT_TRUE(value->GetAsBoolean(&value_bool));
@@ skipping 82 matching lines @@
   capabilities()->SetCapability(
       "dummy_validate_key", make_scoped_ptr(new base::FundamentalValue(true)));
   base::RunLoop().RunUntilIdle();
 
   // Check that FakeCapabilityManagerComplex::Validate() ran and that behavior
   // was successful
   AssertBasicOperationsSuccessful(capabilities());
 }
 
 }  // namespace chromecast