Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/policy/cloud_external_data_manager_base.cc

Index: chrome/browser/chromeos/policy/cloud_external_data_manager_base.cc
diff --git a/chrome/browser/chromeos/policy/cloud_external_data_manager_base.cc b/chrome/browser/chromeos/policy/cloud_external_data_manager_base.cc
index eafe096e86707baeeeb53cfc3e8f2fb812561e99..8f6be5c4d215f6f104f7d0cb5744d02aad5268b0 100644
--- a/chrome/browser/chromeos/policy/cloud_external_data_manager_base.cc
+++ b/chrome/browser/chromeos/policy/cloud_external_data_manager_base.cc
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <map>
 #include <string>
 #include <utility>
@@ -17,6 +18,7 @@
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ -57,13 +59,13 @@ class CloudExternalDataManagerBase::Backend {
 
   // Allows downloaded external data to be cached in |external_data_store|.
   // Ownership of the store is taken. The store can be destroyed by calling
-  // SetExternalDataStore(scoped_ptr<CloudExternalDataStore>()).
+  // SetExternalDataStore(std::unique_ptr<CloudExternalDataStore>()).
   void SetExternalDataStore(
-      scoped_ptr<CloudExternalDataStore> external_data_store);
+      std::unique_ptr<CloudExternalDataStore> external_data_store);
 
   // Allows downloading of external data via the |external_policy_data_fetcher|.
   void Connect(
-      scoped_ptr<ExternalPolicyDataFetcher> external_policy_data_fetcher);
+      std::unique_ptr<ExternalPolicyDataFetcher> external_policy_data_fetcher);
 
   // Prevents further external data downloads and aborts any downloads currently
   // in progress
