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

chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.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_impl.h"
 
 #include <stddef.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 116 matching lines @@
     case user_manager::User::USER_IMAGE_EXTERNAL:
       // TODO(ivankr): Distinguish this from selected from file.
       return default_user_image::kHistogramImageFromCamera;
     case user_manager::User::USER_IMAGE_PROFILE:
       return default_user_image::kHistogramImageFromProfile;
     default:
       return image_index;
   }
 }
 
-bool SaveImage(scoped_ptr<user_manager::UserImage::Bytes> image_bytes,
+bool SaveImage(std::unique_ptr<user_manager::UserImage::Bytes> image_bytes,
                const base::FilePath& image_path) {
   if (image_bytes->empty() ||
       base::WriteFile(image_path,
                       reinterpret_cast<const char*>(image_bytes->data()),
                       image_bytes->size()) == -1) {
     LOG(ERROR) << "Failed to save image to file.";
     return false;
   }
 
   return true;
@@ skipping 33 matching lines @@
                  const GURL& image_url);
 
   // Sets the user image in local state to the default image indicated
   // by |default_image_index|. Also updates the user object with the
   // new image.
   void SetToDefaultImage(int default_image_index);
 
   // Saves the |user_image| to disk and sets the user image in local
   // state to that image. Also updates the user with the new image.
   void SetToImage(int image_index,
-                  scoped_ptr<user_manager::UserImage> user_image);
+                  std::unique_ptr<user_manager::UserImage> user_image);
 
   // Decodes the JPEG image |data|, crops and resizes the image, saves
   // it to disk and sets the user image in local state to that image.
   // Also updates the user object with the new image.
-  void SetToImageData(scoped_ptr<std::string> data);
+  void SetToImageData(std::unique_ptr<std::string> data);
 
   // Loads the image at |path|, transcodes it to JPEG format, saves
   // the image to disk and sets the user image in local state to that
   // image.  If |resize| is true, the image is cropped and resized
   // before transcoding.  Also updates the user object with the new
   // image.
   void SetToPath(const base::FilePath& path,
                  int image_index,
                  const GURL& image_url,
                  bool resize);
 
  private:
   // Called back after an image has been loaded from disk.
   void OnLoadImageDone(bool save,
-                       scoped_ptr<user_manager::UserImage> user_image);
+                       std::unique_ptr<user_manager::UserImage> user_image);
 
   // Updates the user object with |user_image|.
-  void UpdateUser(scoped_ptr<user_manager::UserImage> user_image);
+  void UpdateUser(std::unique_ptr<user_manager::UserImage> user_image);
 
   // Updates the user object with |user_image|, and saves the image
   // bytes. Local state will be updated as needed.
-  void UpdateUserAndSaveImage(scoped_ptr<user_manager::UserImage> user_image);
+  void UpdateUserAndSaveImage(
+      std::unique_ptr<user_manager::UserImage> user_image);
 
   // Saves |image_bytes| to disk in JPEG format if
   // |image_is_safe_format|. Local state will be updated as needed.
   void SaveImageAndUpdateLocalState(
       bool image_is_safe_format,
-      scoped_ptr<user_manager::UserImage::Bytes> image_bytes);
+      std::unique_ptr<user_manager::UserImage::Bytes> image_bytes);
 
   // Called back after the user image has been saved to
   // disk. Updates the user image information in local state. The
   // information is only updated if |success| is true (indicating that
   // the image was saved successfully) or the user image is the
   // profile image (indicating that even if the image could not be
   // saved because it is not available right now, it will be
   // downloaded eventually).
   void OnSaveImageDone(bool success);
 
