guard rasterizer and drawlooper setters

tests/LayerRasterizerTest.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDeque.h"
 #include "SkLayerRasterizer.h"
 #include "SkPaint.h"
@@ skipping 31 matching lines @@
 };
 
 int DummyRasterizer::gCount;
 
 SkFlattenable* DummyRasterizer::CreateProc(SkReadBuffer&) { return new DummyRasterizer; }
 
 // Check to make sure that the SkPaint in the layer has its destructor called.
 DEF_TEST(LayerRasterizer_destructor, reporter) {
     {
         SkPaint paint;
-        paint.setRasterizer(new DummyRasterizer)->unref();
+        paint.setRasterizer(sk_make_sp<DummyRasterizer>());
         REPORTER_ASSERT(reporter, DummyRasterizer::GetCount() == 1);
 
         SkLayerRasterizer::Builder builder;
         builder.addLayer(paint);
     }
     REPORTER_ASSERT(reporter, DummyRasterizer::GetCount() == 0);
 }
 
 class LayerRasterizerTester {
 public:
@@ skipping 11 matching lines @@
     SkPaint     fPaint;
     SkVector    fOffset;
 };
 
 static bool equals(const SkLayerRasterizer_Rec& rec1, const SkLayerRasterizer_Rec& rec2) {
     return rec1.fPaint == rec2.fPaint && rec1.fOffset == rec2.fOffset;
 }
 
 DEF_TEST(LayerRasterizer_copy, reporter) {
     SkLayerRasterizer::Builder builder;
-    REPORTER_ASSERT(reporter, nullptr == builder.snapshotRasterizer());
+    REPORTER_ASSERT(reporter, nullptr == builder.snapshot());
     SkPaint paint;
     // Create a bunch of paints with different flags.
     for (uint32_t flags = 0x01; flags < SkPaint::kAllFlags; flags <<= 1) {
         paint.setFlags(flags);
         builder.addLayer(paint, static_cast<SkScalar>(flags), static_cast<SkScalar>(flags));
     }
 
     // Create a layer rasterizer with all the existing layers.
-    SkAutoTUnref<SkLayerRasterizer> firstCopy(builder.snapshotRasterizer());
+    sk_sp<SkLayerRasterizer> firstCopy(builder.snapshot());
 
     // Add one more layer.
     paint.setFlags(SkPaint::kAllFlags);
     builder.addLayer(paint);
 
-    SkAutoTUnref<SkLayerRasterizer> oneLarger(builder.snapshotRasterizer());
-    SkAutoTUnref<SkLayerRasterizer> detached(builder.detachRasterizer());
+    sk_sp<SkLayerRasterizer> oneLarger(builder.snapshot());
+    sk_sp<SkLayerRasterizer> detached(builder.detach());
 
     // Check the counts for consistency.
     const int largerCount = LayerRasterizerTester::CountLayers(*oneLarger.get());
     const int smallerCount = LayerRasterizerTester::CountLayers(*firstCopy.get());
     REPORTER_ASSERT(reporter, largerCount == LayerRasterizerTester::CountLayers(*detached.get()));
     REPORTER_ASSERT(reporter, smallerCount == largerCount - 1);
 
     const SkLayerRasterizer_Rec* recFirstCopy = nullptr;
     const SkLayerRasterizer_Rec* recOneLarger = nullptr;
     const SkLayerRasterizer_Rec* recDetached = nullptr;
@@ skipping 22 matching lines @@
         if (smallerCount == i) {
             REPORTER_ASSERT(reporter, recFirstCopy == nullptr);
         } else {
             REPORTER_ASSERT(reporter, equals(*recFirstCopy, *recOneLarger));
         }
     }
 }
 
 DEF_TEST(LayerRasterizer_detachEmpty, reporter) {
     SkLayerRasterizer::Builder builder;
-    REPORTER_ASSERT(reporter, nullptr == builder.detachRasterizer());
+    REPORTER_ASSERT(reporter, nullptr == builder.detach());
 }