return pictures as sk_sp

gm/multipicturedraw.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 "gm.h"
 
 #include "SkColorFilter.h"
@@ skipping 23 matching lines @@
     hex.rLineTo(SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
     hex.rLineTo(-SkScalarHalf(kHexSide), -kHexSide * kRoot3Over2);
     hex.rLineTo(-SkIntToScalar(kHexSide), 0);
     hex.close();
     return hex;
 }
 
 // Make a picture that is a tiling of the plane with stroked hexagons where
 // each hexagon is in its own layer. The layers are to exercise Ganesh's
 // layer hoisting.
-static const SkPicture* make_hex_plane_picture(SkColor fillColor) {
+static sk_sp<SkPicture> make_hex_plane_picture(SkColor fillColor) {
 
     // Create a hexagon with its center at the origin
     SkPath hex = make_hex_path(0, 0);
 
     SkPaint fill;
     fill.setStyle(SkPaint::kFill_Style);
     fill.setColor(fillColor);
 
     SkPaint stroke;
     stroke.setStyle(SkPaint::kStroke_Style);
@@ skipping 18 matching lines @@
             canvas->drawPath(hex, fill);
             canvas->drawPath(hex, stroke);
             canvas->restore();
 
             xPos += 1.5f * kHexSide;
         }
 
         yPos += 2 * kHexSide * kRoot3Over2;
     }
 
-    return recorder.endRecording();
+    return recorder.finishRecordingAsPicture();
 }
 
 // Create a picture that consists of a single large layer that is tiled
 // with hexagons.
 // This is intended to exercise the layer hoisting code's clip handling (in
 // tile mode).
-static const SkPicture* make_single_layer_hex_plane_picture() {
+static sk_sp<SkPicture> make_single_layer_hex_plane_picture() {
 
     // Create a hexagon with its center at the origin
     SkPath hex = make_hex_path(0, 0);
 
     SkPaint whiteFill;
     whiteFill.setStyle(SkPaint::kFill_Style);
     whiteFill.setColor(SK_ColorWHITE);
 
     SkPaint greyFill;
     greyFill.setStyle(SkPaint::kFill_Style);
@@ skipping 28 matching lines @@
             canvas->restore();
 
             xPos += 1.5f * kHexSide;
         }
 
         yPos += 2 * kHexSide * kRoot3Over2;
     }
 
     canvas->restore();
 
-    return recorder.endRecording();
+    return recorder.finishRecordingAsPicture();
 }
 
 // Make an equilateral triangle path with its top corner at (originX, originY)
 static SkPath make_tri_path(SkScalar originX, SkScalar originY) {
     SkPath tri;
     tri.moveTo(originX, originY);
     tri.rLineTo(SkScalarHalf(kTriSide), 1.5f * kTriSide / kRoot3);
     tri.rLineTo(-kTriSide, 0);
     tri.close();
     return tri;
 }
 
