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

components/policy/core/common/async_policy_loader.h

 // 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.
 
 #ifndef COMPONENTS_POLICY_CORE_COMMON_ASYNC_POLICY_LOADER_H_
 #define COMPONENTS_POLICY_CORE_COMMON_ASYNC_POLICY_LOADER_H_
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "components/policy/core/common/schema_map.h"
 #include "components/policy/policy_export.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace policy {
@@ skipping 15 matching lines @@
   explicit AsyncPolicyLoader(
       const scoped_refptr<base::SequencedTaskRunner>& task_runner);
   virtual ~AsyncPolicyLoader();
 
   // Gets a SequencedTaskRunner backed by the background thread.
   base::SequencedTaskRunner* task_runner() const { return task_runner_.get(); }
 
   // Returns the currently configured policies. Load() is always invoked on
   // the background thread, except for the initial Load() at startup which is
   // invoked from the thread that owns the provider.
-  virtual scoped_ptr<PolicyBundle> Load() = 0;
+  virtual std::unique_ptr<PolicyBundle> Load() = 0;
 
   // Allows implementations to finalize their initialization on the background
   // thread (e.g. setup file watchers).
   virtual void InitOnBackgroundThread() = 0;
 
   // Implementations should return the time of the last modification detected,
   // or base::Time() if it doesn't apply, which is the default.
   virtual base::Time LastModificationTime();
 
   // Used by the AsyncPolicyProvider to do the initial Load(). The first load
   // is also used to initialize |last_modification_time_| and
   // |schema_map_|.
-  scoped_ptr<PolicyBundle> InitialLoad(const scoped_refptr<SchemaMap>& schemas);
+  std::unique_ptr<PolicyBundle> InitialLoad(
+      const scoped_refptr<SchemaMap>& schemas);
 
   // Implementations should invoke Reload() when a change is detected. This
   // must be invoked from the background thread and will trigger a Load(),
   // and pass the returned bundle to the provider.
   // The load is immediate when |force| is true. Otherwise, the loader
   // reschedules the reload until the LastModificationTime() is a couple of
   // seconds in the past. This mitigates the problem of reading files that are
   // currently being written to, and whose contents are incomplete.
   // A reload is posted periodically, if it hasn't been triggered recently. This
   // makes sure the policies are reloaded if the update events aren't triggered.
   void Reload(bool force);
 
   const scoped_refptr<SchemaMap>& schema_map() const { return schema_map_; }
 
  private:
   // Allow AsyncPolicyProvider to call Init().
   friend class AsyncPolicyProvider;
 
-  typedef base::Callback<void(scoped_ptr<PolicyBundle>)> UpdateCallback;
+  typedef base::Callback<void(std::unique_ptr<PolicyBundle>)> UpdateCallback;
 
   // Used by the AsyncPolicyProvider to install the |update_callback_|.
   // Invoked on the background thread.
   void Init(const UpdateCallback& update_callback);
 
   // Used by the AsyncPolicyProvider to reload with an updated SchemaMap.
   void RefreshPolicies(scoped_refptr<SchemaMap> schema_map);
 
   // Cancels any pending periodic reload and posts one |delay| time units from
   // now.
@@ skipping 24 matching lines @@
 
   // Used to get WeakPtrs for the periodic reload task.
   base::WeakPtrFactory<AsyncPolicyLoader> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncPolicyLoader);
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_COMMON_ASYNC_POLICY_LOADER_H_