Convert //remoting to use std::unique_ptr

remoting/test/chromoting_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/chromoting_test_driver_environment.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 38 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 122 matching lines @@
 
   access_token_.clear();
 
   AccessTokenCallback access_token_callback =
       base::Bind(&ChromotingTestDriverEnvironment::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 35 matching lines @@
 
 bool ChromotingTestDriverEnvironment::RetrieveHostList() {
   base::RunLoop run_loop;
 
   // Clear the previous host info.
   host_info_ = HostInfo();
 
   // If a unit test has set |test_host_list_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<HostListFetcher> temporary_host_list_fetcher;
+  std::unique_ptr<HostListFetcher> temporary_host_list_fetcher;
   HostListFetcher* host_list_fetcher = test_host_list_fetcher_;
   if (!host_list_fetcher) {
     temporary_host_list_fetcher.reset(new HostListFetcher());
     host_list_fetcher = temporary_host_list_fetcher.get();
   }
 
   remoting::test::HostListFetcher::HostlistCallback host_list_callback =
       base::Bind(&ChromotingTestDriverEnvironment::OnHostListRetrieved,
                  base::Unretained(this), run_loop.QuitClosure());
 
@@ skipping 37 matching lines @@
     const std::vector<HostInfo>& retrieved_host_list) {
   VLOG(1) << "OnHostListRetrieved() Called";
 
   host_list_ = retrieved_host_list;
 
   done_closure.Run();
 }
 
 }  // namespace test
 }  // namespace remoting