Better (?) interface for controlling sRGB-ness of mipmaps on GrTexture

src/gpu/gl/GrGLGpu.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 "GrGLGpu.h"
 #include "GrGLBuffer.h"
 #include "GrGLGLSL.h"
@@ skipping 3174 matching lines @@
 
     if (GrTextureParams::kMipMap_FilterMode == filterMode) {
         if (!this->caps()->mipMapSupport() || GrPixelConfigIsCompressed(texture->config())) {
             filterMode = GrTextureParams::kBilerp_FilterMode;
         }
     }
 
     newTexParams.fMinFilter = glMinFilterModes[filterMode];
     newTexParams.fMagFilter = glMagFilterModes[filterMode];
 
-    bool enableSRGBDecode = false;
     if (GrPixelConfigIsSRGB(texture->config())) {
-        enableSRGBDecode = allowSRGBInputs;
-
-        newTexParams.fSRGBDecode = enableSRGBDecode ? GR_GL_DECODE_EXT : GR_GL_SKIP_DECODE_EXT;
+        newTexParams.fSRGBDecode = allowSRGBInputs ? GR_GL_DECODE_EXT : GR_GL_SKIP_DECODE_EXT;
         if (setAll || newTexParams.fSRGBDecode != oldTexParams.fSRGBDecode) {
             this->setTextureUnit(unitIdx);
             GL_CALL(TexParameteri(target, GR_GL_TEXTURE_SRGB_DECODE_EXT, newTexParams.fSRGBDecode));
         }
     }
 
 #ifdef SK_DEBUG
     // We were supposed to ensure MipMaps were up-to-date and built correctly before getting here.
     if (GrTextureParams::kMipMap_FilterMode == filterMode) {
         SkASSERT(!texture->texturePriv().mipMapsAreDirty());
         if (GrPixelConfigIsSRGB(texture->config())) {
-            SkASSERT(texture->texturePriv().mipMapsAreSRGBCorrect() == enableSRGBDecode);
+            SkSourceGammaTreatment gammaTreatment = allowSRGBInputs ?
+                SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
+            SkASSERT(texture->texturePriv().gammaTreatment() == gammaTreatment);
         }
     }
 #endif
 
     newTexParams.fMaxMipMapLevel = texture->texturePriv().maxMipMapLevel();
 
     newTexParams.fWrapS = tile_to_gl_wrap(params.getTileModeX());
     newTexParams.fWrapT = tile_to_gl_wrap(params.getTileModeY());
     get_tex_param_swizzle(texture->config(), this->glCaps(), newTexParams.fSwizzleRGBA);
     if (setAll || newTexParams.fMagFilter != oldTexParams.fMagFilter) {
@@ skipping 92 matching lines @@
         }
     }
 
     if (GrTextureParams::kMipMap_FilterMode != filterMode) {
         return;
     }
 
     // If this is an sRGB texture and the mips were previously built the "other" way
     // (gamma-correct vs. not), then we need to rebuild them. We don't need to check for
     // srgbSupport - we'll *never* get an sRGB pixel config if we don't support it.
+    SkSourceGammaTreatment gammaTreatment = allowSRGBInputs
+        ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
     if (GrPixelConfigIsSRGB(texture->config()) &&
-        allowSRGBInputs != texture->texturePriv().mipMapsAreSRGBCorrect()) {
+        gammaTreatment != texture->texturePriv().gammaTreatment()) {
         texture->texturePriv().dirtyMipMaps(true);
     }
 
     // If the mips aren't dirty, we're done:
     if (!texture->texturePriv().mipMapsAreDirty()) {
         return;
     }
 
     // If we created a rt/tex and rendered to it without using a texture and now we're texturing
     // from the rt it will still be the last bound texture, but it needs resolving.
@@ skipping 11 matching lines @@
     if (GrPixelConfigIsSRGB(texture->config())) {
         GL_CALL(TexParameteri(target, GR_GL_TEXTURE_SRGB_DECODE_EXT,
                               allowSRGBInputs ? GR_GL_DECODE_EXT : GR_GL_SKIP_DECODE_EXT));
     }
 
     // Either do manual mipmap generation or (if that fails), just rely on the driver:
     if (!this->generateMipmap(texture, allowSRGBInputs)) {
         GL_CALL(GenerateMipmap(target));
     }
 
-    texture->texturePriv().dirtyMipMaps(false, allowSRGBInputs);
+    texture->texturePriv().dirtyMipMaps(false);
     texture->texturePriv().setMaxMipMapLevel(SkMipMap::ComputeLevelCount(
         texture->width(), texture->height()));
+    texture->texturePriv().setGammaTreatment(gammaTreatment);
 
     // We have potentially set lots of state on the texture. Easiest to dirty it all:
     texture->textureParamsModified();
 }
 
 void GrGLGpu::setTextureSwizzle(int unitIdx, GrGLenum target, const GrGLenum swizzle[]) {
     this->setTextureUnit(unitIdx);
     if (this->glStandard() == kGLES_GrGLStandard) {
         // ES3 added swizzle support but not GL_TEXTURE_SWIZZLE_RGBA.
         GL_CALL(TexParameteri(target, GR_GL_TEXTURE_SWIZZLE_R, swizzle[0]));
@@ skipping 1275 matching lines @@
         if (GR_GL_TEXTURE_EXTERNAL == glTexture->target() ||
             GR_GL_TEXTURE_RECTANGLE == glTexture->target()) {
             copyParams->fFilter = GrTextureParams::kNone_FilterMode;
             copyParams->fWidth = texture->width();
             copyParams->fHeight = texture->height();
             return true;
         }
     }
     return false;
 }