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

chrome/browser/chromeos/policy/cloud_external_data_policy_observer_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/policy/cloud_external_data_policy_observer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/policy/cloud_external_data_manager_base_test_util.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_external_data_manager.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_provider.h"
@@ skipping 77 matching lines @@
   void SetUp() override;
   void TearDown() override;
 
   // CloudExternalDataPolicyObserver::Delegate:
   void OnExternalDataSet(const std::string& policy,
                          const std::string& user_id) override;
   void OnExternalDataCleared(const std::string& policy,
                              const std::string& user_id) override;
   void OnExternalDataFetched(const std::string& policy,
                              const std::string& user_id,
-                             scoped_ptr<std::string> data) override;
+                             std::unique_ptr<std::string> data) override;
 
   void CreateObserver();
 
   void ClearObservations();
 
   void SetDeviceLocalAccountAvatarPolicy(const std::string& account_id,
                                          const std::string& value);
 
   void AddDeviceLocalAccount(const std::string& account_id);
   void RemoveDeviceLocalAccount(const std::string& account_id);
 
   DeviceLocalAccountPolicyBroker* GetBrokerForDeviceLocalAccountUser();
 
   void RefreshDeviceLocalAccountPolicy(DeviceLocalAccountPolicyBroker* broker);
 
   void LogInAsDeviceLocalAccount(const AccountId& account_id);
 
   void SetRegularUserAvatarPolicy(const std::string& value);
 
   void LogInAsRegularUser();
 
   const std::string device_local_account_user_id_;
 
   std::string avatar_policy_1_data_;
   std::string avatar_policy_2_data_;
   std::string avatar_policy_1_;
   std::string avatar_policy_2_;
 
   chromeos::CrosSettings cros_settings_;
-  scoped_ptr<DeviceLocalAccountPolicyService>
+  std::unique_ptr<DeviceLocalAccountPolicyService>
       device_local_account_policy_service_;
   FakeAffiliatedInvalidationServiceProvider
       affiliated_invalidation_service_provider_;
   net::TestURLFetcherFactory url_fetcher_factory_;
 
-  scoped_ptr<DeviceLocalAccountPolicyProvider>
+  std::unique_ptr<DeviceLocalAccountPolicyProvider>
       device_local_account_policy_provider_;
 
   MockCloudExternalDataManager external_data_manager_;
   MockConfigurationPolicyProvider user_policy_provider_;
 
-  scoped_ptr<TestingProfile> profile_;
+  std::unique_ptr<TestingProfile> profile_;
 
-  scoped_ptr<CloudExternalDataPolicyObserver> observer_;
+  std::unique_ptr<CloudExternalDataPolicyObserver> observer_;
 
   std::vector<std::string> set_calls_;
   std::vector<std::string> cleared_calls_;
   std::vector<FetchedCall> fetched_calls_;
 
   ExternalDataFetcher::FetchCallback fetch_callback_;
 
   TestingProfileManager profile_manager_;
 
  private:
@@ skipping 64 matching lines @@
 void CloudExternalDataPolicyObserverTest::OnExternalDataCleared(
     const std::string& policy,
     const std::string& user_id) {
   EXPECT_EQ(key::kUserAvatarImage, policy);
   cleared_calls_.push_back(user_id);
 }
 
 void CloudExternalDataPolicyObserverTest::OnExternalDataFetched(
     const std::string& policy,
     const std::string& user_id,
-    scoped_ptr<std::string> data) {
+    std::unique_ptr<std::string> data) {
   EXPECT_EQ(key::kUserAvatarImage, policy);
   fetched_calls_.push_back(make_pair(user_id, std::string()));
   fetched_calls_.back().second.swap(*data);
 }
 
 void CloudExternalDataPolicyObserverTest::CreateObserver() {
   observer_.reset(new CloudExternalDataPolicyObserver(
       &cros_settings_,
       device_local_account_policy_service_.get(),
       key::kUserAvatarImage,
@@ skipping 69 matching lines @@
   device_settings_test_helper_.Flush();
 }
 
 void CloudExternalDataPolicyObserverTest::LogInAsDeviceLocalAccount(
     const AccountId& account_id) {
   user_manager_->AddUser(account_id);
 
   device_local_account_policy_provider_.reset(
       new DeviceLocalAccountPolicyProvider(
           account_id.GetUserEmail(), device_local_account_policy_service_.get(),
-          scoped_ptr<PolicyMap>()));
+          std::unique_ptr<PolicyMap>()));
 
   PolicyServiceImpl::Providers providers;
   providers.push_back(device_local_account_policy_provider_.get());
   TestingProfile::Builder builder;
   builder.SetPolicyService(
-      scoped_ptr<PolicyService>(new PolicyServiceImpl(providers)));
+      std::unique_ptr<PolicyService>(new PolicyServiceImpl(providers)));
   builder.SetPath(chromeos::ProfileHelper::Get()->GetProfilePathByUserIdHash(
       chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
           account_id.GetUserEmail())));
 
   profile_ = builder.Build();
   profile_->set_profile_name(account_id.GetUserEmail());
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
@@ skipping 16 matching lines @@
   user_policy_provider_.UpdateChromePolicy(policy_map);
 }
 
 void CloudExternalDataPolicyObserverTest::LogInAsRegularUser() {
   user_manager_->AddUser(AccountId::FromUserEmail(kRegularUserID));
 
   PolicyServiceImpl::Providers providers;
   providers.push_back(&user_policy_provider_);
   TestingProfile::Builder builder;
   builder.SetPolicyService(
-      scoped_ptr<PolicyService>(new PolicyServiceImpl(providers)));
+      std::unique_ptr<PolicyService>(new PolicyServiceImpl(providers)));
   builder.SetPath(chromeos::ProfileHelper::Get()->GetProfilePathByUserIdHash(
       chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
           kRegularUserID)));
 
   profile_ = builder.Build();
   profile_->set_profile_name(kRegularUserID);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
