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()),

[f(malita), 2016/04/21 15:45:47]

sk_ref_sp(image.image())?

[tomhudson, 2016/04/25 20:20:51]

Dana's suggestions made this member go away.

         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(RasterBufferProvider* provider) override {}
   void CompleteOnOriginThread(RasterBufferProvider* provider) 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());

[f(malita), 2016/04/21 15:45:47]

sk_ref_sp(draw_image.image())?

(or just leave as is/raw ptr - I don't think having a local sk_sp is helping
much here)

[tomhudson, 2016/04/25 20:20:51]

This is now returning sk_sp<>, and passing it on to clients - who need it in
that form because they may take a ref.

   if (!image)
     return nullptr;
 
   switch (key.filter_quality()) {
     case kNone_SkFilterQuality:
     case kLow_SkFilterQuality:
-      return GetOriginalImageDecode(key, *image);
+      return GetOriginalImageDecode(key, *image.get());
     case kMedium_SkFilterQuality:
       NOTIMPLEMENTED();
       return nullptr;
     case kHigh_SkFilterQuality:
-      return GetScaledImageDecode(key, *image);
+      return GetScaledImageDecode(key, *image.get());
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1("disabled-by-default-cc.debug",
@@ skipping 484 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