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

cc/output/gl_renderer.cc

Index: cc/output/gl_renderer.cc
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index bc405a3de8a290eb528014a2497a62850cc1110f..5ab7ed71c0e46a5ab92aabb47457b32d239eab05 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -594,7 +594,7 @@ void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
   gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
 }
 
-static skia::RefPtr<SkImage> ApplyImageFilter(
+static sk_sp<SkImage> ApplyImageFilter(
     std::unique_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
     const gfx::RectF& src_rect,
@@ -603,10 +603,10 @@ static skia::RefPtr<SkImage> ApplyImageFilter(
     SkImageFilter* filter,
     ScopedResource* source_texture_resource) {
   if (!filter)
-    return skia::RefPtr<SkImage>();
+    return nullptr;
 
   if (!use_gr_context)
-    return skia::RefPtr<SkImage>();
+    return nullptr;
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider,
                                           source_texture_resource->id());
@@ -624,13 +624,13 @@ static skia::RefPtr<SkImage> ApplyImageFilter(
       skia::GrGLTextureInfoToGrBackendObject(texture_info);
   backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
 
-  skia::RefPtr<SkImage> srcImage = skia::AdoptRef(SkImage::NewFromTexture(
-      use_gr_context->context(), backend_texture_description));
-  if (!srcImage.get()) {
+  sk_sp<SkImage> srcImage = SkImage::MakeFromTexture(

[danakj, 2016/04/25 22:06:23]

nit: while you're here.. src_image?

[tomhudson, 2016/04/27 12:06:47]

Done.

+      use_gr_context->context(), backend_texture_description);
+  if (!srcImage) {
     TRACE_EVENT_INSTANT0("cc",
                          "ApplyImageFilter wrap background texture failed",
                          TRACE_EVENT_SCOPE_THREAD);
-    return skia::RefPtr<SkImage>();
+    return nullptr;
   }
 
   // Create surface to draw into.
@@ -641,7 +641,7 @@ static skia::RefPtr<SkImage> ApplyImageFilter(
   if (!surface) {
     TRACE_EVENT_INSTANT0("cc", "ApplyImageFilter surface allocation failed",
                          TRACE_EVENT_SCOPE_THREAD);
-    return skia::RefPtr<SkImage>();
+    return nullptr;
   }
 
   SkMatrix local_matrix;
@@ -650,16 +650,15 @@ static skia::RefPtr<SkImage> ApplyImageFilter(
   SkPaint paint;
   paint.setImageFilter(filter->makeWithLocalMatrix(local_matrix));

[danakj, 2016/04/25 22:06:23]

The SkPaint is taking ownership of this filter right? Then it shouldn't be a raw
pointer as an argument to ApplyImageFilter

[tomhudson, 2016/04/27 12:06:47]

Done.

   surface->getCanvas()->translate(-dst_rect.x(), -dst_rect.y());
-  surface->getCanvas()->drawImage(srcImage.get(), src_rect.x(), src_rect.y(),
-                                  &paint);
+  surface->getCanvas()->drawImage(srcImage, src_rect.x(), src_rect.y(), &paint);

[danakj, 2016/04/25 22:06:23]

I found it a bit surprising that drawImage takes ownership of the SkImage.  I
guess that is intentional? If so, you can move the src_image then.

[tomhudson, 2016/04/27 12:06:47]

As I understand it there are times when parts of the draw could be deferred, so
we need to keep a ref to the image. (e.g. what if the image is backed by
something that is lazily decoded?)

[f(malita), 2016/04/27 14:00:41]

The most common case I believe is a recording canvas - but note that the
ownership transfer is not required/implied:

  drawImage(const sk_sp<SkImage>&,...) rather than drawImage(sk_sp<SkImage>,...)

so moving the argument is not buying us much here.

[tomhudson, 2016/04/27 14:43:12]

OK, slightly better if still not completely understood, and so undone?

   // Flush the drawing before source texture read lock goes out of scope.
   // Skia API does not guarantee that when the SkImage goes out of scope,
   // its externally referenced resources would force the rendering to be
   // flushed.
   surface->getCanvas()->flush();
-  skia::RefPtr<SkImage> image = skia::AdoptRef(surface->newImageSnapshot());
+  sk_sp<SkImage> image = surface->makeImageSnapshot();
   if (!image || !image->isTextureBacked()) {
-    return skia::RefPtr<SkImage>();
+    return nullptr;
   }
 
   CHECK(image->isTextureBacked());
@@ -848,16 +847,16 @@ std::unique_ptr<ScopedResource> GLRenderer::GetBackdropTexture(
   return device_background_texture;
 }
 
-skia::RefPtr<SkImage> GLRenderer::ApplyBackgroundFilters(
+sk_sp<SkImage> GLRenderer::ApplyBackgroundFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     ScopedResource* background_texture,
     const gfx::RectF& rect) {
   DCHECK(ShouldApplyBackgroundFilters(quad));
-  skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
+  sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, gfx::SizeF(background_texture->size()));
 
-  skia::RefPtr<SkImage> background_with_filters = ApplyImageFilter(
+  sk_sp<SkImage> background_with_filters = ApplyImageFilter(
       ScopedUseGrContext::Create(this, frame), resource_provider_, rect, rect,
       quad->filters_scale, filter.get(), background_texture);

[danakj, 2016/04/25 22:06:23]

and we can move the filter here

[tomhudson, 2016/04/27 12:06:47]

Done.

   return background_with_filters;
@@ -925,7 +924,7 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
       settings_->force_blending_with_shaders;
 
   std::unique_ptr<ScopedResource> background_texture;
-  skia::RefPtr<SkImage> background_image;
+  sk_sp<SkImage> background_image;
   GLuint background_image_id = 0;
   gfx::Rect background_rect;
   if (use_shaders_for_blending) {
@@ -985,13 +984,13 @@ void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
-  skia::RefPtr<SkImage> filter_image;
+  sk_sp<SkImage> filter_image;
   GLuint filter_image_id = 0;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   gfx::RectF rect = gfx::RectF(quad->rect);
   if (!quad->filters.IsEmpty()) {
-    skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
+    sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
         quad->filters, gfx::SizeF(contents_texture->size()));
     if (filter) {
       SkColorFilter* colorfilter_rawptr = NULL;