Rework GrSamplerParams to be more compact and use its own wrap mode enum.

The main change is to make GrSamplerParams smaller by making its enums have byte-sized underlying types. The rest is cosmetic.

Change-Id: Ib71ea50612d24619a85e463826c6b8dfb9b445e3
Reviewed-on: https://skia-review.googlesource.com/43200
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index f0681a6..bfdbfdb 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -100,10 +100,9 @@
                 this->setupDfProcessor(this->viewMatrix(),
                                        fLuminanceColor, this->color(), std::move(proxy));
     } else {
-        GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode);
-        flushInfo.fGeometryProcessor =
-                GrBitmapTextGeoProc::Make(this->color(), std::move(proxy), params, maskFormat,
-                                          localMatrix, this->usesLocalCoords());
+        flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
+                this->color(), std::move(proxy), GrSamplerState::ClampNearest(), maskFormat,
+                localMatrix, this->usesLocalCoords());
     }
 
     flushInfo.fGlyphsToFlush = 0;
@@ -223,7 +222,6 @@
                                                            SkColor luminanceColor,
                                                            GrColor color,
                                                            sk_sp<GrTextureProxy> proxy) const {
-    GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kBilerp_FilterMode);
     bool isLCD = this->isLCD();
     // set up any flags
     uint32_t flags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
@@ -249,8 +247,9 @@
                 GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(
                         redCorrection, greenCorrection, blueCorrection);
 
-        return GrDistanceFieldLCDTextGeoProc::Make(color, viewMatrix, std::move(proxy), params,
-                                                   widthAdjust, flags, this->usesLocalCoords());
+        return GrDistanceFieldLCDTextGeoProc::Make(color, viewMatrix, std::move(proxy),
+                                                   GrSamplerState::ClampBilerp(), widthAdjust,
+                                                   flags, this->usesLocalCoords());
     } else {
 #ifdef SK_GAMMA_APPLY_TO_A8
         float correction = 0;
@@ -259,12 +258,13 @@
             correction = fDistanceAdjustTable->getAdjustment(lum >> kDistanceAdjustLumShift,
                                                              fUseGammaCorrectDistanceTable);
         }
-        return GrDistanceFieldA8TextGeoProc::Make(color, viewMatrix, std::move(proxy), params,
-                                                  correction, flags, this->usesLocalCoords());
+        return GrDistanceFieldA8TextGeoProc::Make(color, viewMatrix, std::move(proxy),
+                                                  GrSamplerState::ClampBilerp(), correction, flags,
+                                                  this->usesLocalCoords());
 #else
-        return GrDistanceFieldA8TextGeoProc::Make(color,
-                                                  viewMatrix, std::move(proxy),
-                                                  params, flags, this->usesLocalCoords());
+        return GrDistanceFieldA8TextGeoProc::Make(color, viewMatrix, std::move(proxy),
+                                                  GrSamplerState::ClampBilerp(), flags,
+                                                  this->usesLocalCoords());
 #endif
     }
 }
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 7e7a496..cfdf873 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -225,19 +225,15 @@
         // Setup GrGeometryProcessor
         GrDrawOpAtlas* atlas = fAtlas;
         if (fUsesDistanceField) {
-            GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kBilerp_FilterMode);
-
             uint32_t flags = 0;
             flags |= ctm.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
             flags |= ctm.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
             flags |= fGammaCorrect ? kGammaCorrect_DistanceFieldEffectFlag : 0;
 
             flushInfo.fGeometryProcessor = GrDistanceFieldPathGeoProc::Make(
-                    this->color(), this->viewMatrix(), atlas->getProxy(), params, flags,
-                    fHelper.usesLocalCoords());
+                    this->color(), this->viewMatrix(), atlas->getProxy(),
+                    GrSamplerState::ClampBilerp(), flags, fHelper.usesLocalCoords());
         } else {
-            GrSamplerParams params(SkShader::kClamp_TileMode, GrSamplerParams::kNone_FilterMode);
-
             SkMatrix invert;
             if (fHelper.usesLocalCoords()) {
                 if (!this->viewMatrix().invert(&invert)) {
@@ -249,9 +245,9 @@
                 invert.preTranslate(-fShapes[0].fTranslate.fX, -fShapes[0].fTranslate.fY);
             }
 
-            flushInfo.fGeometryProcessor =
-                    GrBitmapTextGeoProc::Make(this->color(), atlas->getProxy(), params,
-                                              kA8_GrMaskFormat, invert, fHelper.usesLocalCoords());
+            flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
+                    this->color(), atlas->getProxy(), GrSamplerState::ClampNearest(),
+                    kA8_GrMaskFormat, invert, fHelper.usesLocalCoords());
         }
 
         // allocate vertices
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index e16472a..3cb4dc0 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -37,7 +37,7 @@
     };
     static sk_sp<GrGeometryProcessor> Make(sk_sp<GrTextureProxy> proxy,
                                            sk_sp<GrColorSpaceXform> csxf,
-                                           GrSamplerParams::FilterMode filter) {
+                                           GrSamplerState::Filter filter) {
         return sk_sp<TextureGeometryProcessor>(
                 new TextureGeometryProcessor(std::move(proxy), std::move(csxf), filter));
     }
