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

components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h

 // Copyright 2015 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_PROXIMITY_AUTH_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H
 #define COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "components/proximity_auth/cryptauth/cryptauth_gcm_manager.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/cryptauth/sync_scheduler.h"
 
 class PrefRegistrySimple;
 class PrefService;
 
@@ skipping 34 matching lines @@
   // |secure_message_delegate|: Used to generate the user's keypair if it does
   //                            not exist.
   // |device_info|: Contains information about the local device that will be
   //                uploaded to CryptAuth with each enrollment request.
   // |gcm_manager|: Used to perform GCM registrations and also notifies when GCM
   //                push messages trigger re-enrollments.
   //                Not owned and must outlive this instance.
   // |pref_service|: Contains preferences across browser restarts, and should
   //                 have been registered through RegisterPrefs().
   CryptAuthEnrollmentManager(
-      scoped_ptr<base::Clock> clock,
-      scoped_ptr<CryptAuthEnrollerFactory> enroller_factory,
-      scoped_ptr<SecureMessageDelegate> secure_message_delegate,
+      std::unique_ptr<base::Clock> clock,
+      std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory,
+      std::unique_ptr<SecureMessageDelegate> secure_message_delegate,
       const cryptauth::GcmDeviceInfo& device_info,
       CryptAuthGCMManager* gcm_manager,
       PrefService* pref_service);
 
   ~CryptAuthEnrollmentManager() override;
 
   // Registers the prefs used by this class to the given |pref_service|.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Begins scheduling periodic enrollment attempts.
@@ skipping 32 matching lines @@
 
   // Returns the keypair used to enroll with CryptAuth. If no enrollment has
   // been completed, then an empty string will be returned.
   // Note: These keys are really serialized protocol buffer messages, and should
   // only be used by passing to SecureMessageDelegate.
   std::string GetUserPublicKey();
   std::string GetUserPrivateKey();
 
  protected:
   // Creates a new SyncScheduler instance. Exposed for testing.
-  virtual scoped_ptr<SyncScheduler> CreateSyncScheduler();
+  virtual std::unique_ptr<SyncScheduler> CreateSyncScheduler();
 
  private:
   // CryptAuthGCMManager::Observer:
   void OnGCMRegistrationResult(bool success) override;
   void OnReenrollMessage() override;
 
   // Callback when a new keypair is generated.
   void OnKeyPairGenerated(const std::string& public_key,
                           const std::string& private_key);
 
   // SyncScheduler::Delegate:
   void OnSyncRequested(
-      scoped_ptr<SyncScheduler::SyncRequest> sync_request) override;
+      std::unique_ptr<SyncScheduler::SyncRequest> sync_request) override;
 
   // Starts a CryptAuth enrollment attempt, generating a new keypair if one is
   // not already stored in the user prefs.
   void DoCryptAuthEnrollment();
 
   // Starts a CryptAuth enrollment attempt, after a key-pair is stored in the
   // user prefs.
   void DoCryptAuthEnrollmentWithKeys();
 
   // Callback when |cryptauth_enroller_| completes.
   void OnEnrollmentFinished(bool success);
 
   // Used to determine the time.
-  scoped_ptr<base::Clock> clock_;
+  std::unique_ptr<base::Clock> clock_;
 
   // Creates CryptAuthEnroller instances for each enrollment attempt.
-  scoped_ptr<CryptAuthEnrollerFactory> enroller_factory_;
+  std::unique_ptr<CryptAuthEnrollerFactory> enroller_factory_;
 
   // The SecureMessageDelegate used to generate the user's keypair if it does
   // not already exist.
-  scoped_ptr<SecureMessageDelegate> secure_message_delegate_;
+  std::unique_ptr<SecureMessageDelegate> secure_message_delegate_;
 
   // The local device information to upload to CryptAuth.
   const cryptauth::GcmDeviceInfo device_info_;
 
   //  Used to perform GCM registrations and also notifies when GCM push messages
   //  trigger re-enrollments. Not owned and must outlive this instance.
   CryptAuthGCMManager* gcm_manager_;
 
   // Contains perferences that outlive the lifetime of this object and across
   // process restarts.
   // Not owned and must outlive this instance.
   PrefService* pref_service_;
 
   // Schedules the time between enrollment attempts.
-  scoped_ptr<SyncScheduler> scheduler_;
+  std::unique_ptr<SyncScheduler> scheduler_;
 
   // Contains the SyncRequest that |scheduler_| requests when an enrollment
   // attempt is made.
-  scoped_ptr<SyncScheduler::SyncRequest> sync_request_;
+  std::unique_ptr<SyncScheduler::SyncRequest> sync_request_;
 
   // The CryptAuthEnroller instance for the current enrollment attempt. A new
   // instance will be created for each individual attempt.
-  scoped_ptr<CryptAuthEnroller> cryptauth_enroller_;
+  std::unique_ptr<CryptAuthEnroller> cryptauth_enroller_;
 
   // List of observers.
   base::ObserverList<Observer> observers_;
 
   base::WeakPtrFactory<CryptAuthEnrollmentManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CryptAuthEnrollmentManager);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_CRYPTAUTH_CRYPTAUTH_ENROLLMENT_MANAGER_H