Convert //remoting to use std::unique_ptr

remoting/test/app_remoting_test_driver_environment.cc

 // 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.
 
 #include "remoting/test/app_remoting_test_driver_environment.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 41 matching lines @@
   if (!access_token_.empty()) {
     return true;
   }
 
   if (!base::MessageLoop::current()) {
     message_loop_.reset(new base::MessageLoopForIO);
   }
 
   // If a unit test has set |test_refresh_token_store_| then we should use it
   // below.  Note that we do not want to destroy the test object.
-  scoped_ptr<RefreshTokenStore> temporary_refresh_token_store;
+  std::unique_ptr<RefreshTokenStore> temporary_refresh_token_store;
   RefreshTokenStore* refresh_token_store = test_refresh_token_store_;
   if (!refresh_token_store) {
     temporary_refresh_token_store =
         RefreshTokenStore::OnDisk(user_name_, refresh_token_file_path_);
     refresh_token_store = temporary_refresh_token_store.get();
   }
 
   // Check to see if we have a refresh token stored for this user.
   refresh_token_ = refresh_token_store->FetchRefreshToken();
   if (refresh_token_.empty()) {
@@ skipping 38 matching lines @@
 
   base::RunLoop run_loop;
 
   RemoteHostInfoCallback remote_host_info_fetch_callback = base::Bind(
       &AppRemotingTestDriverEnvironment::OnRemoteHostInfoRetrieved,
       base::Unretained(this), run_loop.QuitClosure(), remote_host_info);
 
   // If a unit test has set |test_remote_host_info_fetcher_| then we should use
   // it below.  Note that we do not want to destroy the test object at the end
   // of the function which is why we have the dance below.
-  scoped_ptr<RemoteHostInfoFetcher> temporary_remote_host_info_fetcher;
+  std::unique_ptr<RemoteHostInfoFetcher> temporary_remote_host_info_fetcher;
   RemoteHostInfoFetcher* remote_host_info_fetcher =
       test_remote_host_info_fetcher_;
   if (!remote_host_info_fetcher) {
     temporary_remote_host_info_fetcher.reset(new RemoteHostInfoFetcher());
     remote_host_info_fetcher = temporary_remote_host_info_fetcher.get();
   }
 
   remote_host_info_fetcher->RetrieveRemoteHostInfo(
       application_id, access_token_, service_environment_,
       remote_host_info_fetch_callback);
@@ skipping 89 matching lines @@
     RemoteHostInfoFetcher* remote_host_info_fetcher) {
   DCHECK(remote_host_info_fetcher);
 
   test_remote_host_info_fetcher_ = remote_host_info_fetcher;
 }
 
 void AppRemotingTestDriverEnvironment::TearDown() {
   // If a unit test has set |test_app_remoting_report_issue_request_| then we
   // should use it below.  Note that we do not want to destroy the test object
   // at the end of the function which is why we have the dance below.
-  scoped_ptr<AppRemotingReportIssueRequest> temporary_report_issue_request;
+  std::unique_ptr<AppRemotingReportIssueRequest> temporary_report_issue_request;
   AppRemotingReportIssueRequest* report_issue_request =
       test_app_remoting_report_issue_request_;
   if (!report_issue_request) {
     temporary_report_issue_request.reset(new AppRemotingReportIssueRequest());
     report_issue_request = temporary_report_issue_request.get();
   }
 
   for (const auto& kvp : host_ids_to_release_) {
     std::string application_id = kvp.first;
     VLOG(1) << "Releasing hosts for application: " << application_id;
@@ skipping 30 matching lines @@
 
   access_token_.clear();
 
   AccessTokenCallback access_token_callback =
       base::Bind(&AppRemotingTestDriverEnvironment::OnAccessTokenRetrieved,
                  base::Unretained(this), run_loop.QuitClosure());
 
   // If a unit test has set |test_access_token_fetcher_| then we should use it
   // below.  Note that we do not want to destroy the test object at the end of
   // the function which is why we have the dance below.
-  scoped_ptr<AccessTokenFetcher> temporary_access_token_fetcher;
+  std::unique_ptr<AccessTokenFetcher> temporary_access_token_fetcher;
   AccessTokenFetcher* access_token_fetcher = test_access_token_fetcher_;
   if (!access_token_fetcher) {
     temporary_access_token_fetcher.reset(new AccessTokenFetcher());
     access_token_fetcher = temporary_access_token_fetcher.get();
   }
 
   if (!auth_code.empty()) {
     // If the user passed in an authcode, then use it to retrieve an
     // updated access/refresh token.
     access_token_fetcher->GetAccessTokenFromAuthCode(auth_code,
                                                      access_token_callback);
   } else {
     DCHECK(!refresh_token_.empty());
 
     access_token_fetcher->GetAccessTokenFromRefreshToken(refresh_token_,
                                                          access_token_callback);
   }
 
   run_loop.Run();
 
   // If we were using an auth_code and received a valid refresh token,
   // then we want to store it locally.  If we had an auth code and did not
   // receive a refresh token, then we should let the user know and exit.
   if (!auth_code.empty()) {
     if (!refresh_token_.empty()) {
       // If a unit test has set |test_refresh_token_store_| then we should use
       // it below.  Note that we do not want to destroy the test object.
-      scoped_ptr<RefreshTokenStore> temporary_refresh_token_store;
+      std::unique_ptr<RefreshTokenStore> temporary_refresh_token_store;
       RefreshTokenStore* refresh_token_store = test_refresh_token_store_;
       if (!refresh_token_store) {
         temporary_refresh_token_store =
             RefreshTokenStore::OnDisk(user_name_, refresh_token_file_path_);
         refresh_token_store = temporary_refresh_token_store.get();
       }
 
       if (!refresh_token_store->StoreRefreshToken(refresh_token_)) {
         // If we failed to persist the refresh token, then we should let the
         // user sort out the issue before continuing.
@@ skipping 30 matching lines @@
     const RemoteHostInfo& retrieved_remote_host_info) {
   DCHECK(remote_host_info);
 
   *remote_host_info = retrieved_remote_host_info;
 
   done_closure.Run();
 }
 
 }  // namespace test
 }  // namespace remoting