Convert //chromecast from scoped_ptr to std::unique_ptr

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/memory/ptr_util.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 {
 
 const char kPathSeparator = '.';
@@ skipping 23 matching lines @@
 
 }  // namespace
 
 // static Default Capability Keys
 const char DeviceCapabilities::kKeyBluetoothSupported[] = "bluetooth_supported";
 const char DeviceCapabilities::kKeyDisplaySupported[] = "display_supported";
 const char DeviceCapabilities::kKeyHiResAudioSupported[] =
     "hi_res_audio_supported";
 
 // static
-scoped_ptr<DeviceCapabilities> DeviceCapabilities::Create() {
-  return make_scoped_ptr(new DeviceCapabilitiesImpl);
+std::unique_ptr<DeviceCapabilities> DeviceCapabilities::Create() {
+  return base::WrapUnique(new DeviceCapabilitiesImpl);
 }
 
 // static
-scoped_ptr<DeviceCapabilities> DeviceCapabilities::CreateForTesting() {
+std::unique_ptr<DeviceCapabilities> DeviceCapabilities::CreateForTesting() {
   DeviceCapabilities* capabilities = new DeviceCapabilitiesImpl;
   capabilities->SetCapability(
       kKeyBluetoothSupported,
-      make_scoped_ptr(new base::FundamentalValue(false)));
+      base::WrapUnique(new base::FundamentalValue(false)));
   capabilities->SetCapability(
-      kKeyDisplaySupported, make_scoped_ptr(new base::FundamentalValue(true)));
+      kKeyDisplaySupported, base::WrapUnique(new base::FundamentalValue(true)));
   capabilities->SetCapability(
       kKeyHiResAudioSupported,
-      make_scoped_ptr(new base::FundamentalValue(false)));
-  return make_scoped_ptr(capabilities);
+      base::WrapUnique(new base::FundamentalValue(false)));
+  return base::WrapUnique(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) {
+    std::unique_ptr<const base::DictionaryValue> dictionary) {
   DCHECK(dictionary.get());
   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 {
+    std::unique_ptr<base::Value> new_value) const {
   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)
+    std::unique_ptr<const base::DictionaryValue> dictionary)
     : 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 {
+    std::unique_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, 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() {
   // Make sure that any registered Validators have unregistered at this point
   DCHECK(validator_map_.empty());
   // Make sure that all observers have been removed at this point
   observer_list_->AssertEmpty();
 }
 
 void DeviceCapabilitiesImpl::Register(const std::string& key,
                                       Validator* validator) {
   DCHECK(IsValidRegisterKey(key));
   DCHECK(validator);
 
   base::AutoLock auto_lock(validation_lock_);
   bool added =
-      validator_map_.add(key, make_scoped_ptr(new ValidatorInfo(validator)))
+      validator_map_.add(key, base::WrapUnique(new ValidatorInfo(validator)))
           .second;
   // Check that a validator has not already been registered for this key
   DCHECK(added);
 }
 
 void DeviceCapabilitiesImpl::Unregister(const std::string& key,
                                         const Validator* validator) {
   base::AutoLock auto_lock(validation_lock_);
   auto validator_it = validator_map_.find(key);
   DCHECK(validator_it != validator_map_.end());
@@ skipping 36 matching lines @@
 
 bool DeviceCapabilitiesImpl::HiResAudioSupported() const {
   scoped_refptr<Data> data_ref = GetData();
   bool hi_res_audio_supported = false;
   bool found_key = data_ref->dictionary().GetBoolean(kKeyHiResAudioSupported,
                                                      &hi_res_audio_supported);
   DCHECK(found_key);
   return hi_res_audio_supported;
 }
 
-scoped_ptr<base::Value> DeviceCapabilitiesImpl::GetCapability(
+std::unique_ptr<base::Value> DeviceCapabilitiesImpl::GetCapability(
     const std::string& path) const {
   scoped_refptr<Data> data_ref = GetData();
   const base::Value* value = nullptr;
   bool found_path = data_ref->dictionary().Get(path, &value);
-  return found_path ? value->CreateDeepCopy() : scoped_ptr<base::Value>();
+  return found_path ? value->CreateDeepCopy() : std::unique_ptr<base::Value>();
 }
 
 scoped_refptr<DeviceCapabilities::Data>
 DeviceCapabilitiesImpl::GetData() const {
   // Need to acquire lock here when copy constructing data_ otherwise we could
   // be concurrently be writing to scoped_refptr in SetValidatedValue(), which
   // could cause a bad scoped_refptr read.
   base::AutoLock auto_lock(data_lock_);
   return data_;
 }
 
 void DeviceCapabilitiesImpl::SetCapability(
     const std::string& path,
-    scoped_ptr<base::Value> proposed_value) {
+    std::unique_ptr<base::Value> proposed_value) {
   DCHECK(proposed_value.get());
   if (!IsValidPath(path)) {
     LOG(DFATAL) << "Invalid capability path encountered for SetCapability()";
     return;
   }
 
   {
     base::AutoLock auto_lock(validation_lock_);
     // Check for Validator registered under first key per the Register()
     // interface.
@@ skipping 31 matching lines @@
   observer_list_->AddObserver(observer);
 }
 
 void DeviceCapabilitiesImpl::RemoveCapabilitiesObserver(Observer* observer) {
   DCHECK(observer);
   observer_list_->RemoveObserver(observer);
 }
 
 void DeviceCapabilitiesImpl::SetValidatedValue(
     const std::string& path,
-    scoped_ptr<base::Value> new_value) {
+    std::unique_ptr<base::Value> new_value) {
   // All internal writes/modifications of capabilities must occur on same
   // thread to avoid race conditions.
   if (!task_runner_for_writes_->BelongsToCurrentThread()) {
     task_runner_for_writes_->PostTask(
         FROM_HERE,
         base::Bind(&DeviceCapabilitiesImpl::SetValidatedValue,
                    base::Unretained(this), path, base::Passed(&new_value)));
     return;
   }
 
   DCHECK(IsValidPath(path));
   DCHECK(new_value.get());
 
   // We don't need to acquire lock here when reading data_ because we know that
   // all writes to data_ must occur serially on thread that we're on.
   const base::Value* cur_value = nullptr;
   bool capability_unchanged = data_->dictionary().Get(path, &cur_value) &&
                               cur_value->Equals(new_value.get());
   if (capability_unchanged) {
     VLOG(1) << "Ignoring unchanged capability: " << path;
     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(
+  std::unique_ptr<base::DictionaryValue> dictionary_deep_copy(
       data_->dictionary().CreateDeepCopy());
   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 ObserverListThreadSafe 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