From 3a0f27916712bb3226874aeaa268e30f565880de Mon Sep 17 00:00:00 2001 From: tomhudson Date: Wed, 20 Aug 2014 05:29:41 -0700 Subject: Move the code over using the same template type approach previously used for willPlayBackBitmaps in http://skbug.com/2702. Also unifies that flag and this one into a struct so they and others can be computed together. The struct is stored const to enforce lifetime expectations. Adds a few new cases to the unit test. BUG=skia:2700 R=mtklein@google.com, reed@google.com, robertphillips@google.com, tomhudson@google.com Committed: https://skia.googlesource.com/skia/+/60c2a79cfa8ceebcbafc243407564dc71f5e3b4f Author: tomhudson@chromium.org Review URL: https://codereview.chromium.org/364823009 --- tests/PictureTest.cpp | 81 +++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 76 insertions(+), 5 deletions(-) (limited to 'tests/PictureTest.cpp') diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp index 61cc5021fc..e9b38d20a9 100644 --- a/tests/PictureTest.cpp +++ b/tests/PictureTest.cpp @@ -578,6 +578,43 @@ static void test_gatherpixelrefs(skiatest::Reporter* reporter) { } } +#define GENERATE_CANVAS(recorder, x) \ + (x) ? recorder.EXPERIMENTAL_beginRecording(100, 100) \ + : recorder.beginRecording(100,100); + +/* Hit a few SkPicture::Analysis cases not handled elsewhere. */ +static void test_analysis(skiatest::Reporter* reporter, bool useNewPath) { + SkPictureRecorder recorder; + + SkCanvas* canvas = GENERATE_CANVAS(recorder, useNewPath); + { + canvas->drawRect(SkRect::MakeWH(10, 10), SkPaint ()); + } + SkAutoTUnref picture(recorder.endRecording()); + REPORTER_ASSERT(reporter, !picture->willPlayBackBitmaps()); + + canvas = GENERATE_CANVAS(recorder, useNewPath); + { + SkPaint paint; + // CreateBitmapShader is too smart for us; an empty (or 1x1) bitmap shader + // gets optimized into a non-bitmap form, so we create a 2x2 bitmap here. + SkBitmap bitmap; + bitmap.allocPixels(SkImageInfo::MakeN32Premul(2, 2)); + bitmap.eraseColor(SK_ColorBLUE); + *(bitmap.getAddr32(0, 0)) = SK_ColorGREEN; + SkShader* shader = SkShader::CreateBitmapShader(bitmap, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode); + paint.setShader(shader)->unref(); + REPORTER_ASSERT(reporter, + shader->asABitmap(NULL, NULL, NULL) == SkShader::kDefault_BitmapType); + + canvas->drawRect(SkRect::MakeWH(10, 10), paint); + } + picture.reset(recorder.endRecording()); + REPORTER_ASSERT(reporter, picture->willPlayBackBitmaps()); +} + + static void test_gatherpixelrefsandrects(skiatest::Reporter* reporter) { const int IW = 32; const int IH = IW; @@ -706,11 +743,13 @@ static void rand_op(SkCanvas* canvas, SkRandom& rand) { } #if SK_SUPPORT_GPU -static void test_gpu_veto(skiatest::Reporter* reporter) { + +static void test_gpu_veto(skiatest::Reporter* reporter, + bool useNewPath) { SkPictureRecorder recorder; - SkCanvas* canvas = recorder.beginRecording(100, 100); + SkCanvas* canvas = GENERATE_CANVAS(recorder, useNewPath); { SkPath path; path.moveTo(0, 0); @@ -732,7 +771,7 @@ static void test_gpu_veto(skiatest::Reporter* reporter) { REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL, &reason)); REPORTER_ASSERT(reporter, NULL != reason); - canvas = recorder.beginRecording(100, 100); + canvas = GENERATE_CANVAS(recorder, useNewPath); { SkPath path; @@ -754,7 +793,7 @@ static void test_gpu_veto(skiatest::Reporter* reporter) { // A lot of AA concave paths currently render an SkPicture undesireable for GPU rendering REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL)); - canvas = recorder.beginRecording(100, 100); + canvas = GENERATE_CANVAS(recorder, useNewPath); { SkPath path; @@ -777,8 +816,37 @@ static void test_gpu_veto(skiatest::Reporter* reporter) { picture.reset(recorder.endRecording()); // hairline stroked AA concave paths are fine for GPU rendering REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL)); + + canvas = GENERATE_CANVAS(recorder, useNewPath); + { + SkPaint paint; + SkScalar intervals [] = { 10, 20 }; + SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25); + paint.setPathEffect(pe)->unref(); + + SkPoint points [2] = { { 0, 0 }, { 100, 0 } }; + canvas->drawPoints(SkCanvas::kLines_PointMode, 2, points, paint); + } + picture.reset(recorder.endRecording()); + // fast-path dashed effects are fine for GPU rendering ... + REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL)); + + canvas = GENERATE_CANVAS(recorder, useNewPath); + { + SkPaint paint; + SkScalar intervals [] = { 10, 20 }; + SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25); + paint.setPathEffect(pe)->unref(); + + canvas->drawRect(SkRect::MakeWH(10, 10), paint); + } + picture.reset(recorder.endRecording()); + // ... but only when applied to drawPoint() calls + REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL)); } +#undef GENERATE_CANVAS + static void test_gpu_picture_optimization(skiatest::Reporter* reporter, GrContextFactory* factory) { for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) { @@ -1617,9 +1685,12 @@ DEF_TEST(Picture, reporter) { test_unbalanced_save_restores(reporter); test_peephole(); #if SK_SUPPORT_GPU - test_gpu_veto(reporter); + test_gpu_veto(reporter, false); + test_gpu_veto(reporter, true); #endif test_has_text(reporter); + test_analysis(reporter, false); + test_analysis(reporter, true); test_gatherpixelrefs(reporter); test_gatherpixelrefsandrects(reporter); test_bitmap_with_encoded_data(reporter); -- cgit v1.2.3