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

components/proximity_auth/cryptauth/cryptauth_device_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_DEVICE_MANAGER_H
 #define COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CRYPTAUTH_DEVICE_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/clock.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 PrefService;
 class PrefRegistrySimple;
@@ skipping 37 matching lines @@
   };
 
   // Creates the manager:
   // |clock|: Used to determine the time between sync attempts.
   // |client_factory|: Creates CryptAuthClient instances to perform each sync.
   // |gcm_manager|: Notifies when GCM push messages trigger device syncs.
   //                Not owned and must outlive this instance.
   // |pref_service|: Stores syncing metadata and unlock key information to
   //                 persist across browser restarts. Must already be registered
   //                 with RegisterPrefs().
-  CryptAuthDeviceManager(scoped_ptr<base::Clock> clock,
-                         scoped_ptr<CryptAuthClientFactory> client_factory,
+  CryptAuthDeviceManager(std::unique_ptr<base::Clock> clock,
+                         std::unique_ptr<CryptAuthClientFactory> client_factory,
                          CryptAuthGCMManager* gcm_manager,
                          PrefService* pref_service);
 
   ~CryptAuthDeviceManager() override;
 
   // Registers the prefs used by this class to the given |registry|.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Starts device manager to begin syncing devices.
   void Start();
@@ skipping 25 matching lines @@
   // has ever been recorded, then this function will also return true.
   bool IsRecoveringFromFailure() const;
 
   // Returns a list of remote devices that can unlock the user's other devices.
   const std::vector<cryptauth::ExternalDeviceInfo>& unlock_keys() const {
     return unlock_keys_;
   }
 
  protected:
   // Creates a new SyncScheduler instance. Exposed for testing.
-  virtual scoped_ptr<SyncScheduler> CreateSyncScheduler();
+  virtual std::unique_ptr<SyncScheduler> CreateSyncScheduler();
 
  private:
   // CryptAuthGCMManager::Observer:
   void OnResyncMessage() override;
 
   // Updates |unlock_keys_| by fetching the list stored in |pref_service_|.
   void UpdateUnlockKeysFromPrefs();
 
   // SyncScheduler::Delegate:
   void OnSyncRequested(
-      scoped_ptr<SyncScheduler::SyncRequest> sync_request) override;
+      std::unique_ptr<SyncScheduler::SyncRequest> sync_request) override;
 
   // Callback when |cryptauth_client_| completes with the response.
   void OnGetMyDevicesSuccess(const cryptauth::GetMyDevicesResponse& response);
   void OnGetMyDevicesFailure(const std::string& error);
 
   // Used to determine the time.
-  scoped_ptr<base::Clock> clock_;
+  std::unique_ptr<base::Clock> clock_;
 
   // Creates CryptAuthClient instances for each sync attempt.
-  scoped_ptr<CryptAuthClientFactory> client_factory_;
+  std::unique_ptr<CryptAuthClientFactory> client_factory_;
 
   // Notifies when GCM push messages trigger device sync. Not owned and must
   // outlive this instance.
   CryptAuthGCMManager* gcm_manager_;
 
   // Contains preferences that outlive the lifetime of this object and across
   // process restarts. |pref_service_| must outlive the lifetime of this
   // instance.
   PrefService* const pref_service_;
 
   // The unlock keys currently synced from CryptAuth.
   std::vector<cryptauth::ExternalDeviceInfo> unlock_keys_;
 
   // Schedules the time between device sync attempts.
-  scoped_ptr<SyncScheduler> scheduler_;
+  std::unique_ptr<SyncScheduler> scheduler_;
 
   // Contains the SyncRequest that |scheduler_| requests when a device sync
   // attempt is made.
-  scoped_ptr<SyncScheduler::SyncRequest> sync_request_;
+  std::unique_ptr<SyncScheduler::SyncRequest> sync_request_;
 
   // The CryptAuthEnroller instance for the current sync attempt. A new
   // instance will be created for each individual attempt.
-  scoped_ptr<CryptAuthClient> cryptauth_client_;
+  std::unique_ptr<CryptAuthClient> cryptauth_client_;
 
   // List of observers.
   base::ObserverList<Observer> observers_;
 
   base::WeakPtrFactory<CryptAuthDeviceManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CryptAuthDeviceManager);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_CRYPTAUTH_CRYPTAUTH_DEVICE_MANAGER_H