Add SkSourceGammaTreatment enum so we know how to create mips

src/gpu/GrTextureParamsAdjuster.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureParamsAdjuster.h"
 
 #include "GrCaps.h"
@@ skipping 140 matching lines @@
     if (copy) {
         if (key.isValid()) {
             copy->resourcePriv().setUniqueKey(key);
             this->didCacheCopy(key);
         }
     }
     return copy;
 }
 
 GrTexture* GrTextureAdjuster::refTextureSafeForParams(const GrTextureParams& params,
-                                                      SkIPoint* outOffset) {
+                                                      bool gammaCorrect, SkIPoint* outOffset) {
     GrTexture* texture = this->originalTexture();
     GrContext* context = texture->getContext();
     CopyParams copyParams;
     const SkIRect* contentArea = this->contentAreaOrNull();
 
     if (contentArea && GrTextureParams::kMipMap_FilterMode == params.filterMode()) {
         // If we generate a MIP chain for texture it will read pixel values from outside the content
         // area.
         copyParams.fWidth = contentArea->width();
         copyParams.fHeight = contentArea->height();
@@ skipping 194 matching lines @@
             return GrBicubicEffect::Create(texture, textureMatrix, kClampClamp);
         }
     }
 }
 
 const GrFragmentProcessor* GrTextureAdjuster::createFragmentProcessor(
                                         const SkMatrix& origTextureMatrix,
                                         const SkRect& origConstraintRect,
                                         FilterConstraint filterConstraint,
                                         bool coordsLimitedToConstraintRect,
-                                        const GrTextureParams::FilterMode* filterOrNullForBicubic) {
+                                        const GrTextureParams::FilterMode* filterOrNullForBicubic,
+                                        bool gammaCorrect) {
 
     SkMatrix textureMatrix = origTextureMatrix;
     const SkIRect* contentArea = this->contentAreaOrNull();
     // Convert the constraintRect to be relative to the texture rather than the content area so
     // that both rects are in the same coordinate system.
     SkTCopyOnFirstWrite<SkRect> constraintRect(origConstraintRect);
     if (contentArea) {
         SkScalar l = SkIntToScalar(contentArea->fLeft);
         SkScalar t = SkIntToScalar(contentArea->fTop);
         constraintRect.writable()->offset(l, t);
         textureMatrix.postTranslate(l, t);
     }
 
     SkRect domain;
     GrTextureParams params;
     if (filterOrNullForBicubic) {
         params.setFilterMode(*filterOrNullForBicubic);
     }
-    SkAutoTUnref<GrTexture> texture(this->refTextureSafeForParams(params, nullptr));
+    SkAutoTUnref<GrTexture> texture(this->refTextureSafeForParams(params, gammaCorrect, nullptr));
     if (!texture) {
         return nullptr;
     }
     // If we made a copy then we only copied the contentArea, in which case the new texture is all
     // content.
     if (texture != this->originalTexture()) {
         contentArea = nullptr;
     }
 
     DomainMode domainMode =
@@ skipping 18 matching lines @@
     }
     SkASSERT(kNoDomain_DomainMode == domainMode ||
              (domain.fLeft <= domain.fRight && domain.fTop <= domain.fBottom));
     textureMatrix.postIDiv(texture->width(), texture->height());
     return create_fp_for_domain_and_filter(texture, textureMatrix, domainMode, domain,
                                            filterOrNullForBicubic);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrTexture* GrTextureMaker::refTextureForParams(const GrTextureParams& params) {
+GrTexture* GrTextureMaker::refTextureForParams(const GrTextureParams& params, bool gammaCorrect) {
     CopyParams copyParams;
     bool willBeMipped = params.filterMode() == GrTextureParams::kMipMap_FilterMode;
 
     if (!fContext->caps()->mipMapSupport()) {
         willBeMipped = false;
     }
 
     if (!fContext->getGpu()->makeCopyForTextureParams(this->width(), this->height(), params,
                                                       &copyParams)) {
-        return this->refOriginalTexture(willBeMipped);
+        return this->refOriginalTexture(willBeMipped, gammaCorrect);
     }
     GrUniqueKey copyKey;
     this->makeCopyKey(copyParams, &copyKey);
     if (copyKey.isValid()) {
         GrTexture* result = fContext->textureProvider()->findAndRefTextureByUniqueKey(copyKey);
         if (result) {
             return result;
         }
     }
 
-    GrTexture* result = this->generateTextureForParams(copyParams, willBeMipped);
+    GrTexture* result = this->generateTextureForParams(copyParams, willBeMipped, gammaCorrect);
     if (!result) {
         return nullptr;
     }
 
     if (copyKey.isValid()) {
         fContext->textureProvider()->assignUniqueKeyToTexture(copyKey, result);
         this->didCacheCopy(copyKey);
     }
     return result;
 }
 
 const GrFragmentProcessor* GrTextureMaker::createFragmentProcessor(
                                         const SkMatrix& textureMatrix,
                                         const SkRect& constraintRect,
                                         FilterConstraint filterConstraint,
                                         bool coordsLimitedToConstraintRect,
-                                        const GrTextureParams::FilterMode* filterOrNullForBicubic) {
+                                        const GrTextureParams::FilterMode* filterOrNullForBicubic,
+                                        bool gammaCorrect) {
 
     const GrTextureParams::FilterMode* fmForDetermineDomain = filterOrNullForBicubic;
     if (filterOrNullForBicubic && GrTextureParams::kMipMap_FilterMode == *filterOrNullForBicubic &&
         kYes_FilterConstraint == filterConstraint) {
         // TODo: Here we should force a copy restricted to the constraintRect since MIP maps will
         // read outside the constraint rect. However, as in the adjuster case, we aren't currently
         // doing that.
         // We instead we compute the domain as though were bilerping which is only correct if we
         // only sample level 0.
         static const GrTextureParams::FilterMode kBilerp = GrTextureParams::kBilerp_FilterMode;
         fmForDetermineDomain = &kBilerp;
     }
 
     GrTextureParams params;
     if (filterOrNullForBicubic) {
         params.reset(SkShader::kClamp_TileMode, *filterOrNullForBicubic);
     } else {
         // Bicubic doesn't use filtering for it's texture accesses.
         params.reset(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
     }
-    SkAutoTUnref<GrTexture> texture(this->refTextureForParams(params));
+    SkAutoTUnref<GrTexture> texture(this->refTextureForParams(params, gammaCorrect));
     if (!texture) {
         return nullptr;
     }
     SkRect domain;
     DomainMode domainMode =
         determine_domain_mode(constraintRect, filterConstraint, coordsLimitedToConstraintRect,
                               texture->width(), texture->height(), nullptr, fmForDetermineDomain,
                               &domain);
     SkASSERT(kTightCopy_DomainMode != domainMode);
     SkMatrix normalizedTextureMatrix = textureMatrix;
     normalizedTextureMatrix.postIDiv(texture->width(), texture->height());
     return create_fp_for_domain_and_filter(texture, normalizedTextureMatrix, domainMode, domain,
                                            filterOrNullForBicubic);
 }
 
 GrTexture* GrTextureMaker::generateTextureForParams(const CopyParams& copyParams,
-                                                    bool willBeMipped) {
-    SkAutoTUnref<GrTexture> original(this->refOriginalTexture(willBeMipped));
+                                                    bool willBeMipped, bool gammaCorrect) {
+    SkAutoTUnref<GrTexture> original(this->refOriginalTexture(willBeMipped, gammaCorrect));
     if (!original) {
         return nullptr;
     }
     return copy_on_gpu(original, nullptr, copyParams);
 }