SkPictureGpuAnalyzer

tests/PictureTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBBoxHierarchy.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorMatrixFilter.h"
 #include "SkColorPriv.h"
 #include "SkDashPathEffect.h"
 #include "SkData.h"
 #include "SkImageGenerator.h"
 #include "SkError.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkLayerInfo.h"
 #include "SkMD5.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
+#include "SkPictureAnalyzer.h"
 #include "SkPictureRecorder.h"
 #include "SkPictureUtils.h"
 #include "SkPixelRef.h"
 #include "SkPixelSerializer.h"
 #include "SkMiniRecorder.h"
 #include "SkRRect.h"
 #include "SkRandom.h"
 #include "SkRecord.h"
 #include "SkShader.h"
 #include "SkStream.h"
@@ skipping 118 matching lines @@
         paint.setPathEffect(dash);
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     // path effects currently render an SkPicture undesireable for GPU rendering
 
     const char *reason = nullptr;
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr, &reason));
+    REPORTER_ASSERT(reporter,
+        !SkPictureGpuAnalyzer(picture).suitableForGpuRasterization(nullptr, &reason));
     REPORTER_ASSERT(reporter, reason);
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture = recorder.finishRecordingAsPicture();
     // A lot of small AA concave paths should be fine for GPU rendering
-    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
+    REPORTER_ASSERT(reporter, SkPictureGpuAnalyzer(picture).suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 100);
         path.lineTo(50, 50);
         path.lineTo(100, 100);
         path.lineTo(100, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture = recorder.finishRecordingAsPicture();
     // A lot of large AA concave paths currently render an SkPicture undesireable for GPU rendering
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
+    REPORTER_ASSERT(reporter, !SkPictureGpuAnalyzer(picture).suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(0);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture = recorder.finishRecordingAsPicture();
     // hairline stroked AA concave paths are fine for GPU rendering
-    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
+    REPORTER_ASSERT(reporter, SkPictureGpuAnalyzer(picture).suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 25));
 
         SkPoint points [2] = { { 0, 0 }, { 100, 0 } };
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, points, paint);
         }
     }
     picture = recorder.finishRecordingAsPicture();
     // fast-path dashed effects are fine for GPU rendering ...
-    REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
+    REPORTER_ASSERT(reporter, SkPictureGpuAnalyzer(picture).suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 25));
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawRect(SkRect::MakeWH(10, 10), paint);
         }
     }
     picture = recorder.finishRecordingAsPicture();
     // ... but only when applied to drawPoint() calls
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
+    REPORTER_ASSERT(reporter, !SkPictureGpuAnalyzer(picture).suitableForGpuRasterization(nullptr));
 
     // Nest the previous picture inside a new one.
     canvas = recorder.beginRecording(100, 100);
     {
-        canvas->drawPicture(picture.get());
+        canvas->drawPicture(picture);
     }
     picture = recorder.finishRecordingAsPicture();
-    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
+    REPORTER_ASSERT(reporter, !SkPictureGpuAnalyzer(picture).suitableForGpuRasterization(nullptr));
 }
 
 #endif
 
 static void test_savelayer_extraction(skiatest::Reporter* reporter) {
     static const int kWidth = 100;
     static const int kHeight = 100;
 
     // Create complex paint that the bounding box computation code can't
     // optimize away
@@ skipping 1060 matching lines @@
 
     SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
     sk_sp<SkPicture> deserializedPicture(SkPicture::MakeFromStream(rstream));
 
     REPORTER_ASSERT(r, deserializedPicture != nullptr);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().left() == 1);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().top() == 2);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().right() == 3);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().bottom() == 4);
 }
+
+DEF_TEST(PictureGpuAnalyzer, r) {
+    SkPictureRecorder recorder;
+
+    {
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        SkPaint paint;
+        SkScalar intervals [] = { 10, 20 };
+        paint.setPathEffect(SkDashPathEffect::Make(intervals, 2, 25));
+
+        for (int i = 0; i < 50; ++i) {
+            canvas->drawRect(SkRect::MakeWH(10, 10), paint);
+        }
+    }
+    sk_sp<SkPicture> vetoPicture(recorder.finishRecordingAsPicture());
+
+    SkPictureGpuAnalyzer analyzer;
+    REPORTER_ASSERT(r, analyzer.suitableForGpuRasterization(nullptr));
+
+    analyzer.analyze(vetoPicture.get());
+    REPORTER_ASSERT(r, !analyzer.suitableForGpuRasterization(nullptr));
+
+    analyzer.reset();
+    REPORTER_ASSERT(r, analyzer.suitableForGpuRasterization(nullptr));
+
+    recorder.beginRecording(10, 10)->drawPicture(vetoPicture);
+    sk_sp<SkPicture> nestedVetoPicture(recorder.finishRecordingAsPicture());
+
+    analyzer.analyze(nestedVetoPicture.get());
+    REPORTER_ASSERT(r, !analyzer.suitableForGpuRasterization(nullptr));
+}