Convert //components/policy from scoped_ptr to std::unique_ptr

components/policy/core/browser/configuration_policy_handler.cc

 // Copyright (c) 2012 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 "components/policy/core/browser/configuration_policy_handler.h"
 
 #include <stddef.h>
+
 #include <algorithm>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "components/policy/core/browser/policy_error_map.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/prefs/pref_value_map.h"
 #include "grit/components_strings.h"
 #include "url/gurl.h"
 
 namespace policy {
@@ skipping 120 matching lines @@
   if (output)
     *output = value;
   return true;
 }
 
 
 // StringMappingListPolicyHandler implementation -----------------------------
 
 StringMappingListPolicyHandler::MappingEntry::MappingEntry(
     const char* policy_value,
-    scoped_ptr<base::Value> map)
+    std::unique_ptr<base::Value> map)
     : enum_value(policy_value), mapped_value(std::move(map)) {}
 
 StringMappingListPolicyHandler::MappingEntry::~MappingEntry() {}
 
 StringMappingListPolicyHandler::StringMappingListPolicyHandler(
     const char* policy_name,
     const char* pref_path,
     const GenerateMapCallback& callback)
     : TypeCheckingPolicyHandler(policy_name, base::Value::TYPE_LIST),
       pref_path_(pref_path),
       map_getter_(callback) {}
 
 StringMappingListPolicyHandler::~StringMappingListPolicyHandler() {}
 
 bool StringMappingListPolicyHandler::CheckPolicySettings(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
   const base::Value* value;
   return CheckAndGetValue(policies, errors, &value) &&
       Convert(value, NULL, errors);
 }
 
 void StringMappingListPolicyHandler::ApplyPolicySettings(
     const PolicyMap& policies,
     PrefValueMap* prefs) {
   if (!pref_path_)
     return;
   const base::Value* value = policies.GetValue(policy_name());
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   if (value && Convert(value, list.get(), NULL))
     prefs->SetValue(pref_path_, std::move(list));
 }
 
 bool StringMappingListPolicyHandler::Convert(const base::Value* input,
                                              base::ListValue* output,
                                              PolicyErrorMap* errors) {
   if (!input)
     return true;
 
   const base::ListValue* list_value = NULL;
   if (!input->GetAsList(&list_value)) {
     NOTREACHED();
     return false;
   }
 
   for (base::ListValue::const_iterator entry(list_value->begin());
        entry != list_value->end(); ++entry) {
     std::string entry_value;
     if (!(*entry)->GetAsString(&entry_value)) {
       if (errors) {
         errors->AddError(policy_name(),
                          entry - list_value->begin(),
                          IDS_POLICY_TYPE_ERROR,
                          ValueTypeToString(base::Value::TYPE_STRING));
       }
       continue;
     }
 
-    scoped_ptr<base::Value> mapped_value = Map(entry_value);
+    std::unique_ptr<base::Value> mapped_value = Map(entry_value);
     if (mapped_value) {
       if (output)
         output->Append(mapped_value.release());
     } else {
       if (errors) {
         errors->AddError(policy_name(),
                          entry - list_value->begin(),
                          IDS_POLICY_OUT_OF_RANGE_ERROR);
       }
     }
   }
 
   return true;
 }
 
-scoped_ptr<base::Value> StringMappingListPolicyHandler::Map(
+std::unique_ptr<base::Value> StringMappingListPolicyHandler::Map(
     const std::string& entry_value) {
   // Lazily generate the map of policy strings to mapped values.
   if (map_.empty())
     map_getter_.Run(&map_);
 
-  scoped_ptr<base::Value> return_value;
+  std::unique_ptr<base::Value> return_value;
   for (ScopedVector<MappingEntry>::const_iterator it = map_.begin();
        it != map_.end(); ++it) {
     const MappingEntry* mapping_entry = *it;
     if (mapping_entry->enum_value == entry_value) {
-      return_value = make_scoped_ptr(mapping_entry->mapped_value->DeepCopy());
+      return_value = base::WrapUnique(mapping_entry->mapped_value->DeepCopy());
       break;
     }
   }
   return return_value;
 }
 
 // IntRangePolicyHandler implementation ----------------------------------------
 
 IntRangePolicyHandler::IntRangePolicyHandler(const char* policy_name,
                                              const char* pref_path,
@@ skipping 101 matching lines @@
       error_path = "(ROOT)";
     errors->AddError(policy_name_, error_path, error);
   }
 
   return result;
 }
 
 bool SchemaValidatingPolicyHandler::CheckAndGetValue(
     const PolicyMap& policies,
     PolicyErrorMap* errors,
-    scoped_ptr<base::Value>* output) {
+    std::unique_ptr<base::Value>* output) {
   const base::Value* value = policies.GetValue(policy_name());
   if (!value)
     return true;
 
   output->reset(value->DeepCopy());
   std::string error_path;
   std::string error;
   bool result =
       schema_.Normalize(output->get(), strategy_, &error_path, &error, NULL);
 
@@ skipping 55 matching lines @@
 }
 
 // LegacyPoliciesDeprecatingPolicyHandler implementation -----------------------
 
 // TODO(binjin): Add a new common base class for SchemaValidatingPolicyHandler
 // and TypeCheckingPolicyHandler representing policy handlers for a single
 // policy, and use it as the type of |new_policy_handler|.
 // http://crbug.com/345299
 LegacyPoliciesDeprecatingPolicyHandler::LegacyPoliciesDeprecatingPolicyHandler(
     ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers,
-    scoped_ptr<SchemaValidatingPolicyHandler> new_policy_handler)
+    std::unique_ptr<SchemaValidatingPolicyHandler> new_policy_handler)
     : legacy_policy_handlers_(std::move(legacy_policy_handlers)),
       new_policy_handler_(std::move(new_policy_handler)) {}
 
 LegacyPoliciesDeprecatingPolicyHandler::
     ~LegacyPoliciesDeprecatingPolicyHandler() {
 }
 
 bool LegacyPoliciesDeprecatingPolicyHandler::CheckPolicySettings(
     const PolicyMap& policies,
     PolicyErrorMap* errors) {
@@ skipping 34 matching lines @@
     }
   }
 }
 void LegacyPoliciesDeprecatingPolicyHandler::ApplyPolicySettings(
     const policy::PolicyMap& /* policies */,
     PrefValueMap* /* prefs */) {
   NOTREACHED();
 }
 
 }  // namespace policy