Remove SK_SUPPORT_LEGACY_GRADIENT_DITHERING from Skia proper

gm/gradients.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 "gm.h"
 #include "SkGradientShader.h"
 
@@ skipping 82 matching lines @@
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
                                SkShader::TileMode tm, const SkMatrix& localMatrix);
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GradientsGM : public GM {
 public:
-    GradientsGM() {
+    GradientsGM(bool dither) : fDither(dither) {
         this->setBGColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
     }
 
 protected:
 
     SkString onShortName() {
-        return SkString("gradients");
+        return SkString(fDither ? "gradients" : "gradients_nodither");
     }
 
     virtual SkISize onISize() { return SkISize::Make(840, 815); }
 
     virtual void onDraw(SkCanvas* canvas) {
 
         SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(100), SkIntToScalar(100) }
         };
         SkShader::TileMode tm = SkShader::kClamp_TileMode;
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
         SkPaint paint;
         paint.setAntiAlias(true);
+        paint.setDither(fDither);
 
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
                 SkMatrix scale = SkMatrix::I();
 
                 if (i == 5) { // if the clamp case
                     scale.setScale(0.5f, 0.5f);
                     scale.postTranslate(25.f, 25.f);
                 }
 
                 SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, scale);
 
                 paint.setShader(shader);
                 canvas->drawRect(r, paint);
                 shader->unref();
                 canvas->translate(0, SkIntToScalar(120));
             }
             canvas->restore();
             canvas->translate(SkIntToScalar(120), 0);
         }
     }
 
+protected:
+    bool fDither;
+
 private:
     typedef GM INHERITED;
 };
-DEF_GM( return new GradientsGM; )
+DEF_GM( return new GradientsGM(true); )
+DEF_GM( return new GradientsGM(false); )
 
 // Based on the original gradient slide, but with perspective applied to the
 // gradient shaders' local matrices
 class GradientsLocalPerspectiveGM : public GM {
 public:
-    GradientsLocalPerspectiveGM() {
+    GradientsLocalPerspectiveGM(bool dither) : fDither(dither) {
         this->setBGColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
     }
 
 protected:
 
     SkString onShortName() {
-        return SkString("gradients_local_perspective");
+        return SkString(fDither ? "gradients_local_perspective" :
+                                  "gradients_local_perspective_nodither");
     }
 
     virtual SkISize onISize() { return SkISize::Make(840, 815); }
 
     virtual void onDraw(SkCanvas* canvas) {
 
         SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(100), SkIntToScalar(100) }
         };
         SkShader::TileMode tm = SkShader::kClamp_TileMode;
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(100) };
         SkPaint paint;
         paint.setAntiAlias(true);
+        paint.setDither(fDither);
 
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         for (size_t i = 0; i < SK_ARRAY_COUNT(gGradData); i++) {
             canvas->save();
             for (size_t j = 0; j < SK_ARRAY_COUNT(gGradMakers); j++) {
                 // apply an increasing y perspective as we move to the right
                 SkMatrix perspective;
                 perspective.setIdentity();
                 perspective.setPerspY(SkIntToScalar(i+1) / 500);
                 perspective.setSkewX(SkIntToScalar(i+1) / 10);
 
                 SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, perspective);
 
                 paint.setShader(shader);
                 canvas->drawRect(r, paint);
                 shader->unref();
                 canvas->translate(0, SkIntToScalar(120));
             }
             canvas->restore();
             canvas->translate(SkIntToScalar(120), 0);
         }
     }
 
 private:
+    bool fDither;
+
     typedef GM INHERITED;
 };
-DEF_GM( return new GradientsLocalPerspectiveGM; )
+DEF_GM( return new GradientsLocalPerspectiveGM(true); )
+DEF_GM( return new GradientsLocalPerspectiveGM(false); )
 
 // Based on the original gradient slide, but with perspective applied to
 // the view matrix
 class GradientsViewPerspectiveGM : public GradientsGM {
+public:
+    GradientsViewPerspectiveGM(bool dither) : INHERITED(dither) { }
+
 protected:
     SkString onShortName() {
-        return SkString("gradients_view_perspective");
+        return SkString(fDither ? "gradients_view_perspective" :
+                                  "gradients_view_perspective_nodither");
     }
 
     virtual SkISize onISize() { return SkISize::Make(840, 500); }
 
     virtual void onDraw(SkCanvas* canvas) {
         SkMatrix perspective;
         perspective.setIdentity();
         perspective.setPerspY(0.001f);
         perspective.setSkewX(SkIntToScalar(8) / 25);
         canvas->concat(perspective);
         INHERITED::onDraw(canvas);
     }
 
 private:
     typedef GradientsGM INHERITED;
 };
-DEF_GM( return new GradientsViewPerspectiveGM; )
+DEF_GM( return new GradientsViewPerspectiveGM(true); )
+DEF_GM( return new GradientsViewPerspectiveGM(false); )
 
 /*
  Inspired by this <canvas> javascript, where we need to detect that we are not
  solving a quadratic equation, but must instead solve a linear (since our X^2
  coefficient is 0)
 
  ctx.fillStyle = '#f00';
  ctx.fillRect(0, 0, 100, 50);
 
  var g = ctx.createRadialGradient(-80, 25, 70, 0, 25, 150);
  g.addColorStop(0, '#f00');
  g.addColorStop(0.01, '#0f0');
  g.addColorStop(0.99, '#0f0');
  g.addColorStop(1, '#f00');
  ctx.fillStyle = g;
  ctx.fillRect(0, 0, 100, 50);
  */
 class GradientsDegenrate2PointGM : public GM {
 public:
-    GradientsDegenrate2PointGM() {}
+    GradientsDegenrate2PointGM(bool dither) : fDither(dither) {}
 
 protected:
     SkString onShortName() {
-        return SkString("gradients_degenerate_2pt");
+        return SkString(fDither ? "gradients_degenerate_2pt" : "gradients_degenerate_2pt_nodither");
     }
 
     virtual SkISize onISize() { return SkISize::Make(320, 320); }
 
     void drawBG(SkCanvas* canvas) {
         canvas->drawColor(SK_ColorBLUE);
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         this->drawBG(canvas);
 
         SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorGREEN, SK_ColorRED };
         SkScalar pos[] = { 0, 0.01f, 0.99f, SK_Scalar1 };
         SkPoint c0;
         c0.iset(-80, 25);
         SkScalar r0 = SkIntToScalar(70);
         SkPoint c1;
         c1.iset(0, 25);
         SkScalar r1 = SkIntToScalar(150);
         SkShader* s = SkGradientShader::CreateTwoPointConical(c0, r0, c1, r1, colors,
                                                               pos, SK_ARRAY_COUNT(pos),
                                                               SkShader::kClamp_TileMode);
         SkPaint paint;
+        paint.setDither(fDither);
         paint.setShader(s)->unref();
         canvas->drawPaint(paint);
     }
 
 private:
+    bool fDither;
+
     typedef GM INHERITED;
 };
-DEF_GM( return new GradientsDegenrate2PointGM; )
+DEF_GM( return new GradientsDegenrate2PointGM(true); )
+DEF_GM( return new GradientsDegenrate2PointGM(false); )
 
 /// Tests correctness of *optimized* codepaths in gradients.
 
 class ClampedGradientsGM : public GM {
 public:
-    ClampedGradientsGM() {}
+    ClampedGradientsGM(bool dither) : fDither(dither) {}
 
 protected:
-    SkString onShortName() { return SkString("clamped_gradients"); }
+    SkString onShortName() {
+        return SkString(fDither ? "clamped_gradients" : "clamped_gradients_nodither");
+    }
 
     virtual SkISize onISize() { return SkISize::Make(640, 510); }
 
     void drawBG(SkCanvas* canvas) {
         canvas->drawColor(sk_tool_utils::color_to_565(0xFFDDDDDD));
     }
 
     virtual void onDraw(SkCanvas* canvas) {
         this->drawBG(canvas);
 
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(300) };
         SkPaint paint;
+        paint.setDither(fDither);
         paint.setAntiAlias(true);
 
         SkPoint center;
         center.iset(0, 300);
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         SkShader* shader = SkGradientShader::CreateRadial(
             SkPoint(center),
             SkIntToScalar(200), gColors, nullptr, 5,
             SkShader::kClamp_TileMode);
         paint.setShader(shader);
         canvas->drawRect(r, paint);
         shader->unref();
     }
 
 private:
+    bool fDither;
+
     typedef GM INHERITED;
 };
-DEF_GM( return new ClampedGradientsGM; )
+DEF_GM( return new ClampedGradientsGM(true); )
+DEF_GM( return new ClampedGradientsGM(false); )
 
 /// Checks quality of large radial gradients, which may display
 /// some banding.
 
 class RadialGradientGM : public GM {
 public:
     RadialGradientGM() {}
 
 protected:
 
@@ skipping 26 matching lines @@
         };
         canvas->drawRect(r, paint);
     }
 private:
     typedef GM INHERITED;
 };
 DEF_GM( return new RadialGradientGM; )
 
 class RadialGradient2GM : public GM {
 public:
-    RadialGradient2GM() {}
+    RadialGradient2GM(bool dither) : fDither(dither) {}
 
 protected:
 
-    SkString onShortName() override { return SkString("radial_gradient2"); }
+    SkString onShortName() override {
+        return SkString(fDither ? "radial_gradient2" : "radial_gradient2_nodither");
+    }
+
     SkISize onISize() override { return SkISize::Make(800, 400); }
     void drawBG(SkCanvas* canvas) {
         canvas->drawColor(0xFF000000);
     }
 
     // Reproduces the example given in bug 7671058.
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint1, paint2, paint3;
         paint1.setStyle(SkPaint::kFill_Style);
         paint2.setStyle(SkPaint::kFill_Style);
@@ skipping 21 matching lines @@
                     SkGradientShader::CreateRadial(center, radius, colors1,
                                                    nullptr, SK_ARRAY_COUNT(colors1),
                                                    SkShader::kClamp_TileMode,
                                                    flags[i], nullptr));
             SkAutoTUnref<SkShader> radial2(
                     SkGradientShader::CreateRadial(center, radius, colors2,
                                                    nullptr, SK_ARRAY_COUNT(colors2),
                                                    SkShader::kClamp_TileMode,
                                                    flags[i], nullptr));
             paint1.setShader(sweep);
+            paint1.setDither(fDither);
             paint2.setShader(radial1);
+            paint2.setDither(fDither);
             paint3.setShader(radial2);
+            paint3.setDither(fDither);
 
             canvas->drawCircle(cx, cy, radius, paint1);
             canvas->drawCircle(cx, cy, radius, paint3);
             canvas->drawCircle(cx, cy, radius, paint2);
 
             canvas->translate(400, 0);
         }
     }
 
 private:
+    bool fDither;
+
     typedef GM INHERITED;
 };
-DEF_GM( return new RadialGradient2GM; )
+DEF_GM( return new RadialGradient2GM(true); )
+DEF_GM( return new RadialGradient2GM(false); )
 
 // Shallow radial (shows banding on raster)
 class RadialGradient3GM : public GM {
-    SkAutoTUnref<SkShader> fShader;
+public:
+    RadialGradient3GM(bool dither) : fDither(dither) { }
 
 protected:
-    SkString onShortName() override { return SkString("radial_gradient3"); }
+    SkString onShortName() override {
+        return SkString(fDither ? "radial_gradient3" : "radial_gradient3_nodither");
+    }
 
     SkISize onISize() override { return SkISize::Make(500, 500); }
 
     bool runAsBench() const override { return true; }
 
     void onOnceBeforeDraw() override {
         const SkPoint center = { 0, 0 };
         const SkScalar kRadius = 3000;
         const SkColor gColors[] = { 0xFFFFFFFF, 0xFF000000 };
         fShader.reset(SkGradientShader::CreateRadial(center, kRadius, gColors, nullptr, 2,
                                                      SkShader::kClamp_TileMode));
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setShader(fShader);
+        paint.setDither(fDither);
         canvas->drawRect(SkRect::MakeWH(500, 500), paint);
     }
     
 private:
+    SkAutoTUnref<SkShader> fShader;
+    bool fDither;
+
     typedef GM INHERITED;
 };
-DEF_GM( return new RadialGradient3GM; )
+DEF_GM( return new RadialGradient3GM(true); )
+DEF_GM( return new RadialGradient3GM(false); )
 
 class RadialGradient4GM : public GM {
-    SkAutoTUnref<SkShader> fShader;
+public:
+    RadialGradient4GM(bool dither) : fDither(dither) { }
 
 protected:
-    SkString onShortName() override { return SkString("radial_gradient4"); }
+    SkString onShortName() override {
+        return SkString(fDither ? "radial_gradient4" : "radial_gradient4_nodither");
+    }
 
     SkISize onISize() override { return SkISize::Make(500, 500); }
 
     void onOnceBeforeDraw() override {
         const SkPoint center = { 250, 250 };
         const SkScalar kRadius = 250;
         const SkColor colors[] = { SK_ColorRED, SK_ColorRED, SK_ColorWHITE, SK_ColorWHITE,
                 SK_ColorRED };
         const SkScalar pos[] = { 0, .4f, .4f, .8f, .8f, 1 };
         fShader.reset(SkGradientShader::CreateRadial(center, kRadius, colors, pos, 
                 SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode));
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setAntiAlias(true);
+        paint.setDither(fDither);
         paint.setShader(fShader);
         canvas->drawRect(SkRect::MakeWH(500, 500), paint);
     }
     
 private:
+    SkAutoTUnref<SkShader> fShader;
+    bool fDither;
+
     typedef GM INHERITED;
 };
-DEF_GM( return new RadialGradient4GM; )
+DEF_GM( return new RadialGradient4GM(true); )
+DEF_GM( return new RadialGradient4GM(false); )
 
 class LinearGradientGM : public GM {
-    SkAutoTUnref<SkShader> fShader[100];
+public:
+    LinearGradientGM(bool dither) : fDither(dither) { }
 
 protected:
-    SkString onShortName() override { return SkString("linear_gradient"); }
+    SkString onShortName() override {
+        return SkString(fDither ? "linear_gradient" : "linear_gradient_nodither");
+    }
+
     const SkScalar kWidthBump = 30.f;
     const SkScalar kHeight = 5.f;
     const SkScalar kMinWidth = 540.f;
 
     SkISize onISize() override { return SkISize::Make(500, 500); }
 
     void onOnceBeforeDraw() override {
         SkPoint pts[2] = { {0, 0}, {0, 0} };
         const SkColor colors[] = { SK_ColorWHITE, SK_ColorWHITE, 0xFF008200, 0xFF008200,
                 SK_ColorWHITE, SK_ColorWHITE };
         const SkScalar unitPos[] = { 0, 50, 70, 500, 540 };
         SkScalar pos[6];
         pos[5] = 1;
         for (int index = 0; index < (int) SK_ARRAY_COUNT(fShader); ++index) {
             pts[1].fX = 500.f + index * kWidthBump;
             for (int inner = 0; inner < (int) SK_ARRAY_COUNT(unitPos); ++inner) {
                 pos[inner] = unitPos[inner] / (kMinWidth + index * kWidthBump);
             }
             fShader[index].reset(SkGradientShader::CreateLinear(pts, colors, pos, 
                     SK_ARRAY_COUNT(gColors), SkShader::kClamp_TileMode));
         }
     }
 
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setAntiAlias(true);
+        paint.setDither(fDither);
         for (int index = 0; index < (int) SK_ARRAY_COUNT(fShader); ++index) {
             paint.setShader(fShader[index]);
             canvas->drawRect(SkRect::MakeLTRB(0, index * kHeight, kMinWidth + index * kWidthBump,
                     (index + 1) * kHeight), paint);
         }
     }
     
 private:
+    SkAutoTUnref<SkShader> fShader[100];
+    bool fDither;
+
     typedef GM INHERITED;
 };
-DEF_GM( return new LinearGradientGM; )
+DEF_GM( return new LinearGradientGM(true); )
+DEF_GM( return new LinearGradientGM(false); )
 
 }