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

chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc

Index: chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc
diff --git a/chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc b/chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc
index 4749636051e633831480cd5cb283685b76ad8ac0..a94469fc6313848b66ce69fd968ed4eef82b65f1 100644
--- a/chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc
+++ b/chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc
@@ -11,6 +11,7 @@
 #include "base/bind_helpers.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
@@ -71,7 +72,7 @@ class FakeURLFetcherFactory : public net::FakeURLFetcherFactory {
   ~FakeURLFetcherFactory() override;
 
   // net::FakeURLFetcherFactory:
-  scoped_ptr<net::URLFetcher> CreateURLFetcher(
+  std::unique_ptr<net::URLFetcher> CreateURLFetcher(
       int id,
       const GURL& url,
       net::URLFetcher::RequestType request_type,
@@ -88,12 +89,12 @@ FakeURLFetcherFactory::FakeURLFetcherFactory()
 FakeURLFetcherFactory::~FakeURLFetcherFactory() {
 }
 
-scoped_ptr<net::URLFetcher> FakeURLFetcherFactory::CreateURLFetcher(
+std::unique_ptr<net::URLFetcher> FakeURLFetcherFactory::CreateURLFetcher(
     int id,
     const GURL& url,
     net::URLFetcher::RequestType request_type,
     net::URLFetcherDelegate* delegate) {
-  scoped_ptr<net::URLFetcher> fetcher =
+  std::unique_ptr<net::URLFetcher> fetcher =
       net::FakeURLFetcherFactory::CreateURLFetcher(id, url, request_type,
                                                    delegate);
   EXPECT_TRUE(fetcher);
@@ -111,15 +112,17 @@ class CloudExternalDataManagerBaseTest : public testing::Test {
 
   void SetUpExternalDataManager();
 
-  scoped_ptr<base::DictionaryValue> ConstructMetadata(const std::string& url,
-                                                      const std::string& hash);
-  void SetExternalDataReference(const std::string& policy,
-                                scoped_ptr<base::DictionaryValue> metadata);
+  std::unique_ptr<base::DictionaryValue> ConstructMetadata(
+      const std::string& url,
+      const std::string& hash);
+  void SetExternalDataReference(
+      const std::string& policy,
+      std::unique_ptr<base::DictionaryValue> metadata);
 
   ExternalDataFetcher::FetchCallback ConstructFetchCallback(int id);
   void ResetCallbackData();
 
-  void OnFetchDone(int id, scoped_ptr<std::string> data);
+  void OnFetchDone(int id, std::unique_ptr<std::string> data);
 
   void FetchAll();
 
@@ -130,12 +133,12 @@ class CloudExternalDataManagerBaseTest : public testing::Test {
 
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_dir_;
-  scoped_ptr<ResourceCache> resource_cache_;
+  std::unique_ptr<ResourceCache> resource_cache_;
   MockCloudPolicyStore cloud_policy_store_;
   scoped_refptr<net::TestURLRequestContextGetter> request_content_getter_;
   FakeURLFetcherFactory fetcher_factory_;
 
-  scoped_ptr<CloudExternalDataManagerBase> external_data_manager_;
+  std::unique_ptr<CloudExternalDataManagerBase> external_data_manager_;
 
   std::map<int, std::string*> callback_data_;
   PolicyDetailsMap policy_details_;
@@ -191,16 +194,15 @@ void CloudExternalDataManagerBaseTest::SetUpExternalDataManager() {
       policy_details_.GetCallback(), message_loop_.task_runner(),
       message_loop_.task_runner()));
   external_data_manager_->SetExternalDataStore(
-      make_scoped_ptr(new CloudExternalDataStore(
+      base::WrapUnique(new CloudExternalDataStore(
           kCacheKey, message_loop_.task_runner(), resource_cache_.get())));
   external_data_manager_->SetPolicyStore(&cloud_policy_store_);
 }
 
-scoped_ptr<base::DictionaryValue>
-    CloudExternalDataManagerBaseTest::ConstructMetadata(
-        const std::string& url,
-        const std::string& hash) {
-  scoped_ptr<base::DictionaryValue> metadata(new base::DictionaryValue);
+std::unique_ptr<base::DictionaryValue>
+CloudExternalDataManagerBaseTest::ConstructMetadata(const std::string& url,
+                                                    const std::string& hash) {
+  std::unique_ptr<base::DictionaryValue> metadata(new base::DictionaryValue);
   metadata->SetStringWithoutPathExpansion("url", url);
   metadata->SetStringWithoutPathExpansion("hash", base::HexEncode(hash.c_str(),
                                                                   hash.size()));
@@ -209,7 +211,7 @@ scoped_ptr<base::DictionaryValue>
 
 void CloudExternalDataManagerBaseTest::SetExternalDataReference(
     const std::string& policy,
-    scoped_ptr<base::DictionaryValue> metadata) {
+    std::unique_ptr<base::DictionaryValue> metadata) {
   cloud_policy_store_.policy_map_.Set(
       policy,
       POLICY_LEVEL_MANDATORY,
@@ -233,7 +235,7 @@ void CloudExternalDataManagerBaseTest::ResetCallbackData() {
 
 void CloudExternalDataManagerBaseTest::OnFetchDone(
     int id,
-    scoped_ptr<std::string> data) {
+    std::unique_ptr<std::string> data) {
   delete callback_data_[id];
   callback_data_[id] = data.release();
 }
@@ -551,7 +553,7 @@ TEST_F(CloudExternalDataManagerBaseTest, LoadFromCache) {
 TEST_F(CloudExternalDataManagerBaseTest, PruneCacheOnStartup) {
   external_data_manager_.reset();
   base::RunLoop().RunUntilIdle();
-  scoped_ptr<CloudExternalDataStore> cache(new CloudExternalDataStore(
+  std::unique_ptr<CloudExternalDataStore> cache(new CloudExternalDataStore(
       kCacheKey, message_loop_.task_runner(), resource_cache_.get()));
   // Store valid external data for |k10BytePolicy| in the cache.
   EXPECT_TRUE(cache->Store(k10BytePolicy,
@@ -602,7 +604,7 @@ TEST_F(CloudExternalDataManagerBaseTest, PruneCacheOnChange) {
   // Store valid external data for |k20BytePolicy| in the cache.
   external_data_manager_.reset();
   base::RunLoop().RunUntilIdle();
-  scoped_ptr<CloudExternalDataStore> cache(new CloudExternalDataStore(
+  std::unique_ptr<CloudExternalDataStore> cache(new CloudExternalDataStore(
       kCacheKey, message_loop_.task_runner(), resource_cache_.get()));
   EXPECT_TRUE(cache->Store(k20BytePolicy,
                            crypto::SHA256HashString(k20ByteData),
@@ -637,7 +639,7 @@ TEST_F(CloudExternalDataManagerBaseTest, PruneCacheOnChange) {
 TEST_F(CloudExternalDataManagerBaseTest, CacheCorruption) {
   external_data_manager_.reset();
   base::RunLoop().RunUntilIdle();
-  scoped_ptr<CloudExternalDataStore> cache(new CloudExternalDataStore(
+  std::unique_ptr<CloudExternalDataStore> cache(new CloudExternalDataStore(
       kCacheKey, message_loop_.task_runner(), resource_cache_.get()));
   // Store external data for |k10BytePolicy| that exceeds the maximal external
   // data size allowed for that policy.