make the filter mode for GrTextureAccess an enum so we can plumb down

include/gpu/GrTextureAccess.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTextureAccess_DEFINED
 #define GrTextureAccess_DEFINED
 
 #include "GrNoncopyable.h"
 #include "SkRefCnt.h"
 #include "SkShader.h"
 
 class GrTexture;
 
 /**
  * Represents the filtering and tile modes used to access a texture. It is mostly used with
  * GrTextureAccess (defined below). Also, some of the texture cache methods require knowledge about
  * filtering and tiling to perform a cache lookup. If it wasn't for this latter usage this would
  * be folded into GrTextureAccess.
  */
 class GrTextureParams {
 public:
     GrTextureParams() {
         this->reset();
     }
+    
+    enum FilterMode {
+        kNone_FilterMode,
+        kBilerp_FilterMode,
+        kMipMap_FilterMode
+    };
 
-    GrTextureParams(SkShader::TileMode tileXAndY, bool bilerp) {
-        this->reset(tileXAndY, bilerp);
+    GrTextureParams(SkShader::TileMode tileXAndY, FilterMode filterMode) {
+        this->reset(tileXAndY, filterMode);
     }
 
-    GrTextureParams(SkShader::TileMode tileModes[2], bool bilerp) {
-        this->reset(tileModes, bilerp);
+    GrTextureParams(SkShader::TileMode tileModes[2], FilterMode filterMode) {
+        this->reset(tileModes, filterMode);
     }
 
     GrTextureParams(const GrTextureParams& params) {
         *this = params;
     }
 
     GrTextureParams& operator= (const GrTextureParams& params) {
         fTileModes[0] = params.fTileModes[0];
         fTileModes[1] = params.fTileModes[1];
-        fBilerp = params.fBilerp;
+        fFilterMode = params.fFilterMode;
         return *this;
     }
 
     void reset() {
-        this->reset(SkShader::kClamp_TileMode, false);
+        this->reset(SkShader::kClamp_TileMode, kNone_FilterMode);
     }
 
-    void reset(SkShader::TileMode tileXAndY, bool bilerp) {
+    void reset(SkShader::TileMode tileXAndY, FilterMode filterMode) {
         fTileModes[0] = fTileModes[1] = tileXAndY;
-        fBilerp = bilerp;
+        fFilterMode = filterMode;
     }
 
-    void reset(SkShader::TileMode tileModes[2], bool bilerp) {
+    void reset(SkShader::TileMode tileModes[2], FilterMode filterMode) {
         fTileModes[0] = tileModes[0];
         fTileModes[1] = tileModes[1];
-        fBilerp = bilerp;
+        fFilterMode = filterMode;
     }
 
     void setClampNoFilter() {
         fTileModes[0] = fTileModes[1] = SkShader::kClamp_TileMode;
-        fBilerp = false;
+        fFilterMode = kNone_FilterMode;
     }
 
     void setClamp() {
         fTileModes[0] = fTileModes[1] = SkShader::kClamp_TileMode;
     }
 
-    void setBilerp(bool bilerp) { fBilerp = bilerp; }
+    void setFilterMode(FilterMode filterMode) { fFilterMode = filterMode; }
 
     void setTileModeX(const SkShader::TileMode tm) { fTileModes[0] = tm; }
     void setTileModeY(const SkShader::TileMode tm) { fTileModes[1] = tm; }
     void setTileModeXAndY(const SkShader::TileMode tm) { fTileModes[0] = fTileModes[1] = tm; }
 
     SkShader::TileMode getTileModeX() const { return fTileModes[0]; }
 
     SkShader::TileMode getTileModeY() const { return fTileModes[1]; }
 
     bool isTiled() const {
         return SkShader::kClamp_TileMode != fTileModes[0] ||
                SkShader::kClamp_TileMode != fTileModes[1];
     }
 
-    bool isBilerp() const { return fBilerp; }
+    FilterMode filterMode() const { return fFilterMode; }
 
     bool operator== (const GrTextureParams& other) const {
         return fTileModes[0] == other.fTileModes[0] &&
                fTileModes[1] == other.fTileModes[1] &&
-               fBilerp == other.fBilerp;
+               fFilterMode == other.fFilterMode;
     }
 
     bool operator!= (const GrTextureParams& other) const { return !(*this == other); }
 
 private:
 
     SkShader::TileMode fTileModes[2];
-    bool               fBilerp;
+    FilterMode         fFilterMode;
 };
 
 /** A class representing the swizzle access pattern for a texture. Note that if the texture is
  *  an alpha-only texture then the alpha channel is substituted for other components. Any mangling
  *  to handle the r,g,b->a conversions for alpha textures is automatically included in the stage
  *  key. However, if a GrEffect uses different swizzles based on its input then it must
  *  consider that variation in its key-generation.
  */
 class GrTextureAccess : GrNoncopyable {
 public:
     /**
      * A default GrTextureAccess must have reset() called on it in a GrEffect subclass's
      * constructor if it will be accessible via GrEffect::textureAccess().
      */
     GrTextureAccess();
 
     /**
      * Uses the default swizzle, "rgba".
      */
     GrTextureAccess(GrTexture*, const GrTextureParams&);
     explicit GrTextureAccess(GrTexture*,
-                             bool bilerp = false,
+                             GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
                              SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
 
     /**
      * swizzle must be a string between one and four (inclusive) characters containing only 'r',
      * 'g', 'b',  and/or 'a'.
      */
     GrTextureAccess(GrTexture*, const char* swizzle, const GrTextureParams&);
     GrTextureAccess(GrTexture*,
                     const char* swizzle,
-                    bool bilerp = false,
+                    GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
                     SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
 
     void reset(GrTexture*, const GrTextureParams&);
     void reset(GrTexture*,
-               bool bilerp = false,
+               GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
                SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
     void reset(GrTexture*, const char* swizzle, const GrTextureParams&);
     void reset(GrTexture*,
                const char* swizzle,
-               bool bilerp = false,
+               GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
                SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
 
     bool operator== (const GrTextureAccess& other) const {
 #if GR_DEBUG
         // below assumes all chars in fSwizzle are initialized even if string is < 4 chars long.
         GrAssert(memcmp(fSwizzle, other.fSwizzle, sizeof(fSwizzle)-1) ==
                  strcmp(fSwizzle, other.fSwizzle));
 #endif
         return fParams == other.fParams &&
                (fTexture.get() == other.fTexture.get()) &&
@@ skipping 20 matching lines @@
 
     GrTextureParams         fParams;
     SkAutoTUnref<GrTexture> fTexture;
     uint32_t                fSwizzleMask;
     char                    fSwizzle[5];
 
     typedef GrNoncopyable INHERITED;
 };
 
 #endif