@@ -72,7 +74,7 @@ class CloudExternalDataManagerBase::Backend {
   // Called when the external data references that this backend is responsible
   // for change. |metadata| maps from policy names to the metadata specifying
   // the external data that each of the policies references.
-  void OnMetadataUpdated(scoped_ptr<Metadata> metadata);
+  void OnMetadataUpdated(std::unique_ptr<Metadata> metadata);
 
   // Called by the |updater_| when the external |data| referenced by |policy|
   // has been successfully downloaded and verified to match |hash|.
@@ -112,7 +114,7 @@ class CloudExternalDataManagerBase::Backend {
   // Invokes |callback| via the |callback_task_runner_|, passing |data| as a
   // parameter.
   void RunCallback(const ExternalDataFetcher::FetchCallback& callback,
-                   scoped_ptr<std::string> data) const;
+                   std::unique_ptr<std::string> data) const;
 
   // Tells the |updater_| to download the external data referenced by |policy|.
   // If Connect() was not called yet and no |updater_| exists, does nothing.
@@ -142,10 +144,10 @@ class CloudExternalDataManagerBase::Backend {
   Metadata metadata_;
 
   // Used to cache external data referenced by policies.
-  scoped_ptr<CloudExternalDataStore> external_data_store_;
+  std::unique_ptr<CloudExternalDataStore> external_data_store_;
 
   // Used to download external data referenced by policies.
-  scoped_ptr<ExternalPolicyDataUpdater> updater_;
+  std::unique_ptr<ExternalPolicyDataUpdater> updater_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
@@ -161,14 +163,14 @@ CloudExternalDataManagerBase::Backend::Backend(
 }
 
 void CloudExternalDataManagerBase::Backend::SetExternalDataStore(
-    scoped_ptr<CloudExternalDataStore> external_data_store) {
+    std::unique_ptr<CloudExternalDataStore> external_data_store) {
   external_data_store_.reset(external_data_store.release());
   if (metadata_set_ && external_data_store_)
     external_data_store_->Prune(metadata_);
 }
 
 void CloudExternalDataManagerBase::Backend::Connect(
-    scoped_ptr<ExternalPolicyDataFetcher> external_policy_data_fetcher) {
+    std::unique_ptr<ExternalPolicyDataFetcher> external_policy_data_fetcher) {
   DCHECK(!updater_);
   updater_.reset(new ExternalPolicyDataUpdater(
       task_runner_, std::move(external_policy_data_fetcher),
@@ -184,7 +186,7 @@ void CloudExternalDataManagerBase::Backend::Disconnect() {
 }
 
 void CloudExternalDataManagerBase::Backend::OnMetadataUpdated(
-    scoped_ptr<Metadata> metadata) {
+    std::unique_ptr<Metadata> metadata) {
   metadata_set_ = true;
   Metadata old_metadata;
   metadata_.swap(old_metadata);
@@ -207,7 +209,7 @@ void CloudExternalDataManagerBase::Backend::OnMetadataUpdated(
       for (FetchCallbackList::const_iterator callback = it->second.begin();
            callback != it->second.end(); ++callback) {
         // Invoke all callbacks for |policy|, indicating permanent failure.
-        RunCallback(*callback, scoped_ptr<std::string>());
+        RunCallback(*callback, std::unique_ptr<std::string>());
       }
       pending_downloads_.erase(it++);
       continue;
@@ -235,7 +237,7 @@ bool CloudExternalDataManagerBase::Backend::OnDownloadSuccess(
   const FetchCallbackList& pending_callbacks = pending_downloads_[policy];
   for (FetchCallbackList::const_iterator it = pending_callbacks.begin();
        it != pending_callbacks.end(); ++it) {
-    RunCallback(*it, make_scoped_ptr(new std::string(data)));
+    RunCallback(*it, base::WrapUnique(new std::string(data)));
   }
   pending_downloads_.erase(policy);
   return true;
@@ -248,7 +250,7 @@ void CloudExternalDataManagerBase::Backend::Fetch(
   if (metadata == metadata_.end()) {
     // If |policy| does not reference any external data, indicate permanent
     // failure.
-    RunCallback(callback, scoped_ptr<std::string>());
+    RunCallback(callback, std::unique_ptr<std::string>());
     return;
   }
 
@@ -260,7 +262,7 @@ void CloudExternalDataManagerBase::Backend::Fetch(
     return;
   }
 
-  scoped_ptr<std::string> data(new std::string);
+  std::unique_ptr<std::string> data(new std::string);
   if (external_data_store_ && external_data_store_->Load(
           policy, metadata->second.hash, GetMaxExternalDataSize(policy),
           data.get())) {
@@ -281,7 +283,7 @@ void CloudExternalDataManagerBase::Backend::FetchAll() {
   for (Metadata::const_iterator it = metadata_.begin(); it != metadata_.end();
        ++it) {
     const std::string& policy = it->first;
-    scoped_ptr<std::string> data(new std::string);
+    std::unique_ptr<std::string> data(new std::string);
     if (pending_downloads_.find(policy) != pending_downloads_.end() ||
         (external_data_store_ && external_data_store_->Load(
              policy, it->second.hash, GetMaxExternalDataSize(policy),
@@ -316,7 +318,7 @@ size_t CloudExternalDataManagerBase::Backend::GetMaxExternalDataSize(
 
 void CloudExternalDataManagerBase::Backend::RunCallback(
     const ExternalDataFetcher::FetchCallback& callback,
-    scoped_ptr<std::string> data) const {
+    std::unique_ptr<std::string> data) const {
   callback_task_runner_->PostTask(FROM_HERE,
                                   base::Bind(callback, base::Passed(&data)));
 }
@@ -358,7 +360,7 @@ CloudExternalDataManagerBase::~CloudExternalDataManagerBase() {
 }
 
 void CloudExternalDataManagerBase::SetExternalDataStore(
-    scoped_ptr<CloudExternalDataStore> external_data_store) {
+    std::unique_ptr<CloudExternalDataStore> external_data_store) {
   DCHECK(CalledOnValidThread());
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::SetExternalDataStore,
@@ -378,7 +380,7 @@ void CloudExternalDataManagerBase::OnPolicyStoreLoaded() {
   // Collect all external data references made by policies in |policy_store_|
   // and pass them to the |backend_|.
   DCHECK(CalledOnValidThread());
-  scoped_ptr<Metadata> metadata(new Metadata);
+  std::unique_ptr<Metadata> metadata(new Metadata);
   const PolicyMap& policy_map = policy_store_->policy_map();
   for (PolicyMap::const_iterator it = policy_map.begin();
        it != policy_map.end(); ++it) {