Convert //chrome/browser/supervised_user from scoped_ptr to std::unique_ptr

chrome/browser/supervised_user/legacy/supervised_user_refresh_token_fetcher.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 "chrome/browser/supervised_user/legacy/supervised_user_refresh_token_fetcher.h"
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 90 matching lines @@
                                       const std::string& token);
   OAuth2TokenService* oauth2_token_service_;
   std::string account_id_;
   std::string device_id_;
   URLRequestContextGetter* context_;
 
   std::string device_name_;
   std::string supervised_user_id_;
   TokenCallback callback_;
 
-  scoped_ptr<OAuth2TokenService::Request> access_token_request_;
+  std::unique_ptr<OAuth2TokenService::Request> access_token_request_;
   std::string access_token_;
   bool access_token_expired_;
-  scoped_ptr<URLFetcher> url_fetcher_;
-  scoped_ptr<GaiaOAuthClient> gaia_oauth_client_;
+  std::unique_ptr<URLFetcher> url_fetcher_;
+  std::unique_ptr<GaiaOAuthClient> gaia_oauth_client_;
 };
 
 SupervisedUserRefreshTokenFetcherImpl::SupervisedUserRefreshTokenFetcherImpl(
     OAuth2TokenService* oauth2_token_service,
     const std::string& account_id,
     const std::string& device_id,
     URLRequestContextGetter* context)
     : OAuth2TokenService::Consumer("supervised_user"),
       oauth2_token_service_(oauth2_token_service),
       account_id_(account_id),
@@ skipping 89 matching lines @@
     // TODO(bauerb): We should return the HTTP response code somehow.
     DLOG(WARNING) << "HTTP error " << response_code;
     DispatchGoogleServiceAuthError(
         GoogleServiceAuthError(GoogleServiceAuthError::CONNECTION_FAILED),
         std::string());
     return;
   }
 
   std::string response_body;
   source->GetResponseAsString(&response_body);
-  scoped_ptr<base::Value> value = base::JSONReader::Read(response_body);
+  std::unique_ptr<base::Value> value = base::JSONReader::Read(response_body);
   base::DictionaryValue* dict = NULL;
   if (!value.get() || !value->GetAsDictionary(&dict)) {
     DispatchNetworkError(net::ERR_INVALID_RESPONSE);
     return;
   }
   std::string auth_code;
   if (!dict->GetString(kCodeKey, &auth_code)) {
     DispatchNetworkError(net::ERR_INVALID_RESPONSE);
     return;
   }
@@ skipping 46 matching lines @@
 void SupervisedUserRefreshTokenFetcherImpl::DispatchGoogleServiceAuthError(
     const GoogleServiceAuthError& error,
     const std::string& token) {
   callback_.Run(error, token);
   callback_.Reset();
 }
 
 }  // namespace
 
 // static
-scoped_ptr<SupervisedUserRefreshTokenFetcher>
+std::unique_ptr<SupervisedUserRefreshTokenFetcher>
 SupervisedUserRefreshTokenFetcher::Create(
     OAuth2TokenService* oauth2_token_service,
     const std::string& account_id,
     const std::string& device_id,
     URLRequestContextGetter* context) {
-  scoped_ptr<SupervisedUserRefreshTokenFetcher> fetcher(
-      new SupervisedUserRefreshTokenFetcherImpl(oauth2_token_service,
-                                                account_id,
-                                                device_id,
-                                                context));
+  std::unique_ptr<SupervisedUserRefreshTokenFetcher> fetcher(
+      new SupervisedUserRefreshTokenFetcherImpl(
+          oauth2_token_service, account_id, device_id, context));
   return fetcher;
 }
 
 SupervisedUserRefreshTokenFetcher::~SupervisedUserRefreshTokenFetcher() {}