Remove unused (by clients) SkUnitMapper

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 22 matching lines @@
 static const GradData gGradData[] = {
     { 2, gColors, NULL },
     { 2, gColors, gPos0 },
     { 2, gColors, gPos1 },
     { 5, gColors, NULL },
     { 5, gColors, gPos2 },
     { 4, gColorClamp, gPosClamp }
 };
 
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, SkUnitMapper* mapper,
-                            const SkMatrix& localMatrix) {
+                            SkShader::TileMode tm, const SkMatrix& localMatrix) {
     return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
-                                          data.fCount, tm, mapper, 0, &localMatrix);
+                                          data.fCount, tm, 0, &localMatrix);
 }
 
 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, SkUnitMapper* mapper,
-                            const SkMatrix& localMatrix) {
+                            SkShader::TileMode tm, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
-                                          data.fPos, data.fCount, tm, mapper, 0, &localMatrix);
+                                          data.fPos, data.fCount, tm, 0, &localMatrix);
 }
 
 static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
-                           SkShader::TileMode, SkUnitMapper* mapper,
-                           const SkMatrix& localMatrix) {
+                           SkShader::TileMode, const SkMatrix& localMatrix) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
-                                         data.fPos, data.fCount, mapper, 0, &localMatrix);
+                                         data.fPos, data.fCount, 0, &localMatrix);
 }
 
 static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper,
-                             const SkMatrix& localMatrix) {
+                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
     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,
-                                                  data.fColors, data.fPos, data.fCount, tm, mapper,
+                                                  data.fColors, data.fPos, data.fCount, tm,
                                                   0, &localMatrix);
 }
 
 static SkShader* Make2Conical(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, SkUnitMapper* mapper,
-                             const SkMatrix& localMatrix) {
+                             SkShader::TileMode tm, const SkMatrix& localMatrix) {
     SkPoint center0, center1;
     SkScalar radius0 = SkScalarDiv(pts[1].fX - pts[0].fX, 10);
     SkScalar radius1 = SkScalarDiv(pts[1].fX - pts[0].fX, 3);
     center0.set(pts[0].fX + radius0, pts[0].fY + radius0);
     center1.set(pts[1].fX - radius1, pts[1].fY - radius1);
     return SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                    center0, radius0,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm, mapper,
-                                                   0, &localMatrix);
+                                                   data.fCount, tm, 0, &localMatrix);
 }
 
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                               SkShader::TileMode tm, SkUnitMapper* mapper,
-                               const SkMatrix& localMatrix);
+                               SkShader::TileMode tm, const SkMatrix& localMatrix);
 static const GradMaker gGradMakers[] = {
     MakeLinear, MakeRadial, MakeSweep, Make2Radial, Make2Conical
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GradientsGM : public GM {
 public:
     GradientsGM() {
         this->setBGColor(0xFFDDDDDD);
@@ skipping 25 matching lines @@
         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, NULL, scale);
+                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);
         }
     }
@@ skipping 37 matching lines @@
             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(SkScalarDiv(SkIntToScalar((unsigned) i+1),
                                       SkIntToScalar(500)));
                 perspective.setSkewX(SkScalarDiv(SkIntToScalar((unsigned) i+1),
                                      SkIntToScalar(10)));
 
-                SkShader* shader = gGradMakers[j](pts, gGradData[i], tm, NULL, perspective);
+                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);
         }
     }
@@ skipping 104 matching lines @@
         SkRect r = { 0, 0, SkIntToScalar(100), SkIntToScalar(300) };
         SkPaint paint;
         paint.setAntiAlias(true);
 
         SkPoint center;
         center.iset(0, 300);
         canvas->translate(SkIntToScalar(20), SkIntToScalar(20));
         SkShader* shader = SkGradientShader::CreateRadial(
             SkPoint(center),
             SkIntToScalar(200), gColors, NULL, 5,
-            SkShader::kClamp_TileMode, NULL);
+            SkShader::kClamp_TileMode);
         paint.setShader(shader);
         canvas->drawRect(r, paint);
         shader->unref();
     }
 
 private:
     typedef GM INHERITED;
 };
 
 /// Checks quality of large radial gradients, which may display
@@ skipping 74 matching lines @@
         center.set(cx, cy);
 
         // We can either interpolate endpoints and premultiply each point (default, more precision),
         // or premultiply the endpoints first, avoiding the need to premultiply each point (cheap).
         const uint32_t flags[] = { 0, SkGradientShader::kInterpolateColorsInPremul_Flag };
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(flags); i++) {
             SkAutoTUnref<SkShader> sweep(
                     SkGradientShader::CreateSweep(cx, cy, sweep_colors,
                                                   NULL, SK_ARRAY_COUNT(sweep_colors),
-                                                  NULL, flags[i]));
+                                                  flags[i], NULL));
             SkAutoTUnref<SkShader> radial1(
                     SkGradientShader::CreateRadial(center, radius, colors1,
                                                    NULL, SK_ARRAY_COUNT(colors1),
                                                    SkShader::kClamp_TileMode,
-                                                   NULL, flags[i]));
+                                                   flags[i], NULL));
             SkAutoTUnref<SkShader> radial2(
                     SkGradientShader::CreateRadial(center, radius, colors2,
                                                    NULL, SK_ARRAY_COUNT(colors2),
                                                    SkShader::kClamp_TileMode,
-                                                   NULL, flags[i]));
+                                                   flags[i], NULL));
             paint1.setShader(sweep);
             paint2.setShader(radial1);
             paint3.setShader(radial2);
 
             canvas->drawCircle(cx, cy, radius, paint1);
             canvas->drawCircle(cx, cy, radius, paint3);
             canvas->drawCircle(cx, cy, radius, paint2);
 
             canvas->translate(400, 0);
         }
@@ skipping 19 matching lines @@
 
 static GM* MyFactory5(void*) { return new GradientsLocalPerspectiveGM; }
 static GMRegistry reg5(MyFactory5);
 
 static GM* MyFactory6(void*) { return new GradientsViewPerspectiveGM; }
 static GMRegistry reg6(MyFactory6);
 
 static GM* MyFactory7(void*) { return new RadialGradient2GM; }
 static GMRegistry reg7(MyFactory7);
 }