Complex clipPath accounting

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"
@@ skipping 117 matching lines @@
 //        SkDebugf("clip\n");
         canvas->clipRect(rect);
     } else {
 //        SkDebugf("draw\n");
         canvas->drawPaint(paint);
     }
 }
 
 #if SK_SUPPORT_GPU
 
+static SkPath make_convex_path() {
+    SkPath path;
+    path.lineTo(100, 0);
+    path.lineTo(50, 100);
+    path.close();
+
+    return path;
+}
+
+static SkPath make_concave_path() {
+    SkPath path;
+    path.lineTo(50, 50);
+    path.lineTo(100, 0);
+    path.lineTo(50, 100);
+    path.close();
+
+    return path;
+}
+
 static void test_gpu_veto(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
     SkCanvas* canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
         SkScalar intervals[] = { 1.0f, 1.0f };
@@ skipping 106 matching lines @@
         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, !SkPictureGpuAnalyzer(picture).suitableForGpuRasterization());
 
+    canvas = recorder.beginRecording(100, 100);
+    {
+        const SkPath convexClip = make_convex_path();
+        const SkPath concaveClip = make_concave_path();
+
+        for (int i = 0; i < 50; ++i) {
+            canvas->clipPath(convexClip);
+            canvas->clipPath(concaveClip);
+            canvas->clipPath(convexClip, SkRegion::kIntersect_Op, true);
+            canvas->drawRect(SkRect::MakeWH(100, 100), SkPaint());
+        }
+    }
+    picture = recorder.finishRecordingAsPicture();
+    // Convex clips and non-AA concave clips are fine on the GPU.
+    REPORTER_ASSERT(reporter, SkPictureGpuAnalyzer(picture).suitableForGpuRasterization());
+
+    canvas = recorder.beginRecording(100, 100);
+    {
+        const SkPath concaveClip = make_concave_path();
+        for (int i = 0; i < 50; ++i) {
+            canvas->clipPath(concaveClip, SkRegion::kIntersect_Op, true);
+            canvas->drawRect(SkRect::MakeWH(100, 100), SkPaint());
+        }
+    }
+    picture = recorder.finishRecordingAsPicture();
+    // ... but AA concave clips are not.
+    REPORTER_ASSERT(reporter, !SkPictureGpuAnalyzer(picture).suitableForGpuRasterization());
+
     // Nest the previous picture inside a new one.
     canvas = recorder.beginRecording(100, 100);
     {
         canvas->drawPicture(picture);
     }
     picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, !SkPictureGpuAnalyzer(picture).suitableForGpuRasterization());
 }
 
 #endif // SK_SUPPORT_GPU
@@ skipping 1099 matching lines @@
     REPORTER_ASSERT(r, !analyzer.suitableForGpuRasterization());
 
     analyzer.reset();
     REPORTER_ASSERT(r, analyzer.suitableForGpuRasterization());
 
     recorder.beginRecording(10, 10)->drawPicture(vetoPicture);
     sk_sp<SkPicture> nestedVetoPicture(recorder.finishRecordingAsPicture());
 
     analyzer.analyze(nestedVetoPicture.get());
     REPORTER_ASSERT(r, !analyzer.suitableForGpuRasterization());
+
+    analyzer.reset();
+
+    const SkPath convexClip = make_convex_path();
+    const SkPath concaveClip = make_concave_path();
+    for (int i = 0; i < 50; ++i) {
+        analyzer.analyzeClipPath(convexClip, SkRegion::kIntersect_Op, false);
+        analyzer.analyzeClipPath(convexClip, SkRegion::kIntersect_Op, true);
+        analyzer.analyzeClipPath(concaveClip, SkRegion::kIntersect_Op, false);
+    }
+    REPORTER_ASSERT(r, analyzer.suitableForGpuRasterization());
+
+    for (int i = 0; i < 50; ++i) {
+        analyzer.analyzeClipPath(concaveClip, SkRegion::kIntersect_Op, true);
+    }
+    REPORTER_ASSERT(r, !analyzer.suitableForGpuRasterization());
 }
 
 #endif // SK_SUPPORT_GPU