Replace many skia::RefPtr with sk_sp<> in cc/

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>
 
@@ skipping 45 matching lines @@
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(SoftwareImageDecodeController* controller,
                       const SoftwareImageDecodeController::ImageKey& image_key,
                       const DrawImage& image,
                       uint64_t source_prepare_tiles_id)
       : controller_(controller),
         image_key_(image_key),
         image_(image),
-        image_ref_(skia::SharePtr(image.image())),
+        image_ref_(image.image()),
         source_prepare_tiles_id_(source_prepare_tiles_id) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode",
                  "software", "source_prepare_tiles_id",
                  source_prepare_tiles_id_);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_ref_.get());
     controller_->DecodeImage(image_key_, image_);
   }
 
   // Overridden from TileTask:
   void ScheduleOnOriginThread(TileTaskClient* client) override {}
   void CompleteOnOriginThread(TileTaskClient* client) override {
     controller_->RemovePendingTask(image_key_);
   }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
   SoftwareImageDecodeController* controller_;
   SoftwareImageDecodeController::ImageKey image_key_;
   DrawImage image_;
-  skia::RefPtr<const SkImage> image_ref_;
+  sk_sp<const SkImage> image_ref_;
   uint64_t source_prepare_tiles_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key) {
   // If the requested filter quality did not require scale, then the adjustment
   // is identity.
   if (key.can_use_original_decode())
     return SkSize::Make(1.f, 1.f);
@@ skipping 259 matching lines @@
   SanityCheckState(__LINE__, true);
 }
 
 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();
+  sk_sp<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_);
     std::unique_ptr<base::DiscardableMemory> decoded_pixels;
     {
       TRACE_EVENT0(
           "disabled-by-default-cc.debug",
@@ skipping 28 matching lines @@
   // 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
   // place. If, on the other hand, the decode was not available,
   // GetDecodedImageForDrawInternal() would decode the image, and unreffing it
   // later ensures that we will store the discardable memory unlocked in the
   // cache to be used by future requests.
   gfx::Rect full_image_rect(image->width(), image->height());
-  DrawImage original_size_draw_image(image, gfx::RectToSkIRect(full_image_rect),
+  DrawImage original_size_draw_image(image.get(),
+                                     gfx::RectToSkIRect(full_image_rect),
                                      kNone_SkFilterQuality, SkMatrix::I());
   ImageKey original_size_key =
       ImageKey::FromDrawImage(original_size_draw_image);
   // Sanity checks.
   DCHECK(original_size_key.can_use_original_decode())
       << original_size_key.ToString();
   DCHECK(full_image_rect.size() == original_size_key.target_size());
 
   auto decoded_draw_image = GetDecodedImageForDrawInternal(
       original_size_key, original_size_draw_image);
@@ skipping 441 matching lines @@
 SoftwareImageDecodeController::DecodedImage::DecodedImage(
     const SkImageInfo& info,
     std::unique_ptr<base::DiscardableMemory> memory,
     const SkSize& src_rect_offset,
     uint64_t tracing_id)
     : locked_(true),
       image_info_(info),
       memory_(std::move(memory)),
       src_rect_offset_(src_rect_offset),
       tracing_id_(tracing_id) {
-  image_ = skia::AdoptRef(SkImage::NewFromRaster(
-      image_info_, memory_->data(), image_info_.minRowBytes(),
-      [](const void* pixels, void* context) {}, nullptr));
+  SkPixmap p(image_info_, memory_->data(), image_info_.minRowBytes());
+  image_ = SkImage::MakeFromRaster(p, [](const void* pixels, void* context) {},
+                                   nullptr);
 }
 
 SoftwareImageDecodeController::DecodedImage::~DecodedImage() {
   DCHECK(!locked_);
 }
 
 bool SoftwareImageDecodeController::DecodedImage::Lock() {
   DCHECK(!locked_);
   bool success = memory_->Lock();
   if (!success)
@@ skipping 30 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc