modifying blur gms to test with shader too

gm/blurrect.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 "gm.h"
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
@@ skipping 37 matching lines @@
     rect.offset(7, -7);
 
     path.addRect(rect);
     path.setFillType(SkPath::kEvenOdd_FillType);
 
     canvas->drawPath(path, p);
 }
 
 #include "SkGradientShader.h"
 
+/*
+ * Spits out a dummy gradient to test blur with shader on paint
+ */
+static SkShader* MakeRadial() {
+    SkPoint pts[2] = {
+        { 0, 0 },
+        { SkIntToScalar(100), SkIntToScalar(100) }
+    };
+    SkShader::TileMode tm = SkShader::kClamp_TileMode;
+    const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, };
+    const SkScalar pos[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
+    SkMatrix scale;
+    scale.setScale(0.5f, 0.5f);
+    scale.postTranslate(25.f, 25.f);
+    SkPoint center0, center1;
+    center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
+                SkScalarAve(pts[0].fY, pts[1].fY));
+    center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
+                SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
+    return SkGradientShader::CreateTwoPointRadial(center1, (pts[1].fX - pts[0].fX) / 7,
+                                                  center0, (pts[1].fX - pts[0].fX) / 2,
+                                                  colors, pos, SK_ARRAY_COUNT(colors), tm,
+                                                  0, &scale);
+}
+
 typedef void (*PaintProc)(SkPaint*, SkScalar width);
 
 class BlurRectGM : public skiagm::GM {
       SkAutoTUnref<SkMaskFilter> fMaskFilters[kLastEnum_SkBlurStyle + 1];
       SkString  fName;
       SkAlpha   fAlpha;
 public:
     BlurRectGM(const char name[], U8CPU alpha)
         : fName(name)
         , fAlpha(SkToU8(alpha)) {
     }
 
 protected:
     virtual void onOnceBeforeDraw() SK_OVERRIDE {
         for (int i = 0; i <= kLastEnum_SkBlurStyle; ++i) {
             fMaskFilters[i].reset(SkBlurMaskFilter::Create((SkBlurStyle)i,
                                   SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(STROKE_WIDTH/2)),
                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
         }
     }
 
     virtual SkString onShortName() {
         return fName;
     }
 
     virtual SkISize onISize() {
-        return SkISize::Make(440, 820);
+        return SkISize::Make(860, 820);
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         canvas->translate(STROKE_WIDTH*3/2, STROKE_WIDTH*3/2);
 
         SkRect  r = { 0, 0, 100, 50 };
         SkScalar scales[] = { SK_Scalar1, 0.6f };
 
         for (size_t s = 0; s < SK_ARRAY_COUNT(scales); ++s) {
             canvas->save();
             for (size_t f = 0; f < SK_ARRAY_COUNT(fMaskFilters); ++f) {
                 SkPaint paint;
                 paint.setMaskFilter(fMaskFilters[f]);
                 paint.setAlpha(fAlpha);
 
+                SkPaint paintWithRadial = paint;
+                paintWithRadial.setShader(MakeRadial())->unref();
+
                 static const Proc procs[] = {
                     fill_rect, draw_donut, draw_donut_skewed
                 };
 
                 canvas->save();
                 canvas->scale(scales[s], scales[s]);
                 this->drawProcs(canvas, r, paint, false, procs, SK_ARRAY_COUNT(procs));
                 canvas->translate(r.width() * 4/3, 0);
+                this->drawProcs(canvas, r, paintWithRadial, false, procs, SK_ARRAY_COUNT(procs));
+                canvas->translate(r.width() * 4/3, 0);
                 this->drawProcs(canvas, r, paint, true, procs, SK_ARRAY_COUNT(procs));
+                canvas->translate(r.width() * 4/3, 0);
+                this->drawProcs(canvas, r, paintWithRadial, true, procs, SK_ARRAY_COUNT(procs));
                 canvas->restore();
 
                 canvas->translate(0, SK_ARRAY_COUNT(procs) * r.height() * 4/3 * scales[s]);
             }
             canvas->restore();
-            canvas->translate(2 * r.width() * 4/3 * scales[s], 0);
+            canvas->translate(4 * r.width() * 4/3 * scales[s], 0);
         }
     }
 
-    virtual uint32_t onGetFlags() const { return kSkipPipe_Flag; }
+    virtual uint32_t onGetFlags() const { return kSkipPipe_Flag | kSkipTiled_Flag; }
 
 private:
     void drawProcs(SkCanvas* canvas, const SkRect& r, const SkPaint& paint,
                    bool doClip, const Proc procs[], size_t procsCount) {
         SkAutoCanvasRestore acr(canvas, true);
         for (size_t i = 0; i < procsCount; ++i) {
             if (doClip) {
                 SkRect clipRect(r);
                 clipRect.inset(STROKE_WIDTH/2, STROKE_WIDTH/2);
                 canvas->save();
@@ skipping 256 matching lines @@
     }
 private:
     typedef BlurRectCompareGM INHERITED;
 };
 
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new BlurRectGM("blurrects", 0xFF);)
 DEF_GM(return new BlurRectDirectGM("blurrect_gallery");)