Use base::RefCountedBytes in user_manager::UserImage

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>
 
@@ skipping 131 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(std::unique_ptr<user_manager::UserImage::Bytes> image_bytes,
+bool SaveImage(scoped_refptr<base::RefCountedBytes> image_bytes,
                const base::FilePath& image_path) {
-  if (image_bytes->empty() ||
+  if (image_bytes->size() == 0 ||
       base::WriteFile(image_path,
-                      reinterpret_cast<const char*>(image_bytes->data()),
+                      reinterpret_cast<const char*>(image_bytes->front()),
                       image_bytes->size()) == -1) {
     LOG(ERROR) << "Failed to save image to file.";
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
@@ skipping 63 matching lines @@
 
   // Updates the user object with |user_image|, and saves the image
   // bytes. Local state will be updated as needed.
   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,
-      std::unique_ptr<user_manager::UserImage::Bytes> image_bytes);
+      scoped_refptr<base::RefCountedBytes> 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 163 matching lines @@
                 IDR_PROFILE_PICTURE_LOADING)),
         image_index_, false);
   }
   user->SetImageURL(image_url_);
 
   parent_->OnJobChangedUserImage();
 }
 
 void UserImageManagerImpl::Job::UpdateUserAndSaveImage(
     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();
-  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()));
-  }
+  // Create a reference before user_image is passed.
+  scoped_refptr<base::RefCountedBytes> image_bytes;
+  if (image_is_safe_format)
+    image_bytes = user_image->image_bytes();
 
   UpdateUser(std::move(user_image));
 
-  SaveImageAndUpdateLocalState(image_is_safe_format, std::move(copied_bytes));
+  SaveImageAndUpdateLocalState(image_is_safe_format, image_bytes);
 }
 
 void UserImageManagerImpl::Job::SaveImageAndUpdateLocalState(
     bool image_is_safe_format,
-    std::unique_ptr<user_manager::UserImage::Bytes> image_bytes) {
+    scoped_refptr<base::RefCountedBytes> 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.
   // 3) Profile image from policy (via OnExternalDataFetched()) -> JPEG is
   //    only allowed and ROBUST_JPEG_CODEC is used.
   //
   // However, check the value just in case because an unsafe image should
   // never be saved.
   if (!image_is_safe_format) {
     LOG(ERROR) << "User image is not in safe format";
     OnSaveImageDone(false);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       parent_->background_task_runner_.get(), FROM_HERE,
-      base::Bind(&SaveImage, base::Passed(std::move(image_bytes)), image_path_),
+      base::Bind(&SaveImage, image_bytes, image_path_),
       base::Bind(&Job::OnSaveImageDone, weak_factory_.GetWeakPtr()));
 }
 
 void UserImageManagerImpl::Job::OnSaveImageDone(bool success) {
   if (success || image_index_ == user_manager::User::USER_IMAGE_PROFILE)
     UpdateLocalState();
   NotifyJobDone();
 }
 
 void UserImageManagerImpl::Job::UpdateLocalState() {
@@ skipping 485 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