@@ skipping 36 matching lines @@
   DCHECK(!run_);
   run_ = true;
 
   image_index_ = image_index;
   image_url_ = image_url;
   image_path_ = image_path;
 
   if (image_index_ >= 0 &&
       image_index_ < default_user_image::kDefaultImagesCount) {
     // Load one of the default images. This happens synchronously.
-    scoped_ptr<user_manager::UserImage> user_image(new user_manager::UserImage(
-        default_user_image::GetDefaultImage(image_index_)));
+    std::unique_ptr<user_manager::UserImage> user_image(
+        new user_manager::UserImage(
+            default_user_image::GetDefaultImage(image_index_)));
     UpdateUser(std::move(user_image));
     NotifyJobDone();
   } else if (image_index_ == user_manager::User::USER_IMAGE_EXTERNAL ||
              image_index_ == user_manager::User::USER_IMAGE_PROFILE) {
     // Load the user image from a file referenced by |image_path|. This happens
     // asynchronously. ROBUST_JPEG_CODEC can be used here because
     // LoadImage() is called only for users whose user image has previously
     // been set by one of the Set*() methods, which transcode to JPEG format.
     DCHECK(!image_path_.empty());
     user_image_loader::StartWithFilePath(
         parent_->background_task_runner_, image_path_,
         ImageDecoder::ROBUST_JPEG_CODEC,
         0,  // Do not crop.
         base::Bind(&Job::OnLoadImageDone, weak_factory_.GetWeakPtr(), false));
   } else {
     NOTREACHED();
     NotifyJobDone();
   }
 }
 
 void UserImageManagerImpl::Job::SetToDefaultImage(int default_image_index) {
   DCHECK(!run_);
   run_ = true;
 
   DCHECK_LE(0, default_image_index);
   DCHECK_GT(default_user_image::kDefaultImagesCount, default_image_index);
 
   image_index_ = default_image_index;
-  scoped_ptr<user_manager::UserImage> user_image(new user_manager::UserImage(
-      default_user_image::GetDefaultImage(image_index_)));
+  std::unique_ptr<user_manager::UserImage> user_image(
+      new user_manager::UserImage(
+          default_user_image::GetDefaultImage(image_index_)));
 
   UpdateUser(std::move(user_image));
   UpdateLocalState();
   NotifyJobDone();
 }
 
 void UserImageManagerImpl::Job::SetToImage(
     int image_index,
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   DCHECK(!run_);
   run_ = true;
 
   DCHECK(image_index == user_manager::User::USER_IMAGE_EXTERNAL ||
          image_index == user_manager::User::USER_IMAGE_PROFILE);
 
   image_index_ = image_index;
 
   UpdateUserAndSaveImage(std::move(user_image));
 }
 
