Revert of remove unused (by clients) SkUnitMapper

bench/GradientBench.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 "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkGradientShader.h"
 #include "SkPaint.h"
 #include "SkShader.h"
 #include "SkString.h"
+#include "SkUnitMapper.h"
 
 struct GradData {
     int             fCount;
     const SkColor*  fColors;
     const SkScalar* fPos;
     const char*     fName;
 };
 
 static const SkColor gColors[] = {
     SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
@@ skipping 11 matching lines @@
 // We have several special-cases depending on the number (and spacing) of colors, so
 // try to exercise those here.
 static const GradData gGradData[] = {
     { 2, gColors, NULL, "" },
     { 50, gColors, NULL, "_hicolor" }, // many color gradient
     { 3, gColors, NULL, "_3color" },
 };
 
 /// Ignores scale
 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, float scale) {
-    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos, data.fCount, tm);
+                            SkShader::TileMode tm, SkUnitMapper* mapper,
+                            float scale) {
+    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
+                                          data.fCount, tm, mapper);
 }
 
 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
-                            SkShader::TileMode tm, float scale) {
+                            SkShader::TileMode tm, SkUnitMapper* mapper,
+                            float scale) {
     SkPoint center;
     center.set(SkScalarAve(pts[0].fX, pts[1].fX),
                SkScalarAve(pts[0].fY, pts[1].fY));
     return SkGradientShader::CreateRadial(center, center.fX * scale,
                                           data.fColors,
-                                          data.fPos, data.fCount, tm);
+                                          data.fPos, data.fCount, tm, mapper);
 }
 
 /// Ignores scale
 static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
-                           SkShader::TileMode tm, float scale) {
+                           SkShader::TileMode tm, SkUnitMapper* mapper,
+                           float scale) {
     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);
+                                         data.fPos, data.fCount, mapper);
 }
 
 /// Ignores scale
 static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, float scale) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             float scale) {
     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);
+                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
 }
 
 /// Ignores scale
 static SkShader* MakeConical(const SkPoint pts[2], const GradData& data,
-                             SkShader::TileMode tm, float scale) {
+                             SkShader::TileMode tm, SkUnitMapper* mapper,
+                             float scale) {
     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::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
                                                    center0, (pts[1].fX - pts[0].fX) / 2,
-                                                   data.fColors, data.fPos, data.fCount, tm);
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper);
 }
 
 /// Ignores scale
 static SkShader* MakeConicalZeroRad(const SkPoint pts[2], const GradData& data,
-                                    SkShader::TileMode tm, float scale) {
+                                    SkShader::TileMode tm, SkUnitMapper* mapper,
+                                    float scale) {
     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::CreateTwoPointConical(center1, 0.0,
                                                    center0, (pts[1].fX - pts[0].fX) / 2,
-                                                   data.fColors, data.fPos, data.fCount, tm);
+                                                   data.fColors, data.fPos, data.fCount, tm, mapper);
 }
 
 /// Ignores scale
 static SkShader* MakeConicalOutside(const SkPoint pts[2], const GradData& data,
-                                    SkShader::TileMode tm, float scale) {
+                                    SkShader::TileMode tm, SkUnitMapper* mapper,
+                                    float scale) {
     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(center0, radius0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm);
+                                                   data.fCount, tm, mapper);
 }
 
 /// Ignores scale
 static SkShader* MakeConicalOutsideZeroRad(const SkPoint pts[2], const GradData& data,
-                                           SkShader::TileMode tm, float scale) {
+                                           SkShader::TileMode tm, SkUnitMapper* mapper,
+                                           float scale) {
     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(center0, 0.0,
                                                    center1, radius1,
                                                    data.fColors, data.fPos,
-                                                   data.fCount, tm);
+                                                   data.fCount, tm, mapper);
 }
 
 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
-                               SkShader::TileMode tm, float scale);
+                               SkShader::TileMode tm, SkUnitMapper* mapper,
+                               float scale);
 
 static const struct {
     GradMaker   fMaker;
     const char* fName;
 } gGrads[] = {
     { MakeLinear,                 "linear"  },
     { MakeRadial,                 "radial1" },
     { MakeSweep,                  "sweep"   },
     { Make2Radial,                "radial2" },
     { MakeConical,                "conical" },
@@ skipping 71 matching lines @@
             fName.appendf("_scale_%g", scale);
         }
 
         fName.append(data.fName);
 
         const SkPoint pts[2] = {
             { 0, 0 },
             { SkIntToScalar(W), SkIntToScalar(H) }
         };
 
-        fShader = gGrads[gradType].fMaker(pts, data, tm, scale);
+        fShader = gGrads[gradType].fMaker(pts, data, tm, NULL, scale);
         fGeomType = geomType;
     }
 
     virtual ~GradientBench() {
         fShader->unref();
     }
 
 protected:
     virtual const char* onGetName() {
         return fName.c_str();
@@ skipping 102 matching lines @@
             canvas->drawRect(r, paint);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 DEF_BENCH( return new Gradient2Bench(false); )
 DEF_BENCH( return new Gradient2Bench(true); )