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

chromecast/base/device_capabilities_impl.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 <stddef.h>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromecast/base/serializers.h"
 
 namespace chromecast {
 
 namespace {
@@ skipping 45 matching lines @@
   return make_scoped_ptr(capabilities);
 }
 
 scoped_refptr<DeviceCapabilities::Data> DeviceCapabilities::CreateData() {
   return make_scoped_refptr(new Data);
 }
 
 scoped_refptr<DeviceCapabilities::Data> DeviceCapabilities::CreateData(
     scoped_ptr<const base::DictionaryValue> dictionary) {
   DCHECK(dictionary.get());
-  return make_scoped_refptr(new Data(dictionary.Pass()));
+  return make_scoped_refptr(new Data(std::move(dictionary)));
 }
 
 DeviceCapabilities::Validator::Validator(DeviceCapabilities* capabilities)
     : capabilities_(capabilities) {
   DCHECK(capabilities);
 }
 
 void DeviceCapabilities::Validator::SetValidatedValue(
     const std::string& path,
     scoped_ptr<base::Value> new_value) const {
-  capabilities_->SetValidatedValue(path, new_value.Pass());
+  capabilities_->SetValidatedValue(path, std::move(new_value));
 }
 
 DeviceCapabilities::Data::Data()
     : dictionary_(new base::DictionaryValue),
       json_string_(SerializeToJson(*dictionary_)) {
   DCHECK(json_string_.get());
 }
 
 DeviceCapabilities::Data::Data(
     scoped_ptr<const base::DictionaryValue> dictionary)
-    : dictionary_(dictionary.Pass()),
+    : dictionary_(std::move(dictionary)),
       json_string_(SerializeToJson(*dictionary_)) {
   DCHECK(dictionary_.get());
   DCHECK(json_string_.get());
 }
 
 DeviceCapabilitiesImpl::Data::~Data() {}
 
 DeviceCapabilitiesImpl::ValidatorInfo::ValidatorInfo(Validator* validator)
     : validator_(validator), task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   DCHECK(validator_);
   DCHECK(task_runner_.get());
 }
 
 DeviceCapabilitiesImpl::ValidatorInfo::~ValidatorInfo() {
   // Check that ValidatorInfo is being destroyed on the same thread that it was
   // constructed on.
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 void DeviceCapabilitiesImpl::ValidatorInfo::Validate(
     const std::string& path,
     scoped_ptr<base::Value> proposed_value) const {
   // Check that we are running Validate on the same thread that ValidatorInfo
   // was constructed on.
   DCHECK(task_runner_->BelongsToCurrentThread());
-  validator_->Validate(path, proposed_value.Pass());
+  validator_->Validate(path, std::move(proposed_value));
 }
 
 DeviceCapabilitiesImpl::DeviceCapabilitiesImpl()
     : data_(CreateData()),
       task_runner_for_writes_(base::ThreadTaskRunnerHandle::Get()),
       observer_list_(new base::ObserverListThreadSafe<Observer>) {
   DCHECK(task_runner_for_writes_.get());
 }
 
 DeviceCapabilitiesImpl::~DeviceCapabilitiesImpl() {
@@ skipping 99 matching lines @@
       // Validator gets unregistered, the call to Validate will get skipped.
       validator_it->second->task_runner()->PostTask(
           FROM_HERE, base::Bind(&ValidatorInfo::Validate,
                                 validator_it->second->AsWeakPtr(), path,
                                 base::Passed(&proposed_value)));
       return;
     }
   }
   // Since we are done checking for a registered Validator at this point, we
   // can release the lock. All further member access will be for capabilities.
-  SetValidatedValue(path, proposed_value.Pass());
+  SetValidatedValue(path, std::move(proposed_value));
 }
 
 void DeviceCapabilitiesImpl::MergeDictionary(
     const base::DictionaryValue& dict_value) {
   for (base::DictionaryValue::Iterator it(dict_value); !it.IsAtEnd();
        it.Advance()) {
     SetCapability(it.key(), it.value().CreateDeepCopy());
   }
 }
 
@@ skipping 33 matching lines @@
     return;
   }
 
   // In this sequence, we create a deep copy, modify the deep copy, and then
   // do a pointer swap. We do this to have minimal time spent in the
   // data_lock_. If we were to lock and modify the capabilities
   // dictionary directly, there may be expensive writes that block other
   // threads.
   scoped_ptr<base::DictionaryValue> dictionary_deep_copy(
       data_->dictionary().CreateDeepCopy());
-  dictionary_deep_copy->Set(path, new_value.Pass());
-  scoped_refptr<Data> new_data(CreateData(dictionary_deep_copy.Pass()));
+  dictionary_deep_copy->Set(path, std::move(new_value));
+  scoped_refptr<Data> new_data(CreateData(std::move(dictionary_deep_copy)));
 
   {
     base::AutoLock auto_lock(data_lock_);
     // Using swap instead of assignment operator here because it's a little
     // faster. Avoids an extra call to AddRef()/Release().
     data_.swap(new_data);
   }
 
   // Even though ObseverListThreadSafe notifications are always asynchronous
   // (posts task even if to same thread), no locks should be held at this point
   // in the code. This is just to be safe that no deadlocks occur if Observers
   // call DeviceCapabilities methods in OnCapabilitiesChanged().
   observer_list_->Notify(FROM_HERE, &Observer::OnCapabilitiesChanged, path);
 }
 
 }  // namespace chromecast