return pictures as sk_sp

tests/SerializationTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAnnotationKeys.h"
 #include "Resources.h"
 #include "SkCanvas.h"
@@ skipping 320 matching lines @@
     paint.setTypeface(typeface);
 
     // Paint some text.
     SkPictureRecorder recorder;
     SkIRect canvasRect = SkIRect::MakeWH(kBitmapSize, kBitmapSize);
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(canvasRect.width()), 
                                                SkIntToScalar(canvasRect.height()), 
                                                nullptr, 0);
     canvas->drawColor(SK_ColorWHITE);
     canvas->drawText(text, 2, 24, 32, paint);
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     // Serlialize picture and create its clone from stream.
     SkDynamicMemoryWStream stream;
     picture->serialize(&stream);
     SkAutoTDelete<SkStream> inputStream(stream.detachAsStream());
-    SkAutoTUnref<SkPicture> loadedPicture(SkPicture::CreateFromStream(inputStream.get()));
+    sk_sp<SkPicture> loadedPicture(SkPicture::MakeFromStream(inputStream.get()));
 
     // Draw both original and clone picture and compare bitmaps -- they should be identical.
     SkBitmap origBitmap = draw_picture(*picture);
     SkBitmap destBitmap = draw_picture(*loadedPicture);
     compare_bitmaps(reporter, origBitmap, destBitmap);
 }
 
 static void TestPictureTypefaceSerialization(skiatest::Reporter* reporter) {
     {
         // Load typeface from file to test CreateFromFile with index.
@@ skipping 164 matching lines @@
         // even when the device fails to initialize, due to its size
         TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
     }
 
     // Test simple SkPicture serialization
     {
         SkPictureRecorder recorder;
         draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize),
                                                SkIntToScalar(kBitmapSize),
                                                nullptr, 0));
-        SkAutoTUnref<SkPicture> pict(recorder.endRecording());
+        sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
 
         // Serialize picture
         SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
         pict->flatten(writer);
         size_t size = writer.bytesWritten();
         SkAutoTMalloc<unsigned char> data(size);
         writer.writeToMemory(static_cast<void*>(data.get()));
 
         // Deserialize picture
         SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size);
-        SkAutoTUnref<SkPicture> readPict(
-            SkPicture::CreateFromBuffer(reader));
+        sk_sp<SkPicture> readPict(SkPicture::MakeFromBuffer(reader));
         REPORTER_ASSERT(reporter, readPict.get());
     }
 
     TestPictureTypefaceSerialization(reporter);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 #include "SkAnnotation.h"
 
-static SkPicture* copy_picture_via_serialization(SkPicture* src) {
+static sk_sp<SkPicture> copy_picture_via_serialization(SkPicture* src) {
     SkDynamicMemoryWStream wstream;
     src->serialize(&wstream);
     SkAutoTDelete<SkStreamAsset> rstream(wstream.detachAsStream());
-    return SkPicture::CreateFromStream(rstream);
+    return SkPicture::MakeFromStream(rstream);
 }
 
 struct AnnotationRec {
     const SkRect    fRect;
     const char*     fKey;
     SkData*         fValue;
 };
 
 class TestAnnotationCanvas : public SkCanvas {
     skiatest::Reporter*     fReporter;
@@ skipping 46 matching lines @@
     const SkRect r2 = SkRect::MakeXYWH(20, 20, 5, 6);
     SkAutoTUnref<SkData> d2(SkData::NewWithCString(str2));
     SkAnnotateLinkToDestination(recordingCanvas, r2, d2);
 
     const AnnotationRec recs[] = {
         { r0, SkAnnotationKeys::URL_Key(),                  d0 },
         { r1, SkAnnotationKeys::Define_Named_Dest_Key(),    d1 },
         { r2, SkAnnotationKeys::Link_Named_Dest_Key(),      d2 },
     };
 
-    SkAutoTUnref<SkPicture> pict0(recorder.endRecording());
-    SkAutoTUnref<SkPicture> pict1(copy_picture_via_serialization(pict0));
+    sk_sp<SkPicture> pict0(recorder.finishRecordingAsPicture());
+    sk_sp<SkPicture> pict1(copy_picture_via_serialization(pict0.get()));
 
     TestAnnotationCanvas canvas(reporter, recs, SK_ARRAY_COUNT(recs));
     canvas.drawPicture(pict1);
 }