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

chrome/browser/chromeos/login/users/avatar/user_image_manager_browsertest.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/chromeos/login/users/avatar/user_image_manager.h"
+
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #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/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/login_manager_test.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
-#include "chrome/browser/chromeos/login/users/avatar/user_image_manager.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager_test_util.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/login/users/default_user_image/default_user_images.h"
 #include "chrome/browser/chromeos/login/users/mock_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/policy/cloud_external_data_manager_base_test_util.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.h"
 #include "chrome/browser/chromeos/policy/user_cloud_policy_manager_factory_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
@@ skipping 224 matching lines @@
       run_loop_.reset(new base::RunLoop);
       run_loop_->Run();
     }
   }
 
   base::FilePath test_data_dir_;
   base::FilePath user_data_dir_;
 
   PrefService* local_state_;
 
-  scoped_ptr<gfx::ImageSkia> decoded_image_;
+  std::unique_ptr<gfx::ImageSkia> decoded_image_;
 
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   const AccountId test_account_id1_ = AccountId::FromUserEmail(kTestUser1);
   const AccountId test_account_id2_ = AccountId::FromUserEmail(kTestUser2);
   const AccountId enterprise_account_id_ =
       AccountId::FromUserEmail(kEnterpriseUser1);
   const cryptohome::Identification cryptohome_id_ =
       cryptohome::Identification(enterprise_account_id_);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UserImageManagerTest);
@@ skipping 86 matching lines @@
       user_manager::UserImage::CreateAndEncode(custom_image));
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(custom_image, user->GetImage()));
   ExpectUserImageInfo(test_account_id1_,
                       user_manager::User::USER_IMAGE_EXTERNAL,
                       GetUserImagePath(test_account_id1_, "jpg"));
 
-  const scoped_ptr<gfx::ImageSkia> saved_image =
+  const std::unique_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(test_account_id1_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(custom_image.width(), saved_image->width());
   EXPECT_EQ(custom_image.height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_SaveUserImageFromFile) {
   RegisterUser(test_account_id1_.GetUserEmail());
 }
 
 // Verifies that SaveUserImageFromFile() correctly sets and persists the chosen
 // user image.
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, SaveUserImageFromFile) {
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(test_account_id1_);
   ASSERT_TRUE(user);
 
   const base::FilePath custom_image_path =
       test_data_dir_.Append(test::kUserAvatarImage1RelativePath);
-  const scoped_ptr<gfx::ImageSkia> custom_image =
+  const std::unique_ptr<gfx::ImageSkia> custom_image =
       test::ImageLoader(custom_image_path).Load();
   ASSERT_TRUE(custom_image);
 
   run_loop_.reset(new base::RunLoop);
   UserImageManager* user_image_manager =
       ChromeUserManager::Get()->GetUserImageManager(test_account_id1_);
   user_image_manager->SaveUserImageFromFile(custom_image_path);
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*custom_image, user->GetImage()));
   ExpectUserImageInfo(test_account_id1_,
                       user_manager::User::USER_IMAGE_EXTERNAL,
                       GetUserImagePath(test_account_id1_, "jpg"));
 
-  const scoped_ptr<gfx::ImageSkia> saved_image =
+  const std::unique_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(test_account_id1_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(custom_image->width(), saved_image->width());
   EXPECT_EQ(custom_image->height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest,
                        PRE_SaveUserImageFromProfileImage) {
@@ skipping 25 matching lines @@
 
   const gfx::ImageSkia& profile_image =
       user_image_manager->DownloadedProfileImage();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_PROFILE, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(profile_image, user->GetImage()));
   ExpectUserImageInfo(test_account_id1_, user_manager::User::USER_IMAGE_PROFILE,
                       GetUserImagePath(test_account_id1_, "jpg"));
 
-  const scoped_ptr<gfx::ImageSkia> saved_image =
+  const std::unique_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(test_account_id1_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(profile_image.width(), saved_image->width());
   EXPECT_EQ(profile_image.height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest,
                        PRE_ProfileImageDownloadDoesNotClobber) {
@@ skipping 44 matching lines @@
 class UserImageManagerPolicyTest : public UserImageManagerTest,
                                    public policy::CloudPolicyStore::Observer {
  protected:
   UserImageManagerPolicyTest()
       : fake_session_manager_client_(new chromeos::FakeSessionManagerClient) {
   }
 
   // UserImageManagerTest overrides:
   void SetUpInProcessBrowserTestFixture() override {
     DBusThreadManager::GetSetterForTesting()->SetSessionManagerClient(
-        scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
+        std::unique_ptr<SessionManagerClient>(fake_session_manager_client_));
     UserImageManagerTest::SetUpInProcessBrowserTestFixture();
   }
 
   void SetUpOnMainThread() override {
     UserImageManagerTest::SetUpOnMainThread();
 
     base::FilePath user_keys_dir;
     ASSERT_TRUE(PathService::Get(chromeos::DIR_USER_POLICY_KEYS,
                                  &user_keys_dir));
     const std::string sanitized_username =
@@ skipping 40 matching lines @@
                                     ->GetURL(std::string("/") + relative_path)
                                     .spec(),
                                 image_data),
                             &policy);
     return policy;
   }
 
   policy::UserPolicyBuilder user_policy_;
   FakeSessionManagerClient* fake_session_manager_client_;
 
-  scoped_ptr<gfx::ImageSkia> policy_image_;
+  std::unique_ptr<gfx::ImageSkia> policy_image_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UserImageManagerPolicyTest);
 };
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest, PRE_SetAndClear) {
   RegisterUser(enterprise_account_id_.GetUserEmail());
   chromeos::StartupUtils::MarkOobeCompleted();
 }
 
@@ skipping 23 matching lines @@
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectUserImageInfo(enterprise_account_id_,
                       user_manager::User::USER_IMAGE_EXTERNAL,
                       GetUserImagePath(enterprise_account_id_, "jpg"));
 
-  scoped_ptr<gfx::ImageSkia> saved_image =
+  std::unique_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(enterprise_account_id_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 
   // Clear policy. Verify that the user image switches to a random default
   // image.
   user_policy_.payload().Clear();
@@ skipping 86 matching lines @@
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectUserImageInfo(enterprise_account_id_,
                       user_manager::User::USER_IMAGE_EXTERNAL,
                       GetUserImagePath(enterprise_account_id_, "jpg"));
 
-  scoped_ptr<gfx::ImageSkia> saved_image =
+  std::unique_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(enterprise_account_id_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerPolicyTest,
                        PRE_UserDoesNotOverridePolicy) {
@@ skipping 26 matching lines @@
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectUserImageInfo(enterprise_account_id_,
                       user_manager::User::USER_IMAGE_EXTERNAL,
                       GetUserImagePath(enterprise_account_id_, "jpg"));
 
-  scoped_ptr<gfx::ImageSkia> saved_image =
+  std::unique_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(enterprise_account_id_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 
   // Choose a different user image. Verify that the user image does not change
   // as policy takes precedence.
   UserImageManager* user_image_manager =
@@ skipping 11 matching lines @@
   saved_image =
       test::ImageLoader(GetUserImagePath(enterprise_account_id_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 }
 
 }  // namespace chromeos