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

chrome/browser/chromeos/settings/device_oauth2_token_service_unittest.cc

 // Copyright 2013 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/chromeos/settings/device_oauth2_token_service.h"
 
 #include <stdint.h>
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 73 matching lines @@
   }
 
   void SetRobotAccountId(const std::string& account_id) {
     device_policy_.policy_data().set_service_account_identity(account_id);
     device_policy_.Build();
     device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
     DeviceSettingsService::Get()->Load();
     device_settings_test_helper_.Flush();
   }
 
-  scoped_ptr<OAuth2TokenService::Request> StartTokenRequest() {
+  std::unique_ptr<OAuth2TokenService::Request> StartTokenRequest() {
     return oauth2_service_->StartRequest(oauth2_service_->GetRobotAccountId(),
                                          std::set<std::string>(),
                                          &consumer_);
   }
 
   void SetUp() override {
     fake_cryptohome_client_ = new FakeCryptohomeClient;
     fake_cryptohome_client_->SetServiceIsAvailable(true);
     fake_cryptohome_client_->set_system_salt(
         FakeCryptohomeClient::GetStubSystemSalt());
     chromeos::DBusThreadManager::GetSetterForTesting()->SetCryptohomeClient(
-        scoped_ptr<CryptohomeClient>(fake_cryptohome_client_));
+        std::unique_ptr<CryptohomeClient>(fake_cryptohome_client_));
 
     SystemSaltGetter::Initialize();
 
     DeviceSettingsService::Initialize();
     scoped_refptr<ownership::MockOwnerKeyUtil> owner_key_util_(
         new ownership::MockOwnerKeyUtil());
     owner_key_util_->SetPublicKeyFromPrivateKey(
         *device_policy_.GetSigningKey());
     DeviceSettingsService::Get()->SetSessionManager(
         &device_settings_test_helper_, owner_key_util_);
@@ skipping 87 matching lines @@
     }
   };
 
   base::MessageLoop message_loop_;
   ScopedTestingLocalState scoped_testing_local_state_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   net::TestURLFetcherFactory factory_;
   FakeCryptohomeClient* fake_cryptohome_client_;
   DeviceSettingsTestHelper device_settings_test_helper_;
   policy::DevicePolicyBuilder device_policy_;
