Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/gaia/oauth2_token_service_request.cc

 // 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.
 
 #include "google_apis/gaia/oauth2_token_service_request.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_access_token_consumer.h"
 
 OAuth2TokenServiceRequest::TokenServiceProvider::TokenServiceProvider() {
 }
 
 OAuth2TokenServiceRequest::TokenServiceProvider::~TokenServiceProvider() {
 }
@@ skipping 163 matching lines @@
                                     base::Time expiration_time);
   void InformOwnerOnGetTokenFailure(GoogleServiceAuthError error);
 
   scoped_refptr<base::SingleThreadTaskRunner> owner_task_runner_;
   OAuth2TokenService::Consumer* const consumer_;
   std::string account_id_;
   OAuth2TokenService::ScopeSet scopes_;
 
   // OAuth2TokenService request for fetching OAuth2 access token; it should be
   // created, reset and accessed only on the token service thread.
-  scoped_ptr<OAuth2TokenService::Request> request_;
+  std::unique_ptr<OAuth2TokenService::Request> request_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestCore);
 };
 
 RequestCore::RequestCore(
     OAuth2TokenServiceRequest* owner,
     const scoped_refptr<OAuth2TokenServiceRequest::TokenServiceProvider>&
         provider,
     OAuth2TokenService::Consumer* consumer,
     const std::string& account_id,
@@ skipping 113 matching lines @@
 }
 
 void InvalidateCore::StopOnTokenServiceThread() {
   DCHECK(token_service_task_runner()->BelongsToCurrentThread());
   // Nothing to do.
 }
 
 }  // namespace
 
 // static
-scoped_ptr<OAuth2TokenServiceRequest> OAuth2TokenServiceRequest::CreateAndStart(
+std::unique_ptr<OAuth2TokenServiceRequest>
+OAuth2TokenServiceRequest::CreateAndStart(
     const scoped_refptr<TokenServiceProvider>& provider,
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
-  scoped_ptr<OAuth2TokenServiceRequest> request(
+  std::unique_ptr<OAuth2TokenServiceRequest> request(
       new OAuth2TokenServiceRequest(account_id));
   scoped_refptr<Core> core(
       new RequestCore(request.get(), provider, consumer, account_id, scopes));
   request->StartWithCore(core);
   return request;
 }
 
 // static
 void OAuth2TokenServiceRequest::InvalidateToken(
     const scoped_refptr<TokenServiceProvider>& provider,
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token) {
-  scoped_ptr<OAuth2TokenServiceRequest> request(
+  std::unique_ptr<OAuth2TokenServiceRequest> request(
       new OAuth2TokenServiceRequest(account_id));
   scoped_refptr<Core> core(new InvalidateCore(
       request.get(), provider, access_token, account_id, scopes));
   request->StartWithCore(core);
 }
 
 OAuth2TokenServiceRequest::~OAuth2TokenServiceRequest() {
   core_->Stop();
 }
 
 std::string OAuth2TokenServiceRequest::GetAccountId() const {
   return account_id_;
 }
 
 OAuth2TokenServiceRequest::OAuth2TokenServiceRequest(
     const std::string& account_id)
     : account_id_(account_id) {
   DCHECK(!account_id_.empty());
 }
 
 void OAuth2TokenServiceRequest::StartWithCore(const scoped_refptr<Core>& core) {
   DCHECK(core.get());
   core_ = core;
   core_->Start();
 }