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

components/policy/core/browser/configuration_policy_handler.h

 // 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.
 
 #ifndef COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_
 #define COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/values.h"
 #include "components/policy/core/common/schema.h"
 #include "components/policy/policy_export.h"
 
 class PrefValueMap;
 
 namespace policy {
 
 class PolicyErrorMap;
@@ skipping 140 matching lines @@
 
 // Base class that encapsulates logic for mapping from a string enum list
 // to a separate matching type value.
 class POLICY_EXPORT StringMappingListPolicyHandler
     : public TypeCheckingPolicyHandler {
  public:
   // Data structure representing the map between policy strings and
   // matching pref values.
   class POLICY_EXPORT MappingEntry {
    public:
-    MappingEntry(const char* policy_value, scoped_ptr<base::Value> map);
+    MappingEntry(const char* policy_value, std::unique_ptr<base::Value> map);
     ~MappingEntry();
 
     const char* enum_value;
-    scoped_ptr<base::Value> mapped_value;
+    std::unique_ptr<base::Value> mapped_value;
   };
 
   // Callback that generates the map for this instance.
   typedef base::Callback<void(ScopedVector<MappingEntry>*)> GenerateMapCallback;
 
   StringMappingListPolicyHandler(const char* policy_name,
                                  const char* pref_path,
                                  const GenerateMapCallback& map_generator);
   ~StringMappingListPolicyHandler() override;
 
   // ConfigurationPolicyHandler methods:
   bool CheckPolicySettings(const PolicyMap& policies,
                            PolicyErrorMap* errors) override;
   void ApplyPolicySettings(const PolicyMap& policies,
                            PrefValueMap* prefs) override;
 
  private:
   // Attempts to convert the list in |input| to |output| according to the table,
   // returns false on errors.
   bool Convert(const base::Value* input,
                base::ListValue* output,
                PolicyErrorMap* errors);
 
   // Helper method that converts from a policy value string to the associated
   // pref value.
-  scoped_ptr<base::Value> Map(const std::string& entry_value);
+  std::unique_ptr<base::Value> Map(const std::string& entry_value);
 
   // Name of the pref to write.
   const char* pref_path_;
 
   // The callback invoked to generate the map for this instance.
   GenerateMapCallback map_getter_;
 
   // Map of string policy values to local pref values. This is generated lazily
   // so the generation does not have to happen if no policy is present.
   ScopedVector<MappingEntry> map_;
@@ skipping 60 matching lines @@
   // ConfigurationPolicyHandler:
   bool CheckPolicySettings(const PolicyMap& policies,
                            PolicyErrorMap* errors) override;
 
   const char* policy_name() const;
 
  protected:
   // Runs policy checks and returns the policy value if successful.
   bool CheckAndGetValue(const PolicyMap& policies,
                         PolicyErrorMap* errors,
-                        scoped_ptr<base::Value>* output);
+                        std::unique_ptr<base::Value>* output);
 
  private:
   const char* policy_name_;
   Schema schema_;
   SchemaOnErrorStrategy strategy_;
 
   DISALLOW_COPY_AND_ASSIGN(SchemaValidatingPolicyHandler);
 };
 
 // Maps policy to pref like SimplePolicyHandler while ensuring that the value
@@ skipping 32 matching lines @@
 };
 
 // A policy handler to deprecate multiple legacy policies with a new one.
 // This handler will completely ignore any of legacy policy values if the new
 // one is set.
 class POLICY_EXPORT LegacyPoliciesDeprecatingPolicyHandler
     : public ConfigurationPolicyHandler {
  public:
   LegacyPoliciesDeprecatingPolicyHandler(
       ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers,
-      scoped_ptr<SchemaValidatingPolicyHandler> new_policy_handler);
+      std::unique_ptr<SchemaValidatingPolicyHandler> new_policy_handler);
   ~LegacyPoliciesDeprecatingPolicyHandler() override;
 
   // ConfigurationPolicyHandler:
   bool CheckPolicySettings(const PolicyMap& policies,
                            PolicyErrorMap* errors) override;
   void ApplyPolicySettingsWithParameters(
       const policy::PolicyMap& policies,
       const policy::PolicyHandlerParameters& parameters,
       PrefValueMap* prefs) override;
 
  protected:
   void ApplyPolicySettings(const PolicyMap& policies,
                            PrefValueMap* prefs) override;
 
  private:
   ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers_;
-  scoped_ptr<SchemaValidatingPolicyHandler> new_policy_handler_;
+  std::unique_ptr<SchemaValidatingPolicyHandler> new_policy_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(LegacyPoliciesDeprecatingPolicyHandler);
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_