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

components/proximity_auth/unlock_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_UNLOCK_MANAGER_H
 #define COMPONENTS_PROXIMITY_AUTH_UNLOCK_MANAGER_H
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 44 matching lines @@
   void OnLifeCycleStateChanged();
 
   // Called when the user pod is clicked for an authentication attempt of type
   // |auth_type|.
   // Exposed for testing.
   void OnAuthAttempted(ScreenlockBridge::LockHandler::AuthType auth_type);
 
  protected:
   // Creates a ProximityMonitor instance for the given |remote_device|.
   // Exposed for testing.
-  virtual scoped_ptr<ProximityMonitor> CreateProximityMonitor(
+  virtual std::unique_ptr<ProximityMonitor> CreateProximityMonitor(
       const RemoteDevice& remote_device);
 
  private:
   // The possible lock screen states for the remote device.
   enum class RemoteScreenlockState {
     UNKNOWN,
     UNLOCKED,
     DISABLED,
     LOCKED,
   };
@@ skipping 63 matching lines @@
   // Returns the Messenger instance associated with |life_cycle_|. This function
   // will return nullptr if |life_cycle_| is not set or the remote device is not
   // yet authenticated.
   Messenger* GetMessenger();
 
   // Whether |this| manager is being used for sign-in or session unlock.
   const ProximityAuthSystem::ScreenlockType screenlock_type_;
 
   // Whether the user is present at the remote device. Unset if no remote status
   // update has yet been received.
-  scoped_ptr<RemoteScreenlockState> remote_screenlock_state_;
+  std::unique_ptr<RemoteScreenlockState> remote_screenlock_state_;
 
   // Controls the proximity auth flow logic for a remote device. Not owned, and
   // expcted to outlive |this| instance.
   RemoteDeviceLifeCycle* life_cycle_;
 
   // Tracks whether the remote device is currently in close enough proximity to
   // the local device to allow unlocking.
-  scoped_ptr<ProximityMonitor> proximity_monitor_;
+  std::unique_ptr<ProximityMonitor> proximity_monitor_;
 
   // Used to call into the embedder. Expected to outlive |this| instance.
   ProximityAuthClient* proximity_auth_client_;
 
   // Whether the screen is currently locked.
   bool is_locked_;
 
   // True if the manager is currently processing a user-initiated authentication
   // attempt, which is initiated when the user pod is clicked.
   bool is_attempting_auth_;
 
   // Whether the system is waking up from sleep.
   bool is_waking_up_;
 
   // The Bluetooth adapter. Null if there is no adapter present on the local
   // device.
   scoped_refptr<device::BluetoothAdapter> bluetooth_adapter_;
 
   // The sign-in secret received from the remote device by decrypting the
   // sign-in challenge.
-  scoped_ptr<std::string> sign_in_secret_;
+  std::unique_ptr<std::string> sign_in_secret_;
 
   // The state of the current screen lock UI.
   ScreenlockState screenlock_state_;
 
   // Used to clear the waking up state after a timeout.
   base::WeakPtrFactory<UnlockManager> clear_waking_up_state_weak_ptr_factory_;
 
   // Used to reject auth attempts after a timeout. An in-progress auth attempt
   // blocks the sign-in screen UI, so it's important to prevent the auth attempt
   // from blocking the UI in case a step in the code path hangs.
   base::WeakPtrFactory<UnlockManager> reject_auth_attempt_weak_ptr_factory_;
 
   // Used to vend all other weak pointers.
   base::WeakPtrFactory<UnlockManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UnlockManager);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_AUTH_UNLOCK_MANAGER_H