@@ -100,7 +100,7 @@
 
 private:
     TextureGeometryProcessor(sk_sp<GrTextureProxy> proxy, sk_sp<GrColorSpaceXform> csxf,
-                             GrSamplerParams::FilterMode filter)
+                             GrSamplerState::Filter filter)
             : fSampler(std::move(proxy), filter), fColorSpaceXform(std::move(csxf)) {
         this->initClassID<TextureGeometryProcessor>();
         fPositions =
@@ -125,7 +125,7 @@
 class TextureOp final : public GrMeshDrawOp {
 public:
     static std::unique_ptr<GrDrawOp> Make(sk_sp<GrTextureProxy> proxy,
-                                          GrSamplerParams::FilterMode filter, GrColor color,
+                                          GrSamplerState::Filter filter, GrColor color,
                                           const SkRect srcRect, const SkRect dstRect,
                                           const SkMatrix& viewMatrix, sk_sp<GrColorSpaceXform> csxf,
                                           bool allowSRBInputs) {
@@ -140,7 +140,8 @@
 
     SkString dumpInfo() const override {
         SkString str;
-        str.appendf("Filter: %d AllowSRGBInputs: %d\n", fFilter, fAllowSRGBInputs);
+        str.appendf("Filter: %d AllowSRGBInputs: %d\n", static_cast<int>(fFilter),
+                    fAllowSRGBInputs);
         str.appendf("# draws: %d\n", fDraws.count());
         for (int i = 0; i < fDraws.count(); ++i) {
             const Draw& draw = fDraws[i];
@@ -170,7 +171,7 @@
     DEFINE_OP_CLASS_ID
 
 private:
-    TextureOp(sk_sp<GrTextureProxy> proxy, GrSamplerParams::FilterMode filter, GrColor color,
+    TextureOp(sk_sp<GrTextureProxy> proxy, GrSamplerState::Filter filter, GrColor color,
               const SkRect& srcRect, const SkRect& dstRect, const SkMatrix& viewMatrix,
               sk_sp<GrColorSpaceXform> csxf, bool allowSRGBInputs)
             : INHERITED(ClassID())
@@ -298,7 +299,7 @@
     };
     SkSTArray<1, Draw, true> fDraws;
     GrTextureProxy* fProxy;
-    GrSamplerParams::FilterMode fFilter;
+    GrSamplerState::Filter fFilter;
     sk_sp<GrColorSpaceXform> fColorSpaceXform;
     // Used to track whether fProxy is ref'ed or has a pending IO after finalize() is called.
     bool fFinalized : 1;
@@ -310,7 +311,7 @@
 
 namespace GrTextureOp {
 
-std::unique_ptr<GrDrawOp> Make(sk_sp<GrTextureProxy> proxy, GrSamplerParams::FilterMode filter,
+std::unique_ptr<GrDrawOp> Make(sk_sp<GrTextureProxy> proxy, GrSamplerState::Filter filter,
                                GrColor color, const SkRect& srcRect, const SkRect& dstRect,
                                const SkMatrix& viewMatrix, sk_sp<GrColorSpaceXform> csxf,
                                bool allowSRGBInputs) {
@@ -341,8 +342,8 @@
     srcRect.fBottom = random->nextRangeScalar(0.f, proxy->height()) + proxy->height() / 2.f;
     SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random);
     GrColor color = SkColorToPremulGrColor(random->nextU());
-    GrSamplerParams::FilterMode filter = (GrSamplerParams::FilterMode)random->nextULessThan(
-            GrSamplerParams::kMipMap_FilterMode + 1);
+    GrSamplerState::Filter filter = (GrSamplerState::Filter)random->nextULessThan(
+            static_cast<uint32_t>(GrSamplerState::Filter::kMipMap) + 1);
     auto csxf = GrTest::TestColorXform(random);
     bool allowSRGBInputs = random->nextBool();
     return GrTextureOp::Make(std::move(proxy), filter, color, srcRect, rect, viewMatrix,
diff --git a/src/gpu/ops/GrTextureOp.h b/src/gpu/ops/GrTextureOp.h
index cf6a227..2aea02e 100644
--- a/src/gpu/ops/GrTextureOp.h
+++ b/src/gpu/ops/GrTextureOp.h
@@ -7,7 +7,7 @@
 
 #include "GrColor.h"
 #include "GrColorSpaceXform.h"
-#include "GrSamplerParams.h"
+#include "GrSamplerState.h"
 
 class GrDrawOp;
 class GrTextureProxy;
@@ -21,7 +21,7 @@
  * the rectangle to draw in local coords which will be transformed by 'viewMatrix' to be in device
  * space. 'viewMatrix' must be affine.
  */
-std::unique_ptr<GrDrawOp> Make(sk_sp<GrTextureProxy>, GrSamplerParams::FilterMode, GrColor,
+std::unique_ptr<GrDrawOp> Make(sk_sp<GrTextureProxy>, GrSamplerState::Filter, GrColor,
                                const SkRect& srcRect, const SkRect& dstRect,
                                const SkMatrix& viewMatrix, sk_sp<GrColorSpaceXform>,
                                bool allowSRGBInputs);