-void UserImageManagerImpl::Job::SetToImageData(scoped_ptr<std::string> data) {
+void UserImageManagerImpl::Job::SetToImageData(
+    std::unique_ptr<std::string> data) {
   DCHECK(!run_);
   run_ = true;
 
   image_index_ = user_manager::User::USER_IMAGE_EXTERNAL;
 
   // This method uses ROBUST_JPEG_CODEC, not DEFAULT_CODEC:
   // * This is necessary because the method is used to update the user image
   //   whenever the policy for a user is set. In the case of device-local
   //   accounts, policy may change at any time, even if the user is not
   //   currently logged in (and thus, DEFAULT_CODEC may not be used).
@@ skipping 20 matching lines @@
 
   DCHECK(!path.empty());
   user_image_loader::StartWithFilePath(
       parent_->background_task_runner_, path, ImageDecoder::DEFAULT_CODEC,
       resize ? login::kMaxUserImageSize : 0,
       base::Bind(&Job::OnLoadImageDone, weak_factory_.GetWeakPtr(), true));
 }
 
 void UserImageManagerImpl::Job::OnLoadImageDone(
     bool save,
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   if (save) {
     UpdateUserAndSaveImage(std::move(user_image));
   } else {
     UpdateUser(std::move(user_image));
     NotifyJobDone();
   }
 }
 
 void UserImageManagerImpl::Job::UpdateUser(
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   user_manager::User* user = parent_->GetUserAndModify();
   if (!user)
     return;
 
   if (!user_image->image().isNull()) {
     user->SetImage(std::move(user_image), image_index_);
   } else {
     user->SetStubImage(
-        make_scoped_ptr(new user_manager::UserImage(
+        base::WrapUnique(new user_manager::UserImage(
             *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
                 IDR_PROFILE_PICTURE_LOADING))),
         image_index_, false);
   }
   user->SetImageURL(image_url_);
 
   parent_->OnJobChangedUserImage();
 }
 
 void UserImageManagerImpl::Job::UpdateUserAndSaveImage(
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   // TODO(crbug.com/593251): Remove the data copy.
   // Copy the image bytes, before the user image is passed to
   // UpdateUser(). This is needed to safely save the data bytes to the disk
   // in the blocking pool. Copying is not desirable but the user image is
   // JPEG data of 512x512 pixels (usually <100KB) hence it's not enormous.
   const bool image_is_safe_format = user_image->is_safe_format();
-  scoped_ptr<user_manager::UserImage::Bytes> copied_bytes;
+  std::unique_ptr<user_manager::UserImage::Bytes> copied_bytes;
   if (image_is_safe_format) {
     copied_bytes.reset(
         new user_manager::UserImage::Bytes(user_image->image_bytes()));
   }
 
   UpdateUser(std::move(user_image));
 
   SaveImageAndUpdateLocalState(image_is_safe_format, std::move(copied_bytes));
 }
 
 void UserImageManagerImpl::Job::SaveImageAndUpdateLocalState(
     bool image_is_safe_format,
-    scoped_ptr<user_manager::UserImage::Bytes> image_bytes) {
+    std::unique_ptr<user_manager::UserImage::Bytes> image_bytes) {
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   image_path_ = user_data_dir.Append(user_id() + kSafeImagePathExtension);
 
   // This should always be true, because of the following reasons:
   //
   // 1) Profile image from Google account -> UserImage is created with
   //    CreateAndEncode() that generates safe bytes representation.
   // 2) Profile image from user-specified image -> The bytes representation
   //    is regenerated after the original image is decoded and cropped.
@@ skipping 20 matching lines @@
   NotifyJobDone();
 }
 
 void UserImageManagerImpl::Job::UpdateLocalState() {
   // Ignore if data stored or cached outside the user's cryptohome is to be
   // treated as ephemeral.
   if (parent_->user_manager_->IsUserNonCryptohomeDataEphemeral(
           AccountId::FromUserEmail(user_id())))
     return;
 
-  scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
   entry->Set(kImagePathNodeName, new base::StringValue(image_path_.value()));
   entry->Set(kImageIndexNodeName, new base::FundamentalValue(image_index_));
   if (!image_url_.is_empty())
     entry->Set(kImageURLNodeName, new base::StringValue(image_url_.spec()));
   DictionaryPrefUpdate update(g_browser_process->local_state(),
                               kUserImageProperties);
   update->SetWithoutPathExpansion(user_id(), entry.release());
 
   parent_->user_manager_->NotifyLocalStateChanged();
 }
@@ skipping 40 matching lines @@
 
   if (!image_properties) {
     SetInitialUserImage();
     return;
   }
 
   int image_index = user_manager::User::USER_IMAGE_INVALID;
   image_properties->GetInteger(kImageIndexNodeName, &image_index);
   if (image_index >= 0 &&
       image_index < default_user_image::kDefaultImagesCount) {
-    user->SetImage(make_scoped_ptr(new user_manager::UserImage(
+    user->SetImage(base::WrapUnique(new user_manager::UserImage(
                        default_user_image::GetDefaultImage(image_index))),
                    image_index);
     return;
   }
 
   if (image_index != user_manager::User::USER_IMAGE_EXTERNAL &&
       image_index != user_manager::User::USER_IMAGE_PROFILE) {
     NOTREACHED();
     return;
   }
 
   std::string image_url_string;
   image_properties->GetString(kImageURLNodeName, &image_url_string);
   GURL image_url(image_url_string);
   std::string image_path;
   image_properties->GetString(kImagePathNodeName, &image_path);
 
   user->SetImageURL(image_url);
-  user->SetStubImage(make_scoped_ptr(new user_manager::UserImage(
+  user->SetStubImage(base::WrapUnique(new user_manager::UserImage(
                          *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
                              IDR_PROFILE_PICTURE_LOADING))),
                      image_index, true);
   DCHECK(!image_path.empty() ||
          image_index == user_manager::User::USER_IMAGE_PROFILE);
   if (image_path.empty()) {
     // Return if the profile image is to be used but has not been downloaded
     // yet. The profile image will be downloaded after login.
     return;
   }
@@ skipping 51 matching lines @@
 }
 
 void UserImageManagerImpl::SaveUserDefaultImageIndex(int default_image_index) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
   job_->SetToDefaultImage(default_image_index);
 }
 
 void UserImageManagerImpl::SaveUserImage(
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
   job_->SetToImage(user_manager::User::USER_IMAGE_EXTERNAL,
                    std::move(user_image));
 }
 
 void UserImageManagerImpl::SaveUserImageFromFile(const base::FilePath& path) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
   job_->SetToPath(path, user_manager::User::USER_IMAGE_EXTERNAL, GURL(), true);
 }
 
 void UserImageManagerImpl::SaveUserImageFromProfileImage() {
   if (IsUserImageManaged())
     return;
   // Use the profile image if it has been downloaded already. Otherwise, use a
   // stub image (gray avatar).
   job_.reset(new Job(this));
   job_->SetToImage(user_manager::User::USER_IMAGE_PROFILE,
                    downloaded_profile_image_.isNull()
-                       ? make_scoped_ptr(new user_manager::UserImage)
+                       ? base::WrapUnique(new user_manager::UserImage)
                        : user_manager::UserImage::CreateAndEncode(
                              downloaded_profile_image_));
   // If no profile image has been downloaded yet, ensure that a download is
   // started.
   if (downloaded_profile_image_.isNull())
     DownloadProfileData(kProfileDownloadReasonProfileImageChosen);
 }
 
 void UserImageManagerImpl::DeleteUserImage() {
   job_.reset();
@@ skipping 33 matching lines @@
     user_image_sync_observer_.reset();
 }
 
 void UserImageManagerImpl::OnExternalDataCleared(const std::string& policy) {
   DCHECK_EQ(policy::key::kUserAvatarImage, policy);
   has_managed_image_ = false;
   SetInitialUserImage();
   TryToCreateImageSyncObserver();
 }
 
-void UserImageManagerImpl::OnExternalDataFetched(const std::string& policy,
-                                                 scoped_ptr<std::string> data) {
+void UserImageManagerImpl::OnExternalDataFetched(
+    const std::string& policy,
+    std::unique_ptr<std::string> data) {
   DCHECK_EQ(policy::key::kUserAvatarImage, policy);
   DCHECK(IsUserImageManaged());
   if (data) {
     job_.reset(new Job(this));
     job_->SetToImageData(std::move(data));
   }
 }
 
 // static
 void UserImageManagerImpl::IgnoreProfileDataDownloadDelayForTesting() {
@@ skipping 16 matching lines @@
   return profile_image_url_.spec();
 }
 
 bool UserImageManagerImpl::IsPreSignin() const {
   return false;
 }
 
 void UserImageManagerImpl::OnProfileDownloadSuccess(
     ProfileDownloader* downloader) {
   // Ensure that the |profile_downloader_| is deleted when this method returns.
-  scoped_ptr<ProfileDownloader> profile_downloader(
+  std::unique_ptr<ProfileDownloader> profile_downloader(
       profile_downloader_.release());
   DCHECK_EQ(downloader, profile_downloader.get());
 
   user_manager_->UpdateUserAccountData(
       AccountId::FromUserEmail(user_id()),
       user_manager::UserManager::UserAccountData(
           downloader->GetProfileFullName(), downloader->GetProfileGivenName(),
           downloader->GetProfileLocale()));
   if (!downloading_profile_image_)
     return;
@@ skipping 200 matching lines @@
 }
 
 bool UserImageManagerImpl::IsUserLoggedInAndHasGaiaAccount() const {
   const user_manager::User* user = GetUser();
   if (!user)
     return false;
   return user->is_logged_in() && user->HasGaiaAccount();
 }
 
 }  // namespace chromeos