@@ skipping 401 matching lines @@
 
   EXPECT_TRUE(cleared_calls_.empty());
   EXPECT_TRUE(fetched_calls_.empty());
   ASSERT_EQ(1u, set_calls_.size());
   EXPECT_EQ(kRegularUserID, set_calls_.front());
   ClearObservations();
 
   Mock::VerifyAndClear(&external_data_manager_);
   EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0);
 
-  fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_1_data_)));
+  fetch_callback_.Run(base::WrapUnique(new std::string(avatar_policy_1_data_)));
 
   EXPECT_TRUE(set_calls_.empty());
   EXPECT_TRUE(cleared_calls_.empty());
   ASSERT_EQ(1u, fetched_calls_.size());
   EXPECT_EQ(kRegularUserID, fetched_calls_.front().first);
   EXPECT_EQ(avatar_policy_1_data_, fetched_calls_.front().second);
   ClearObservations();
 }
 
 // Verifies that when the external data reference for a regular user is not set
@@ skipping 85 matching lines @@
 
   EXPECT_TRUE(cleared_calls_.empty());
   EXPECT_TRUE(fetched_calls_.empty());
   ASSERT_EQ(1u, set_calls_.size());
   EXPECT_EQ(kRegularUserID, set_calls_.front());
   ClearObservations();
 
   Mock::VerifyAndClear(&external_data_manager_);
   EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0);
 
-  fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_1_data_)));
+  fetch_callback_.Run(base::WrapUnique(new std::string(avatar_policy_1_data_)));
 
   EXPECT_TRUE(set_calls_.empty());
   EXPECT_TRUE(cleared_calls_.empty());
   ASSERT_EQ(1u, fetched_calls_.size());
   EXPECT_EQ(kRegularUserID, fetched_calls_.front().first);
   EXPECT_EQ(avatar_policy_1_data_, fetched_calls_.front().second);
   ClearObservations();
 }
 
 // Verifies that when the external data reference for a regular user is set
@@ skipping 28 matching lines @@
 
   EXPECT_TRUE(cleared_calls_.empty());
   EXPECT_TRUE(fetched_calls_.empty());
   ASSERT_EQ(1u, set_calls_.size());
   EXPECT_EQ(kRegularUserID, set_calls_.front());
   ClearObservations();
 
   Mock::VerifyAndClear(&external_data_manager_);
   EXPECT_CALL(external_data_manager_, Fetch(key::kUserAvatarImage, _)).Times(0);
 
-  fetch_callback_.Run(make_scoped_ptr(new std::string(avatar_policy_2_data_)));
+  fetch_callback_.Run(base::WrapUnique(new std::string(avatar_policy_2_data_)));
 
   EXPECT_TRUE(set_calls_.empty());
   EXPECT_TRUE(cleared_calls_.empty());
   ASSERT_EQ(1u, fetched_calls_.size());
   EXPECT_EQ(kRegularUserID, fetched_calls_.front().first);
   EXPECT_EQ(avatar_policy_2_data_, fetched_calls_.front().second);
   ClearObservations();
 }
 
 }  // namespace policy