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

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 <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/chromeos/login/helper.h"
 #include "components/user_manager/user_image/user_image.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/skbitmap_operations.h"
@@ skipping 39 matching lines @@
   if (pixels_per_side > target_size) {
     // Also downsize the image to save space and memory.
     final_image = skia::ImageOperations::Resize(
         cropped_image, skia::ImageOperations::RESIZE_LANCZOS3, target_size,
         target_size);
   } else {
     final_image = cropped_image;
   }
 
   // Encode the cropped image to web-compatible bytes representation
-  scoped_ptr<user_manager::UserImage::Bytes> encoded =
+  std::unique_ptr<user_manager::UserImage::Bytes> encoded =
       user_manager::UserImage::Encode(final_image);
   if (!encoded)
     return false;
 
   bitmap->swap(final_image);
   bytes->swap(*encoded);
   return true;
 }
 
 // Handles the decoded image returned from ImageDecoder through the
@@ skipping 69 matching lines @@
     const SkBitmap& image,
     const user_manager::UserImage::Bytes& image_bytes,
     bool image_bytes_regenerated) {
   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();
-  scoped_ptr<user_manager::UserImage> user_image(
+  std::unique_ptr<user_manager::UserImage> user_image(
       new user_manager::UserImage(final_image_skia, image_bytes));
   user_image->set_file_path(image_info_.file_path);
   if (image_info_.image_codec == ImageDecoder::ROBUST_JPEG_CODEC ||
       image_bytes_regenerated)
     user_image->MarkAsSafe();
   image_info_.loaded_cb.Run(std::move(user_image));
   delete this;
 }
 
 void UserImageRequest::OnDecodeImageFailed() {
-  image_info_.loaded_cb.Run(make_scoped_ptr(new user_manager::UserImage));
+  image_info_.loaded_cb.Run(base::WrapUnique(new user_manager::UserImage));
   delete this;
 }
 
 // Starts decoding the image with ImageDecoder for the image |data| if
 // |data_is_ready| is true.
 void DecodeImage(
     const ImageInfo& image_info,
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
     const std::string* data,
     bool data_is_ready) {
   if (!data_is_ready) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(image_info.loaded_cb,
-                   base::Passed(make_scoped_ptr(new user_manager::UserImage))));
+        base::Bind(image_info.loaded_cb, base::Passed(base::WrapUnique(
+                                             new user_manager::UserImage))));
     return;
   }
 
   UserImageRequest* image_request =
       new UserImageRequest(image_info, *data, background_task_runner);
   ImageDecoder::StartWithOptions(image_request, *data, image_info.image_codec,
                                  false);
 }
 
 }  // namespace
 
 void StartWithFilePath(
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
     const base::FilePath& file_path,
     ImageDecoder::ImageCodec image_codec,
     int pixels_per_side,
     const LoadedCallback& loaded_cb) {
   std::string* data = new std::string;
   base::PostTaskAndReplyWithResult(
       background_task_runner.get(), FROM_HERE,
       base::Bind(&base::ReadFileToString, file_path, data),
       base::Bind(&DecodeImage,
                  ImageInfo(file_path, pixels_per_side, image_codec, loaded_cb),
                  background_task_runner, base::Owned(data)));
 }
 
 void StartWithData(
     scoped_refptr<base::SequencedTaskRunner> background_task_runner,
-    scoped_ptr<std::string> data,
+    std::unique_ptr<std::string> data,
     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