Convert //cc from scoped_ptr to std::unique_ptr.

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 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 "cc/tiles/software_image_decode_controller.h"
 
 #include <stdint.h>
 
 #include <functional>
 
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
+#include "base/memory/ptr_util.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/raster/tile_task_runner.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 namespace {
 
 // The amount of memory we can lock ahead of time (128MB). This limit is only
@@ skipping 301 matching lines @@
     return;
   }
 
   auto image_it = decoded_images_.Peek(key);
   if (image_it != decoded_images_.end()) {
     if (image_it->second->is_locked() || image_it->second->Lock())
       return;
     decoded_images_.Erase(image_it);
   }
 
-  scoped_ptr<DecodedImage> decoded_image;
+  std::unique_ptr<DecodedImage> decoded_image;
   {
     base::AutoUnlock unlock(lock_);
     decoded_image = DecodeImageInternal(key, image);
   }
 
   // Abort if we failed to decode the image.
   if (!decoded_image)
     return;
 
   // At this point, it could have been the case that this image was decoded in
@@ skipping 15 matching lines @@
   // ref counts. Unlock it immediately in this case.
   if (decoded_images_ref_counts_.find(key) ==
       decoded_images_ref_counts_.end()) {
     decoded_image->Unlock();
   }
 
   decoded_images_.Put(key, std::move(decoded_image));
   SanityCheckState(__LINE__, true);
 }
 
-scoped_ptr<SoftwareImageDecodeController::DecodedImage>
+std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
 SoftwareImageDecodeController::DecodeImageInternal(
     const ImageKey& key,
     const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::DecodeImageInternal", "key",
                key.ToString());
   const SkImage* image = draw_image.image();
 
   // If we can use the original decode, then we don't need to do scaling. We can
   // just read pixels into the final memory.
   if (key.can_use_original_decode()) {
     SkImageInfo decoded_info =
         CreateImageInfo(image->width(), image->height(), format_);
-    scoped_ptr<base::DiscardableMemory> decoded_pixels;
+    std::unique_ptr<base::DiscardableMemory> decoded_pixels;
     {
       TRACE_EVENT0(
           "disabled-by-default-cc.debug",
           "SoftwareImageDecodeController::DecodeImageInternal - allocate "
           "decoded pixels");
       decoded_pixels =
           base::DiscardableMemoryAllocator::GetInstance()
               ->AllocateLockedDiscardableMemory(decoded_info.minRowBytes() *
                                                 decoded_info.height());
     }
     {
       TRACE_EVENT0(
           "disabled-by-default-cc.debug",
           "SoftwareImageDecodeController::DecodeImageInternal - read pixels");
       bool result = image->readPixels(decoded_info, decoded_pixels->data(),
                                       decoded_info.minRowBytes(), 0, 0,
                                       SkImage::kDisallow_CachingHint);
 
       if (!result) {
         decoded_pixels->Unlock();
         return nullptr;
       }
     }
 
-    return make_scoped_ptr(new DecodedImage(
+    return base::WrapUnique(new DecodedImage(
         decoded_info, std::move(decoded_pixels), SkSize::Make(0, 0)));
   }
 
   // If we get here, that means we couldn't use the original sized decode for
   // whatever reason. However, in all cases we do need an original decode to
   // either do a scale or to extract a subrect from the image. So, what we can
   // do is construct a key that would require a full sized decode, then get that
   // decode via GetDecodedImageForDrawInternal(), use it, and unref it. This
   // ensures that if the original sized decode is already available in any of
   // the caches, we reuse that. We also ensure that all the proper locking takes
@@ skipping 25 matching lines @@
     result = decoded_pixmap.extractSubset(&decoded_pixmap,
                                           gfx::RectToSkIRect(key.src_rect()));
     DCHECK(result) << key.ToString();
   }
 
   // Now we have a decoded_pixmap which represents the src_rect at the
   // original scale. All we need to do is scale it.
   DCHECK(!key.target_size().IsEmpty());
   SkImageInfo scaled_info = CreateImageInfo(
       key.target_size().width(), key.target_size().height(), format_);
-  scoped_ptr<base::DiscardableMemory> scaled_pixels;
+  std::unique_ptr<base::DiscardableMemory> scaled_pixels;
   {
     TRACE_EVENT0(
         "disabled-by-default-cc.debug",
         "SoftwareImageDecodeController::DecodeImageInternal - allocate "
         "scaled pixels");
     scaled_pixels = base::DiscardableMemoryAllocator::GetInstance()
                         ->AllocateLockedDiscardableMemory(
                             scaled_info.minRowBytes() * scaled_info.height());
   }
   SkPixmap scaled_pixmap(scaled_info, scaled_pixels->data(),
                          scaled_info.minRowBytes());
   // TODO(vmpstr): Start handling more than just high filter quality.
   DCHECK_EQ(kHigh_SkFilterQuality, key.filter_quality());
   {
     TRACE_EVENT0(
         "disabled-by-default-cc.debug",
         "SoftwareImageDecodeController::DecodeImageInternal - scale pixels");
     bool result =
         decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
     DCHECK(result) << key.ToString();
   }
 
   // Release the original sized decode. Any other intermediate result to release
   // would be the subrect memory. However, that's in a scoped_ptr and will be
   // deleted automatically when we return.
   DrawWithImageFinished(original_size_draw_image, decoded_draw_image);
 
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new DecodedImage(scaled_info, std::move(scaled_pixels),
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y())));
 }
 
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDraw", "key",
                key.ToString());
@@ skipping 10 matching lines @@
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDrawInternal(
     const ImageKey& key,
     const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDrawInternal",
                "key", key.ToString());
   base::AutoLock lock(lock_);
   auto decoded_images_it = decoded_images_.Get(key);
   // If we found the image and it's locked, then return it. If it's not locked,
   // erase it from the cache since it might be put into the at-raster cache.
-  scoped_ptr<DecodedImage> scoped_decoded_image;
+  std::unique_ptr<DecodedImage> scoped_decoded_image;
   DecodedImage* decoded_image = nullptr;
   if (decoded_images_it != decoded_images_.end()) {
     decoded_image = decoded_images_it->second.get();
     if (decoded_image->is_locked()) {
       RefImage(key);
       SanityCheckState(__LINE__, true);
       return DecodedDrawImage(
           decoded_image->image(), decoded_image->src_rect_offset(),
           GetScaleAdjustment(key), GetDecodedFilterQuality(key));
     } else {
@@ skipping 307 matching lines @@
       << "] target_size[" << target_size_.width() << "x"
       << target_size_.height() << "] filter_quality[" << filter_quality_
       << "] can_use_original_decode [" << can_use_original_decode_ << "] hash ["
       << hash_ << "]";
   return str.str();
 }
 
 // DecodedImage
 SoftwareImageDecodeController::DecodedImage::DecodedImage(
     const SkImageInfo& info,
-    scoped_ptr<base::DiscardableMemory> memory,
+    std::unique_ptr<base::DiscardableMemory> memory,
     const SkSize& src_rect_offset)
     : locked_(true),
       image_info_(info),
       memory_(std::move(memory)),
       src_rect_offset_(src_rect_offset) {
   image_ = skia::AdoptRef(SkImage::NewFromRaster(
       image_info_, memory_->data(), image_info_.minRowBytes(),
       [](const void* pixels, void* context) {}, nullptr));
 }
 
@@ skipping 38 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc