Generate list of GPU contexts outside tests

tests/BlurTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkBlurDrawLooper.h"
@@ skipping 81 matching lines @@
                 refColor = bgColor;
             }
             if (refColor != testColor) {
                 return false;
             }
         }
     }
     return true;
 }
 
-static void test_blur_drawing(skiatest::Reporter* reporter) {
-
+DEF_TEST(BlurDrawing, reporter) {
     SkPaint paint;
     paint.setColor(SK_ColorGRAY);
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(SkIntToScalar(strokeWidth));
 
     SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5));
     for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) {
         SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style);
 
         const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag;
@@ skipping 155 matching lines @@
     bitmap.allocN32Pixels(resultCount, 30);
     SkCanvas canvas(bitmap);
 
     blur_path(&canvas, path, gaussianSigma);
     readback(&canvas, result, resultCount);
 }
 
 #if SK_SUPPORT_GPU
 #if 0
 // temporary disable; see below for explanation
-static bool gpu_blur_path(GrContextFactory* factory, const SkPath& path,
+static bool gpu_blur_path(GrContext* context, const SkPath& path,
                           SkScalar gaussianSigma,
                           int* result, int resultCount) {
-
-    GrContext* grContext = factory->get(GrContextFactory::kNative_GLContextType);
-    if (nullptr == grContext) {
-        return false;
-    }
-
     GrSurfaceDesc desc;
     desc.fConfig = kSkia8888_GrPixelConfig;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = resultCount;
     desc.fHeight = 30;
     desc.fSampleCnt = 0;
 
     SkAutoTUnref<GrTexture> texture(grContext->createTexture(desc, false, nullptr, 0));
     SkAutoTUnref<SkGpuDevice> device(new SkGpuDevice  (grContext, texture.get()));
     SkCanvas canvas(device.get());
@@ skipping 21 matching lines @@
         delta = first[i] - second[i];
         if (delta > tol || delta < -tol) {
             return false;
         }
     }
 
     return true;
 }
 
 // Test out the normal blur style with a wide range of sigmas
-static void test_sigma_range(skiatest::Reporter* reporter, GrContextFactory* factory) {
-
+DEF_GPUTEST_FOR_NATIVE_CONTEXT(BlurSigmaRange, reporter, context) {

[bsalomon, 2015/11/30 15:35:35]

Might as well make these do all rendering contexts. I don't think it was
purposely limited to the native context.

[Kimmo Kinnunen, 2015/12/01 06:57:14]

Done.

     static const int kSize = 100;
 
     // The geometry is offset a smidge to trigger:
     // https://code.google.com/p/chromium/issues/detail?id=282418
     SkPath rectPath;
     rectPath.addRect(0.3f, 0.3f, 100.3f, 100.3f);
 
     SkPoint polyPts[] = {
         { 0.3f, 0.3f },
         { 100.3f, 0.3f },
@@ skipping 17 matching lines @@
         cpu_blur_path(polyPath, sigma, generalCaseResult, kSize);
 
         ground_truth_2d(100, 100, sigma, groundTruthResult, kSize);
         brute_force_1d(-50.0f, 50.0f, sigma, bruteForce1DResult, kSize);
 
         REPORTER_ASSERT(reporter, match(rectSpecialCaseResult, bruteForce1DResult, kSize, 5));
         REPORTER_ASSERT(reporter, match(generalCaseResult, bruteForce1DResult, kSize, 15));
 #if SK_SUPPORT_GPU
 #if 0
         int gpuResult[kSize];
-        bool haveGPUResult = gpu_blur_path(factory, rectPath, sigma, gpuResult, kSize);
+        bool haveGPUResult = gpu_blur_path(context, rectPath, sigma, gpuResult, kSize);
         // Disabling this test for now -- I don't think it's a legit comparison.
         // Will continue to investigate this.
         if (haveGPUResult) {
             // 1 works everywhere but: Ubuntu13 & Nexus4
             REPORTER_ASSERT(reporter, match(gpuResult, bruteForce1DResult, kSize, 10));
         }
 #endif
 #endif
         REPORTER_ASSERT(reporter, match(groundTruthResult, bruteForce1DResult, kSize, 1));
 
@@ skipping 121 matching lines @@
     make_blur_layer(&builder, mf);
     test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, expectSuccess);
 
     // 3 layers is too many
     make_noop_layer(&builder);
     make_blur_layer(&builder, mf);
     make_noop_layer(&builder);
     test_delete_looper(reporter, builder.detachLooper(), sigma, style, quality, false);
 }
 
-static void test_asABlur(skiatest::Reporter* reporter) {
+DEF_TEST(BlurAsABlur, reporter) {
     const SkBlurStyle styles[] = {
         kNormal_SkBlurStyle, kSolid_SkBlurStyle, kOuter_SkBlurStyle, kInner_SkBlurStyle
     };
     const SkScalar sigmas[] = {
         // values <= 0 should not success for a blur
         -1, 0, 0.5f, 2
     };
 
     // Test asABlur for SkBlurMaskFilter
     //
@@ skipping 38 matching lines @@
             if (mf.get()) {
                 SkMaskFilter::BlurRec rec;
                 bool success = mf->asABlur(&rec);
                 REPORTER_ASSERT(reporter, !success);
             }
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-
-DEF_GPUTEST(Blur, reporter, factory) {
-    test_blur_drawing(reporter);
-    test_sigma_range(reporter, factory);
-    test_asABlur(reporter);
-}