return pictures as sk_sp

bench/nanobench.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 <ctype.h>
 
 #include "nanobench.h"
@@ skipping 599 matching lines @@
         // Choose the candidate color types for image decoding
         const SkColorType colorTypes[] =
             { kN32_SkColorType,
               kRGB_565_SkColorType,
               kAlpha_8_SkColorType,
               kIndex_8_SkColorType,
               kGray_8_SkColorType };
         fColorTypes.reset(colorTypes, SK_ARRAY_COUNT(colorTypes));
     }
 
-    static bool ReadPicture(const char* path, SkAutoTUnref<SkPicture>* pic) {
+    static sk_sp<SkPicture> ReadPicture(const char* path) {
         // Not strictly necessary, as it will be checked again later,
         // but helps to avoid a lot of pointless work if we're going to skip it.
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, SkOSPath::Basename(path).c_str())) {
-            return false;
+            return nullptr;
         }
 
         SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(path));
         if (stream.get() == nullptr) {
             SkDebugf("Could not read %s.\n", path);
-            return false;
+            return nullptr;
         }
 
-        pic->reset(SkPicture::CreateFromStream(stream.get()));
-        if (pic->get() == nullptr) {
-            SkDebugf("Could not read %s as an SkPicture.\n", path);
-            return false;
-        }
-        return true;
+        return SkPicture::MakeFromStream(stream.get());
     }
 
     Benchmark* next() {
         SkAutoTDelete<Benchmark> bench;
         do {
             bench.reset(this->rawNext());
             if (!bench) {
                 return nullptr;
             }
         } while(SkCommandLineFlags::ShouldSkip(FLAGS_sourceType, fSourceType) ||
@@ skipping 16 matching lines @@
             if (gm->runAsBench()) {
                 fSourceType = "gm";
                 fBenchType  = "micro";
                 return new GMBench(gm.release());
             }
         }
 
         // First add all .skps as RecordingBenches.
         while (fCurrentRecording < fSKPs.count()) {
             const SkString& path = fSKPs[fCurrentRecording++];
-            SkAutoTUnref<SkPicture> pic;
-            if (!ReadPicture(path.c_str(), &pic)) {
+            sk_sp<SkPicture> pic = ReadPicture(path.c_str());
+            if (!pic) {
                 continue;
             }
             SkString name = SkOSPath::Basename(path.c_str());
             fSourceType = "skp";
             fBenchType  = "recording";
-            fSKPBytes = static_cast<double>(SkPictureUtils::ApproximateBytesUsed(pic));
+            fSKPBytes = static_cast<double>(SkPictureUtils::ApproximateBytesUsed(pic.get()));
             fSKPOps   = pic->approximateOpCount();
             return new RecordingBench(name.c_str(), pic.get(), FLAGS_bbh);
         }
 
         // Then once each for each scale as SKPBenches (playback).
         while (fCurrentScale < fScales.count()) {
             while (fCurrentSKP < fSKPs.count()) {
                 const SkString& path = fSKPs[fCurrentSKP];
-                SkAutoTUnref<SkPicture> pic;
-                if (!ReadPicture(path.c_str(), &pic)) {
+                sk_sp<SkPicture> pic = ReadPicture(path.c_str());
+                if (!pic) {
                     fCurrentSKP++;
                     continue;
                 }
 
                 while (fCurrentUseMPD < fUseMPDs.count()) {
                     if (FLAGS_bbh) {
                         // The SKP we read off disk doesn't have a BBH.  Re-record so it grows one.
                         SkRTreeFactory factory;
                         SkPictureRecorder recorder;
                         static const int kFlags = SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag;
                         pic->playback(recorder.beginRecording(pic->cullRect().width(),
                                                               pic->cullRect().height(),
                                                               &factory,
                                                               fUseMPDs[fCurrentUseMPD] ? kFlags : 0));
-                        pic.reset(recorder.endRecording());
+                        pic = recorder.finishRecordingAsPicture();
                     }
                     SkString name = SkOSPath::Basename(path.c_str());
                     fSourceType = "skp";
                     fBenchType = "playback";
                     return new SKPBench(name.c_str(), pic.get(), fClip, fScales[fCurrentScale],
                                         fUseMPDs[fCurrentUseMPD++], FLAGS_loopSKP);
                 }
                 fCurrentUseMPD = 0;
                 fCurrentSKP++;
             }
             fCurrentSKP = 0;
             fCurrentScale++;
         }
 
         // Now loop over each skp again if we have an animation
         if (fZoomMax != 1.0f && fZoomPeriodMs > 0) {
             while (fCurrentAnimSKP < fSKPs.count()) {
                 const SkString& path = fSKPs[fCurrentAnimSKP];
-                SkAutoTUnref<SkPicture> pic;
-                if (!ReadPicture(path.c_str(), &pic)) {
+                sk_sp<SkPicture> pic = ReadPicture(path.c_str());
+                if (!pic) {
                     fCurrentAnimSKP++;
                     continue;
                 }
 
                 fCurrentAnimSKP++;
                 SkString name = SkOSPath::Basename(path.c_str());
                 SkAutoTUnref<SKPAnimationBench::Animation> animation(
                     SKPAnimationBench::CreateZoomAnimation(fZoomMax, fZoomPeriodMs));
                 return new SKPAnimationBench(name.c_str(), pic.get(), fClip, animation,
                                              FLAGS_loopSKP);
@@ skipping 548 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif