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

cc/tiles/gpu_image_decode_controller.cc

 // Copyright 2016 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/gpu_image_decode_controller.h"
 
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/raster/tile_task_runner.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu_image_decode_controller.h"
-#include "skia/ext/refptr.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gl/trace_util.h"
 
 namespace cc {
 namespace {
 
 static const int kMaxGpuImageBytes = 1024 * 1024 * 96;
@@ skipping 26 matching lines @@
 
 // Task which decodes an image and stores the result in discardable memory.
 // This task does not use GPU resources and can be run on any thread.
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       uint64_t source_prepare_tiles_id)
       : controller_(controller),
         image_(draw_image),
-        image_ref_(skia::SharePtr(draw_image.image())),
+        image_ref_(sk_ref_sp(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
     DCHECK(!SkipImage(draw_image));
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     controller_->DecodeImage(image_);
   }
 
   // Overridden from TileTask:
   void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
   void CompleteOnOriginThread(RasterBufferProvider* provider) override {
     controller_->DecodeTaskCompleted(image_);
   }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
   GpuImageDecodeController* controller_;
   DrawImage image_;
-  skia::RefPtr<const SkImage> image_ref_;
+  sk_sp<const SkImage> image_ref_;
   const uint64_t source_prepare_tiles_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 // Task which creates an image from decoded data. Typically this involves
 // uploading data to the GPU, which requires this task be run on the non-
 // concurrent thread.
 class ImageUploadTaskImpl : public ImageDecodeTask {
  public:
   ImageUploadTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       scoped_refptr<ImageDecodeTask> decode_dependency,
                       uint64_t source_prepare_tiles_id)
       : ImageDecodeTask(std::move(decode_dependency)),
         controller_(controller),
         image_(draw_image),
-        image_ref_(skia::SharePtr(draw_image.image())),
+        image_ref_(draw_image.image()),

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

sk_ref_sp(draw_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) {
     DCHECK(!SkipImage(draw_image));
   }
 
   // Override from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageUploadTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     controller_->UploadImage(image_);
   }
 
   void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
   void CompleteOnOriginThread(RasterBufferProvider* provider) override {
     controller_->UploadTaskCompleted(image_);
   }
 
   // Override from ImageDecodeTask:
   bool SupportsConcurrentExecution() const override { return false; }
 
  protected:
   ~ImageUploadTaskImpl() override {}
 
  private:
   GpuImageDecodeController* controller_;
   DrawImage image_;
-  skia::RefPtr<const SkImage> image_ref_;
+  sk_sp<const SkImage> image_ref_;
   uint64_t source_prepare_tiles_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageUploadTaskImpl);
 };
 
 GpuImageDecodeController::DecodedImageData::DecodedImageData()
     : ref_count(0), is_locked(false), decode_failure(false) {}
 
 GpuImageDecodeController::DecodedImageData::~DecodedImageData() = default;
 
 GpuImageDecodeController::UploadedImageData::UploadedImageData()
     : budgeted(false), ref_count(0) {}
 
 GpuImageDecodeController::UploadedImageData::~UploadedImageData() = default;
 
 GpuImageDecodeController::ImageData::ImageData(DecodedDataMode mode,
                                                size_t size)
     : mode(mode), size(size), is_at_raster(false) {}
 
 GpuImageDecodeController::ImageData::~ImageData() = default;
 
 GpuImageDecodeController::GpuImageDecodeController(ContextProvider* context,
                                                    ResourceFormat decode_format)
     : format_(decode_format),
       context_(context),
-      context_threadsafe_proxy_(
-          skia::AdoptRef(context->GrContext()->threadSafeProxy())),
+      context_threadsafe_proxy_(context->GrContext()->threadSafeProxy()),
       image_data_(ImageDataMRUCache::NO_AUTO_EVICT),
       cached_items_limit_(kMaxDiscardableItems),
       cached_bytes_limit_(kMaxGpuImageBytes),
       bytes_used_(0) {}
 
 GpuImageDecodeController::~GpuImageDecodeController() {
   // SetShouldAggressivelyFreeResources will zero our limits and free all
   // outstanding image memory.
   SetShouldAggressivelyFreeResources(true);
 }
@@ skipping 496 matching lines @@
   TRACE_EVENT0("cc", "GpuImageDecodeController::UploadImage");
   DCHECK(image_data->decode.is_locked);
   DCHECK_GT(image_data->decode.ref_count, 0u);
   DCHECK_GT(image_data->upload.ref_count, 0u);
 
   // We are about to upload a new image and are holding the context lock.
   // Ensure that any images which have been marked for deletion are actually
   // cleaned up so we don't exceed our memory limit during this upload.
   DeletePendingImages();
 
-  skia::RefPtr<SkImage> uploaded_image;
+  sk_sp<SkImage> uploaded_image;
   {
     base::AutoUnlock unlock(lock_);
     switch (image_data->mode) {
       case DecodedDataMode::CPU: {
         SkImageInfo image_info = CreateImageInfoForDrawImage(draw_image);
-        uploaded_image = skia::AdoptRef(SkImage::NewFromRaster(
-            image_info, image_data->decode.data->data(),
-            image_info.minRowBytes(), [](const void*, void*) {}, nullptr));
+        SkPixmap p(image_info, image_data->decode.data->data(),
+                   image_info.minRowBytes());
+        uploaded_image =
+            SkImage::MakeFromRaster(p, [](const void*, void*) {}, nullptr);
         break;
       }
       case DecodedDataMode::GPU: {
-        uploaded_image =
-            skia::AdoptRef(SkImage::NewFromDeferredTextureImageData(
-                context_->GrContext(), image_data->decode.data->data(),
-                SkBudgeted::kNo));
+        uploaded_image = SkImage::MakeFromDeferredTextureImageData(
+            context_->GrContext(), image_data->decode.data->data(),
+            SkBudgeted::kNo);
         break;
       }
     }
   }
   DCHECK(uploaded_image);
 
   // At-raster may have decoded this while we were unlocked. If so, ignore our
   // result.
   if (!image_data->upload.image) {
     image_data->upload.image = std::move(uploaded_image);
@@ skipping 29 matching lines @@
 }
 
 SkImageInfo GpuImageDecodeController::CreateImageInfoForDrawImage(
     const DrawImage& draw_image) const {
   return SkImageInfo::Make(
       draw_image.image()->width(), draw_image.image()->height(),
       ResourceFormatToClosestSkColorType(format_), kPremul_SkAlphaType);
 }
 
 }  // namespace cc