Crop the user-specified profile image for WebUI

chrome/browser/chromeos/login/users/avatar/user_image_loader.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_loader.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 67 matching lines @@
       : image_info_(image_info),
         image_data_(image_data.begin(), image_data.end()),
         background_task_runner_(background_task_runner),
         weak_ptr_factory_(this) {}
   ~UserImageRequest() override {}
 
   // ImageDecoder::ImageRequest implementation.
   void OnImageDecoded(const SkBitmap& decoded_image) override;
   void OnDecodeImageFailed() override;
 
-  // Called after the image is transformed (cropped and downsized) as needed.
-  void OnImageFinalized(const SkBitmap& image);
+  // Called after the image is cropped (and downsized) as needed.
+  void OnImageCropped(const SkBitmap& image);
+
+  // Called after the image is finalized. |image_bytes_regenerated| is true
+  // if |image_bytes| is regenerated from the cropped image.
+  void OnImageFinalized(const SkBitmap& image,
+                        bool image_bytes_regenerated,
+                        const user_manager::UserImage::Bytes& image_bytes);
 
  private:
   const ImageInfo image_info_;
   const user_manager::UserImage::Bytes image_data_;
   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
 
   // This should be the last member.
   base::WeakPtrFactory<UserImageRequest> weak_ptr_factory_;
 };
 
 void UserImageRequest::OnImageDecoded(const SkBitmap& decoded_image) {
   int target_size = image_info_.pixels_per_side;
   if (target_size > 0) {
-    // Transforming an image could be expensive, hence posting to the
-    // background thread.
+    // Cropping an image could be expensive, hence posting to the background
+    // thread.
     base::PostTaskAndReplyWithResult(
         background_task_runner_.get(), FROM_HERE,
         base::Bind(&CropImage, decoded_image, target_size),
-        base::Bind(&UserImageRequest::OnImageFinalized,
+        base::Bind(&UserImageRequest::OnImageCropped,
                    weak_ptr_factory_.GetWeakPtr()));
   } else {
-    OnImageFinalized(decoded_image);
+    OnImageFinalized(decoded_image, false /* image_bytes_regenerated */,
+                     image_data_);
   }
 }
 
-void UserImageRequest::OnImageFinalized(const SkBitmap& image) {
+void UserImageRequest::OnImageCropped(const SkBitmap& image) {
+  DCHECK_GT(image_info_.pixels_per_side, 0);
+
+  // Encode the cropped image to web-compatible bytes representation, because
+  // the original data in |image_data_| isn't cropped and can be big.
+  // Encoding could be expensive, hence posting to the background thread.
+  base::PostTaskAndReplyWithResult(
+      background_task_runner_.get(), FROM_HERE,
+      base::Bind(&user_manager::UserImage::Encode, image),

[hashimoto, 2016/03/02 07:33:58]

Why don't you call Encode() from CropImage()?
IIUC there is no need to encode the image when pixels_per_side <= target_size.

[satorux1, 2016/03/02 08:23:50]

That's a great point. Fixed!

+      base::Bind(&UserImageRequest::OnImageFinalized,
+                 weak_ptr_factory_.GetWeakPtr(), image,
+                 true /* image_bytes_regenerated */));
+}
+
+void UserImageRequest::OnImageFinalized(
+    const SkBitmap& image,
+    bool image_bytes_regenerated,
+    const user_manager::UserImage::Bytes& image_bytes) {
+  if (image_bytes.empty()) {  // Failed to encode to bytes.
+    OnDecodeImageFailed();
+    return;
+  }
+
   SkBitmap final_image = image;
   // Make the SkBitmap immutable as we won't modify it. This is important
   // because otherwise it gets duplicated during painting, wasting memory.
   final_image.setImmutable();
   gfx::ImageSkia final_image_skia =
       gfx::ImageSkia::CreateFrom1xBitmap(final_image);
   final_image_skia.MakeThreadSafe();
-  user_manager::UserImage user_image(final_image_skia, image_data_);
+  user_manager::UserImage user_image(final_image_skia, image_bytes);
   user_image.set_file_path(image_info_.file_path);
-  if (image_info_.image_codec == ImageDecoder::ROBUST_JPEG_CODEC)
+  if (image_info_.image_codec == ImageDecoder::ROBUST_JPEG_CODEC ||
+      image_bytes_regenerated)
     user_image.MarkAsSafe();
   image_info_.loaded_cb.Run(user_image);
   delete this;
 }
 
 void UserImageRequest::OnDecodeImageFailed() {
   image_info_.loaded_cb.Run(user_manager::UserImage());
   delete this;
 }
 
@@ skipping 39 matching lines @@
     ImageDecoder::ImageCodec image_codec,
     int pixels_per_side,
     const LoadedCallback& loaded_cb) {
   DecodeImage(
       ImageInfo(base::FilePath(), pixels_per_side, image_codec, loaded_cb),
       background_task_runner, data.get(), true /* data_is_ready */);
 }
 
 }  // namespace user_image_loader
 }  // namespace chromeos