-  scoped_ptr<DeviceOAuth2TokenService, TokenServiceDeleter> oauth2_service_;
+  std::unique_ptr<DeviceOAuth2TokenService, TokenServiceDeleter>
+      oauth2_service_;
   TestingOAuth2TokenServiceConsumer consumer_;
 };
 
 void DeviceOAuth2TokenServiceTest::ReturnOAuthUrlFetchResults(
     int fetcher_id,
     net::HttpStatusCode response_code,
     const std::string& response_string) {
   net::TestURLFetcher* fetcher = factory_.GetFetcherByID(fetcher_id);
   if (fetcher) {
     factory_.RemoveFetcherFromMap(fetcher_id);
@@ skipping 67 matching lines @@
   EXPECT_EQ("test-token", GetRefreshToken());
 
   // Reloading shouldn't change the token either.
   CreateService();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ("test-token", GetRefreshToken());
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest, RefreshTokenValidation_Success) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetches();
   AssertConsumerTokensAndErrors(1, 0);
 
   EXPECT_EQ("scoped_access_token", consumer_.last_token_);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest, RefreshTokenValidation_SuccessAsyncLoad) {
   SetUpWithPendingSalt();
 
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
   PerformURLFetches();
   AssertConsumerTokensAndErrors(0, 0);
 
   fake_cryptohome_client_->set_system_salt(
       FakeCryptohomeClient::GetStubSystemSalt());
   fake_cryptohome_client_->SetServiceIsAvailable(true);
   base::RunLoop().RunUntilIdle();
 
   PerformURLFetches();
   AssertConsumerTokensAndErrors(1, 0);
 
   EXPECT_EQ("scoped_access_token", consumer_.last_token_);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest, RefreshTokenValidation_Cancel) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
   request.reset();
 
   PerformURLFetches();
 
   // Test succeeds if this line is reached without a crash.
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest, RefreshTokenValidation_NoSalt) {
   fake_cryptohome_client_->set_system_salt(std::vector<uint8_t>());
   fake_cryptohome_client_->SetServiceIsAvailable(true);
   SetUpDefaultValues();
 
   EXPECT_FALSE(RefreshTokenIsAvailable());
 
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
   base::RunLoop().RunUntilIdle();
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest,
        RefreshTokenValidation_Failure_TokenInfoAccessTokenHttpError) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetchesWithResults(
       net::HTTP_UNAUTHORIZED, "",
       net::HTTP_OK, GetValidTokenInfoResponse("service_acct@g.com"),
       net::HTTP_OK, GetValidTokenResponse("ignored", 3600));
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest,
        RefreshTokenValidation_Failure_TokenInfoAccessTokenInvalidResponse) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetchesWithResults(
       net::HTTP_OK, "invalid response",
       net::HTTP_OK, GetValidTokenInfoResponse("service_acct@g.com"),
       net::HTTP_OK, GetValidTokenResponse("ignored", 3600));
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest,
        RefreshTokenValidation_Failure_TokenInfoApiCallHttpError) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetchesWithResults(
       net::HTTP_OK, GetValidTokenResponse("tokeninfo_access_token", 3600),
       net::HTTP_INTERNAL_SERVER_ERROR, "",
       net::HTTP_OK, GetValidTokenResponse("ignored", 3600));
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest,
        RefreshTokenValidation_Failure_TokenInfoApiCallInvalidResponse) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetchesWithResults(
       net::HTTP_OK, GetValidTokenResponse("tokeninfo_access_token", 3600),
       net::HTTP_OK, "invalid response",
       net::HTTP_OK, GetValidTokenResponse("ignored", 3600));
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest,
        RefreshTokenValidation_Failure_CloudPrintAccessTokenHttpError) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetchesWithResults(
       net::HTTP_OK, GetValidTokenResponse("tokeninfo_access_token", 3600),
       net::HTTP_OK, GetValidTokenInfoResponse("service_acct@g.com"),
       net::HTTP_BAD_REQUEST, "");
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest,
        RefreshTokenValidation_Failure_CloudPrintAccessTokenInvalidResponse) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetchesWithResults(
       net::HTTP_OK, GetValidTokenResponse("tokeninfo_access_token", 3600),
       net::HTTP_OK, GetValidTokenInfoResponse("service_acct@g.com"),
       net::HTTP_OK, "invalid request");
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest, RefreshTokenValidation_Failure_BadOwner) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   SetRobotAccountId("WRONG_service_acct@g.com");
 
   PerformURLFetchesWithResults(
       net::HTTP_OK, GetValidTokenResponse("tokeninfo_access_token", 3600),
       net::HTTP_OK, GetValidTokenInfoResponse("service_acct@g.com"),
       net::HTTP_OK, GetValidTokenResponse("ignored", 3600));
 
   AssertConsumerTokensAndErrors(0, 1);
 }
 
 TEST_F(DeviceOAuth2TokenServiceTest, RefreshTokenValidation_Retry) {
   SetUpDefaultValues();
-  scoped_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
+  std::unique_ptr<OAuth2TokenService::Request> request = StartTokenRequest();
 
   PerformURLFetchesWithResults(
       net::HTTP_INTERNAL_SERVER_ERROR, "",
       net::HTTP_OK, GetValidTokenInfoResponse("service_acct@g.com"),
       net::HTTP_OK, GetValidTokenResponse("ignored", 3600));
 
   AssertConsumerTokensAndErrors(0, 1);
 
   // Retry should succeed.
   request = StartTokenRequest();
@@ skipping 16 matching lines @@
   // Also make the robot account ID available. Verify that the token is
   // announced now.
   EXPECT_CALL(observer, OnRefreshTokenAvailable("robot@example.com"));
   SetRobotAccountId("robot@example.com");
   testing::Mock::VerifyAndClearExpectations(&observer);
 
   oauth2_service_->RemoveObserver(&observer);
 }
 
 }  // namespace chromeos