-static const SkPicture* make_tri_picture() {
+static sk_sp<SkPicture> make_tri_picture() {
     SkPath tri = make_tri_path(SkScalarHalf(kTriSide), 0);
 
     SkPaint fill;
     fill.setStyle(SkPaint::kFill_Style);
     fill.setColor(sk_tool_utils::color_to_565(SK_ColorLTGRAY));
 
     SkPaint stroke;
     stroke.setStyle(SkPaint::kStroke_Style);
     stroke.setStrokeWidth(3);
 
     SkPictureRecorder recorder;
     SkRTreeFactory bbhFactory;
 
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                SkIntToScalar(kPicHeight),
                                                &bbhFactory,
                                                SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
     SkRect r = tri.getBounds();
     r.outset(2.0f, 2.0f);       // outset for stroke
     canvas->clipRect(r);
     // The saveLayer/restore block is to exercise layer hoisting
     canvas->saveLayer(nullptr, nullptr);
         canvas->drawPath(tri, fill);
         canvas->drawPath(tri, stroke);
     canvas->restore();
 
-    return recorder.endRecording();
+    return recorder.finishRecordingAsPicture();
 }
 
-static const SkPicture* make_sub_picture(const SkPicture* tri) {
+static sk_sp<SkPicture> make_sub_picture(const SkPicture* tri) {
     SkPictureRecorder recorder;
     SkRTreeFactory bbhFactory;
 
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                SkIntToScalar(kPicHeight),
                                                &bbhFactory,
                                                SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
 
     canvas->scale(1.0f/2.0f, 1.0f/2.0f);
 
     canvas->save();
     canvas->translate(SkScalarHalf(kTriSide), 0);
     canvas->drawPicture(tri);
     canvas->restore();
 
     canvas->save();
     canvas->translate(SkIntToScalar(kTriSide), 1.5f * kTriSide / kRoot3);
     canvas->drawPicture(tri);
     canvas->restore();
 
     canvas->save();
     canvas->translate(0, 1.5f * kTriSide / kRoot3);
     canvas->drawPicture(tri);
     canvas->restore();
 
-    return recorder.endRecording();
+    return recorder.finishRecordingAsPicture();
 }
 
 // Create a Sierpinkski-like picture that starts with a top row with a picture
 // that just contains a triangle. Subsequent rows take the prior row's picture,
 // shrinks it and replicates it 3 times then draws and appropriate number of
 // copies of it.
-static const SkPicture* make_sierpinski_picture() {
-    SkAutoTUnref<const SkPicture> pic(make_tri_picture());
+static sk_sp<SkPicture> make_sierpinski_picture() {
+    sk_sp<SkPicture> pic(make_tri_picture());
 
     SkPictureRecorder recorder;
     SkRTreeFactory bbhFactory;
 
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                SkIntToScalar(kPicHeight),
                                                &bbhFactory,
                                                SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
 
     static const int kNumLevels = 4;
     for (int i = 0; i < kNumLevels; ++i) {
         canvas->save();
             canvas->translate(kPicWidth/2 - (i+1) * (kTriSide/2.0f), 0.0f);
             for (int j = 0; j < i+1; ++j) {
                 canvas->drawPicture(pic);
                 canvas->translate(SkIntToScalar(kTriSide), 0);
             }
         canvas->restore();
 
-        pic.reset(make_sub_picture(pic));
+        pic = make_sub_picture(pic.get());
 
         canvas->translate(0, 1.5f * kTriSide / kRoot3);
     }
 
-    return recorder.endRecording();
+    return recorder.finishRecordingAsPicture();
 }
 
 static SkSurface* create_compat_surface(SkCanvas* canvas, int width, int height) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
 
     SkSurface* surface = canvas->newSurface(info);
     if (nullptr == surface) {
         // picture canvas returns nullptr so fall back to raster
         surface = SkSurface::NewRaster(info);
     }
@@ skipping 97 matching lines @@
     rrect_clip,
     path_clip,
     invpath_clip,
     sierpinski,
     big_layer,
 };
 
 static void create_content(SkMultiPictureDraw* mpd, PFContentMtd pfGen,
                            const SkPicture* pictures[kNumPictures],
                            SkCanvas* dest, const SkMatrix& xform) {
-    SkAutoTUnref<SkPicture> composite;
+    sk_sp<SkPicture> composite;
 
     {
         SkPictureRecorder recorder;
         SkRTreeFactory bbhFactory;
 
         SkCanvas* pictureCanvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                           SkIntToScalar(kPicHeight),
                                                           &bbhFactory,
                                                           SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
 
         (*pfGen)(pictureCanvas, pictures);
 
-        composite.reset(recorder.endRecording());
+        composite = recorder.finishRecordingAsPicture();
     }
 
-    mpd->add(dest, composite, &xform);
+    mpd->add(dest, composite.get(), &xform);
 }
 
 typedef void(*PFLayoutMtd)(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
                            PFContentMtd pfGen, const SkPicture* pictures[kNumPictures],
                            SkTArray<ComposeStep>* composeSteps);
 
 // Draw the content into a single canvas
 static void simple(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
                    PFContentMtd pfGen,
                    const SkPicture* pictures[kNumPictures],
@@ skipping 97 matching lines @@
                 SkSafeUnref(fPictures[i]);
             }
         }
 
     protected:
         Content          fContent;
         Layout           fLayout;
         const SkPicture* fPictures[kNumPictures];
 
         void onOnceBeforeDraw() override {
-            fPictures[0] = make_hex_plane_picture(SK_ColorWHITE);
-            fPictures[1] = make_hex_plane_picture(sk_tool_utils::color_to_565(SK_ColorGRAY));
-            fPictures[2] = make_sierpinski_picture();
-            fPictures[3] = make_single_layer_hex_plane_picture();
+            fPictures[0] = make_hex_plane_picture(SK_ColorWHITE).release();
+            fPictures[1] = make_hex_plane_picture(sk_tool_utils::color_to_565(SK_ColorGRAY)).release();
+            fPictures[2] = make_sierpinski_picture().release();
+            fPictures[3] = make_single_layer_hex_plane_picture().release();
         }
 
         void onDraw(SkCanvas* canvas) override {
             SkMultiPictureDraw mpd;
             SkTArray<ComposeStep> composeSteps;
 
             // Fill up the MultiPictureDraw
             (*gLayoutMthds[fLayout])(canvas, &mpd,
                                      gContentMthds[fContent],
                                      fPictures, &composeSteps);
@@ skipping 58 matching lines @@
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kPathClipMulti_Content,
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kInvPathClipMulti_Content,
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kSierpinski_Content,
                                        MultiPictureDraw::kTiled_Layout);)
     DEF_GM(return new MultiPictureDraw(MultiPictureDraw::kBigLayer_Content,
                                        MultiPictureDraw::kTiled_Layout);)
 }