Re-write many calls to WrapUnique() with MakeUnique()

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"
@@ skipping 141 matching lines @@
 
 void CloudExternalDataManagerBaseTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   resource_cache_.reset(
       new ResourceCache(temp_dir_.path(), message_loop_.task_runner()));
   SetUpExternalDataManager();
 
   // Set |kStringPolicy| to a string value.
   cloud_policy_store_.policy_map_.Set(
       kStringPolicy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-      POLICY_SOURCE_CLOUD,
-      base::WrapUnique(new base::StringValue(std::string())), nullptr);
+      POLICY_SOURCE_CLOUD, base::MakeUnique<base::StringValue>(std::string()),
+      nullptr);
   // Make |k10BytePolicy| reference 10 bytes of external data.
   SetExternalDataReference(
       k10BytePolicy,
       ConstructMetadata(k10BytePolicyURL,
                         crypto::SHA256HashString(k10ByteData)));
   // Make |k20BytePolicy| reference 20 bytes of external data.
   SetExternalDataReference(
       k20BytePolicy,
       ConstructMetadata(k20BytePolicyURL,
                         crypto::SHA256HashString(k20ByteData)));
@@ skipping 11 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(
-      base::WrapUnique(new CloudExternalDataStore(
-          kCacheKey, message_loop_.task_runner(), resource_cache_.get())));
+      base::MakeUnique<CloudExternalDataStore>(
+          kCacheKey, message_loop_.task_runner(), resource_cache_.get()));
   external_data_manager_->SetPolicyStore(&cloud_policy_store_);
 }
 
 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,
     std::unique_ptr<base::DictionaryValue> metadata) {
   cloud_policy_store_.policy_map_.Set(
       policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
       std::move(metadata),
-      base::WrapUnique(new ExternalDataFetcher(
-          external_data_manager_->weak_factory_.GetWeakPtr(), policy)));
+      base::MakeUnique<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() {
@@ skipping 531 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