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

chrome/browser/chromeos/policy/cloud_external_data_manager_base_unittest.cc

 // Copyright 2013 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 "chrome/browser/chromeos/policy/cloud_external_data_manager_base.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #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"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/cloud_external_data_store.h"
 #include "components/policy/core/common/cloud/mock_cloud_policy_store.h"
 #include "components/policy/core/common/cloud/resource_cache.h"
@@ skipping 40 matching lines @@
 const char kCacheKey[] = "data";
 
 // A variant of net::FakeURLFetcherFactory that makes it an error to request a
 // fetcher for an unknown URL.
 class FakeURLFetcherFactory : public net::FakeURLFetcherFactory {
  public:
   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,
       net::URLFetcherDelegate* delegate) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeURLFetcherFactory);
 };
 
 FakeURLFetcherFactory::FakeURLFetcherFactory()
     : net::FakeURLFetcherFactory(NULL) {
 }
 
 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);
   return fetcher;
 }
 
 }  // namespace
 
 class CloudExternalDataManagerBaseTest : public testing::Test {
  protected:
   CloudExternalDataManagerBaseTest();
 
   void SetUp() override;
   void TearDown() override;
 
   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();
 
   void SetFakeResponse(const std::string& url,
                        const std::string& repsonse_data,
                        net::HttpStatusCode response_code,
                        net::URLRequestStatus::Status status);
 
   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_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudExternalDataManagerBaseTest);
 };
 
 CloudExternalDataManagerBaseTest::CloudExternalDataManagerBaseTest() {
 }
@@ skipping 35 matching lines @@
   external_data_manager_.reset();
   base::RunLoop().RunUntilIdle();
   ResetCallbackData();
 }
 
 void CloudExternalDataManagerBaseTest::SetUpExternalDataManager() {
   external_data_manager_.reset(new CloudExternalDataManagerBase(
       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()));
   return metadata;
 }
 
 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,
       POLICY_SCOPE_USER,
       POLICY_SOURCE_CLOUD,
       metadata.release(),
       new ExternalDataFetcher(
           external_data_manager_->weak_factory_.GetWeakPtr(), policy));
 }
 
 ExternalDataFetcher::FetchCallback
 CloudExternalDataManagerBaseTest::ConstructFetchCallback(int id) {
   return base::Bind(&CloudExternalDataManagerBaseTest::OnFetchDone,
                     base::Unretained(this),
                     id);
 }
 
 void CloudExternalDataManagerBaseTest::ResetCallbackData() {
   STLDeleteValues(&callback_data_);
 }
 
 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();
 }
 
 void CloudExternalDataManagerBaseTest::FetchAll() {
   external_data_manager_->FetchAll();
 }
 
 void CloudExternalDataManagerBaseTest::SetFakeResponse(
     const std::string& url,
@@ skipping 297 matching lines @@
   ASSERT_TRUE(callback_data_[0]);
   EXPECT_EQ(k10ByteData, *callback_data_[0]);
   ResetCallbackData();
 }
 
 // Verifies that cache entries which do not correspond to the external data
 // referenced by any policy are pruned on startup.
 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,
                            crypto::SHA256HashString(k10ByteData),
                            k10ByteData));
   // Store external data for |k20BytePolicy| that does not match the hash in its
   // external data reference.
   EXPECT_TRUE(cache->Store(k20BytePolicy,
                            crypto::SHA256HashString(k10ByteData),
                            k10ByteData));
@@ skipping 30 matching lines @@
                            20,
                            &data));
 }
 
 // Verifies that when the external data referenced by a policy is present in the
 // cache and the reference changes, the old data is pruned from the cache.
 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),
                            k20ByteData));
   cache.reset();
 
   // Instantiate an ExternalDataManager that uses the primed cache.
   SetUpExternalDataManager();
   external_data_manager_->Connect(request_content_getter_);
 
@@ skipping 14 matching lines @@
   EXPECT_FALSE(cache->Load(k20BytePolicy,
                            crypto::SHA256HashString(k20ByteData),
                            20,
                            &data));
 }
 
 // Verifies that corrupt cache entries are detected and deleted when accessed.
 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.
   EXPECT_TRUE(cache->Store(k10BytePolicy,
                            crypto::SHA256HashString(k20ByteData),
                            k20ByteData));
   // Store external data for |k20BytePolicy| that is corrupted and does not
   // match the expected hash.
   EXPECT_TRUE(cache->Store(k20BytePolicy,
                            crypto::SHA256HashString(k20ByteData),
@@ skipping 111 matching lines @@
                         crypto::SHA256HashString(k10ByteData)));
   cloud_policy_store_.NotifyStoreLoaded();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, callback_data_.size());
   ASSERT_TRUE(callback_data_[1]);
   EXPECT_EQ(k10ByteData, *callback_data_[1]);
   ResetCallbackData();
 }
 
 }  // namespace policy