Add SkSourceGammaTreatment enum so we know how to create mips

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkGr.h"
 #include "SkGrPriv.h"
@@ skipping 311 matching lines @@
         explicit Invalidator(const GrUniqueKey& key) : fMsg(key) {}
     private:
         GrUniqueKeyInvalidatedMessage fMsg;
 
         void onChange() override { SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg); }
     };
 
     pixelRef->addGenIDChangeListener(new Invalidator(key));
 }
 
-GrTexture* GrGenerateMipMapsAndUploadToTexture(GrContext* ctx, const SkBitmap& bitmap)
+GrTexture* GrGenerateMipMapsAndUploadToTexture(GrContext* ctx, const SkBitmap& bitmap,
+                                               SkSourceGammaTreatment gammaTreatment)
 {
     GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap.info(), *ctx->caps());
     if (kIndex_8_SkColorType != bitmap.colorType() && !bitmap.readyToDraw()) {
         GrTexture* texture = load_etc1_texture(ctx, bitmap, desc);
         if (texture) {
             return texture;
         }
     }
 
     sk_sp<GrTexture> texture(create_texture_from_yuv(ctx, bitmap, desc));
@@ skipping 53 matching lines @@
 
 GrTexture* GrUploadMipMapToTexture(GrContext* ctx, const SkImageInfo& info,
                                    const GrMipLevel* texels, int mipLevelCount) {
     const GrCaps* caps = ctx->caps();
     return ctx->textureProvider()->createMipMappedTexture(GrImageInfoToSurfaceDesc(info, *caps),
                                                           SkBudgeted::kYes, texels,
                                                           mipLevelCount);
 }
 
 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
-                                    const GrTextureParams& params) {
+                                    const GrTextureParams& params,
+                                    SkSourceGammaTreatment gammaTreatment) {
     if (bitmap.getTexture()) {
-        return GrBitmapTextureAdjuster(&bitmap).refTextureSafeForParams(params, nullptr);
+        return GrBitmapTextureAdjuster(&bitmap).refTextureSafeForParams(params, gammaTreatment,
+                                                                        nullptr);
     }
-    return GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params);
+    return GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params, gammaTreatment);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // alphatype is ignore for now, but if GrPixelConfig is expanded to encompass
 // alpha info, that will be considered.
 GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType ct, SkAlphaType, SkColorProfileType pt,
                                         const GrCaps& caps) {
     // We intentionally ignore profile type for non-8888 formats. Anything we can't support
     // in hardware will be expanded to sRGB 8888 in GrUploadPixmapToTexture.
@@ skipping 91 matching lines @@
     grPaint->setAllowSRGBInputs(allowSRGBInputs);
 
     // Setup the initial color considering the shader, the SkPaint color, and the presence or not
     // of per-vertex colors.
     SkAutoTUnref<const GrFragmentProcessor> aufp;
     const GrFragmentProcessor* shaderFP = nullptr;
     if (!primColorMode || blend_requires_shader(*primColorMode, primitiveIsSrc)) {
         if (shaderProcessor) {
             shaderFP = *shaderProcessor;
         } else if (const SkShader* shader = skPaint.getShader()) {
+            SkSourceGammaTreatment gammaTreatment = allowSRGBInputs
+                ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
             aufp.reset(shader->asFragmentProcessor(context, viewM, nullptr,
-                                                   skPaint.getFilterQuality()));
+                                                   skPaint.getFilterQuality(), gammaTreatment));
             shaderFP = aufp;
             if (!shaderFP) {
                 return false;
             }
         }
     }
 
     // Set this in below cases if the output of the shader/paint-color/paint-alpha/primXfermode is
     // a known constant value. In that case we can simply apply a color filter during this
     // conversion without converting the color filter to a GrFragmentProcessor.
@@ skipping 148 matching lines @@
 bool SkPaintToGrPaintWithTexture(GrContext* context,
                                  const SkPaint& paint,
                                  const SkMatrix& viewM,
                                  const GrFragmentProcessor* fp,
                                  bool textureIsAlphaOnly,
                                  bool allowSRGBInputs,
                                  GrPaint* grPaint) {
     SkAutoTUnref<const GrFragmentProcessor> shaderFP;
     if (textureIsAlphaOnly) {
         if (const SkShader* shader = paint.getShader()) {
+            SkSourceGammaTreatment gammaTreatment = allowSRGBInputs
+                ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
             shaderFP.reset(shader->asFragmentProcessor(context,
                                                        viewM,
                                                        nullptr,
-                                                       paint.getFilterQuality()));
+                                                       paint.getFilterQuality(),
+                                                       gammaTreatment));
             if (!shaderFP) {
                 return false;
             }
             const GrFragmentProcessor* fpSeries[] = { shaderFP.get(), fp };
             shaderFP.reset(GrFragmentProcessor::RunInSeries(fpSeries, 2));
         } else {
             shaderFP.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
         }
     } else {
         shaderFP.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
@@ skipping 61 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }