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

cc/trees/layer_tree_host_pixeltest_blending.cc

 // Copyright 2013 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 <stdint.h>
 
 #include "cc/layers/picture_image_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/test/layer_tree_pixel_resource_test.h"
 #include "cc/test/pixel_comparator.h"
@@ skipping 126 matching lines @@
     canvas->clear(SK_ColorTRANSPARENT);
     for (int i = 0; i < kCSSTestColorsCount; ++i) {
       SkPaint paint;
       paint.setColor(kCSSTestColors[i]);
       canvas->drawRect(
           SkRect::MakeXYWH(0, i * kLaneHeight, kLaneWidth, kLaneHeight), paint);
     }
     scoped_refptr<PictureImageLayer> layer = PictureImageLayer::Create();
     layer->SetIsDrawable(true);
     layer->SetBounds(gfx::Size(width, height));
-    skia::RefPtr<const SkImage> image =
-        skia::AdoptRef(backing_store->newImageSnapshot());
-    layer->SetImage(std::move(image));
+    layer->SetImage(skia::SharePtr(backing_store->makeImageSnapshot()));

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

nit: in this particular case I think they're functionally equivalent (both steal
the ref value), but skia::AdoptRef is easier to grok for me.

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

I don't understand - AdoptRef *does not* increment the reference count, but
SharePtr *does* increment the refcount, right?

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

Yes (functionally), but the increment is front-loaded in the arg value
instantiation (refptr.h):

  RefPtr<T> AdoptRef(sk_sp<T>&& sp) { return RefPtr<T>(sp.release()); }
  RefPtr<T> SharePtr(sk_sp<T> sp) { return RefPtr<T>(sp.release()); }

When the argument is an rvalue (as it was the case here) they're equivalent.

All moot now, the new version is much nicer - thanks!

     return layer;
   }
 
   void SetupMaskLayer(scoped_refptr<Layer> layer) {
     const int kMaskOffset = 2;
     gfx::Size bounds = layer->bounds();
     scoped_refptr<PictureImageLayer> mask = PictureImageLayer::Create();
     mask->SetIsDrawable(true);
     mask->SetIsMask(true);
     mask->SetBounds(bounds);
 
     sk_sp<SkSurface> surface =
         SkSurface::MakeRasterN32Premul(bounds.width(), bounds.height());
     SkCanvas* canvas = surface->getCanvas();
     SkPaint paint;
     paint.setColor(SK_ColorWHITE);
     canvas->clear(SK_ColorTRANSPARENT);
     canvas->drawRect(SkRect::MakeXYWH(kMaskOffset, kMaskOffset,
                                       bounds.width() - kMaskOffset * 2,
                                       bounds.height() - kMaskOffset * 2),
                      paint);
-    skia::RefPtr<const SkImage> image =
-        skia::AdoptRef(surface->newImageSnapshot());
-    mask->SetImage(std::move(image));
+    mask->SetImage(skia::SharePtr(surface->makeImageSnapshot()));

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

nit: ditto

     layer->SetMaskLayer(mask.get());
   }
 
   void SetupColorMatrix(scoped_refptr<Layer> layer) {
     FilterOperations filter_operations;
     filter_operations.Append(FilterOperation::CreateSepiaFilter(.001f));
     layer->SetFilters(filter_operations);
   }
 
   void CreateBlendingColorLayers(int lane_width,
@@ skipping 312 matching lines @@
   RunBlendingWithRenderPass(
       GL_ZERO_COPY_RECT_DRAW,
       FILE_PATH_LITERAL("blending_render_pass_mask.png"),
       kUseMasks | kUseAntialiasing | kUseColorMatrix | kForceShaders);
 }
 
 }  // namespace
 }  // namespace cc
 
 #endif  // OS_ANDROID