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

components/proximity_auth/cryptauth/cryptauth_client_impl.h

 // Copyright 2014 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_CLIENT_IMPL_H
 #define COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CLIENT_IMPL_H
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "components/proximity_auth/cryptauth/cryptauth_access_token_fetcher.h"
@@ skipping 12 matching lines @@
 class CryptAuthClientImpl : public CryptAuthClient {
  public:
   typedef base::Callback<void(const std::string&)> ErrorCallback;
 
   // Creates the client using |url_request_context| to make the HTTP request
   // through |api_call_flow|. CryptAuthClientImpl takes ownership of
   // |access_token_fetcher|, which provides the access token authorizing
   // CryptAuth requests. The |device_classifier| argument contains basic device
   // information of the caller (e.g. version and device type).
   CryptAuthClientImpl(
-      scoped_ptr<CryptAuthApiCallFlow> api_call_flow,
-      scoped_ptr<CryptAuthAccessTokenFetcher> access_token_fetcher,
+      std::unique_ptr<CryptAuthApiCallFlow> api_call_flow,
+      std::unique_ptr<CryptAuthAccessTokenFetcher> access_token_fetcher,
       scoped_refptr<net::URLRequestContextGetter> url_request_context,
       const cryptauth::DeviceClassifier& device_classifier);
   ~CryptAuthClientImpl() override;
 
   // CryptAuthClient:
   void GetMyDevices(const cryptauth::GetMyDevicesRequest& request,
                     const GetMyDevicesCallback& callback,
                     const ErrorCallback& error_callback) override;
   void FindEligibleUnlockDevices(
       const cryptauth::FindEligibleUnlockDevicesRequest& request,
@@ skipping 36 matching lines @@
   // return the result.
   template <class ResponseProto>
   void OnFlowSuccess(
       const base::Callback<void(const ResponseProto&)>& result_callback,
       const std::string& serialized_response);
 
   // Called when the current API call fails at any step.
   void OnApiCallFailed(const std::string& error_message);
 
   // Constructs and executes the actual HTTP request.
-  scoped_ptr<CryptAuthApiCallFlow> api_call_flow_;
+  std::unique_ptr<CryptAuthApiCallFlow> api_call_flow_;
 
   // Fetches the access token authorizing the API calls.
-  scoped_ptr<CryptAuthAccessTokenFetcher> access_token_fetcher_;
+  std::unique_ptr<CryptAuthAccessTokenFetcher> access_token_fetcher_;
 
   // The context for network requests.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_;
 
   // Contains basic device info of the client making the request that is sent to
   // CryptAuth with each API call.
   const cryptauth::DeviceClassifier device_classifier_;
 
   // True if an API call has been started. Remains true even after the API call
   // completes.
@@ skipping 22 matching lines @@
   // |url_request_context|: The request context to make the HTTP requests.
   // |device_classifier|: Contains basic device information of the client.
   CryptAuthClientFactoryImpl(
       OAuth2TokenService* token_service,
       const std::string& account_id,
       scoped_refptr<net::URLRequestContextGetter> url_request_context,
       const cryptauth::DeviceClassifier& device_classifier);
   ~CryptAuthClientFactoryImpl() override;
 
   // CryptAuthClientFactory:
-  scoped_ptr<CryptAuthClient> CreateInstance() override;
+  std::unique_ptr<CryptAuthClient> CreateInstance() override;
 
  private:
   OAuth2TokenService* token_service_;
   const std::string account_id_;
   const scoped_refptr<net::URLRequestContextGetter> url_request_context_;
   const cryptauth::DeviceClassifier device_classifier_;
 
   DISALLOW_COPY_AND_ASSIGN(CryptAuthClientFactoryImpl);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_AUTH_CRYPTAUTH_CLIENT_IMPL_H