Add SkSourceGammaTreatment enum so we know how to create mips

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 62 matching lines @@
 // Helper for turning a bitmap into a texture. If the bitmap is GrTexture backed this
 // just accesses the backing GrTexture. Otherwise, it creates a cached texture
 // representation and releases it in the destructor.
 class AutoBitmapTexture : public SkNoncopyable {
 public:
     AutoBitmapTexture() {}
 
     AutoBitmapTexture(GrContext* context,
                       const SkBitmap& bitmap,
                       const GrTextureParams& params,
+                      SkSourceGammaTreatment gammaTreatment,
                       GrTexture** texture) {
         SkASSERT(texture);
-        *texture = this->set(context, bitmap, params);
+        *texture = this->set(context, bitmap, params, gammaTreatment);
     }
 
     GrTexture* set(GrContext* context,
                    const SkBitmap& bitmap,
-                   const GrTextureParams& params) {
+                   const GrTextureParams& params,
+                   SkSourceGammaTreatment gammaTreatment) {
         // Either get the texture directly from the bitmap, or else use the cache and
         // remember to unref it.
         if (GrTexture* bmpTexture = bitmap.getTexture()) {
             fTexture.reset(nullptr);
             return bmpTexture;
         } else {
-            fTexture.reset(GrRefCachedBitmapTexture(context, bitmap, params));
+            fTexture.reset(GrRefCachedBitmapTexture(context, bitmap, params, gammaTreatment));
             return fTexture.get();
         }
     }
 
 private:
     SkAutoTUnref<GrTexture> fTexture;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 145 matching lines @@
         return;
     }
 
     SkAutoLockPixels alp(bitmap, !bitmap.getTexture());
     if (!bitmap.getTexture() && !bitmap.readyToDraw()) {
         return;
     }
 
     GrTexture* texture;
     // draw sprite neither filters nor tiles.
-    AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(), &texture);
+    AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(),
+                          SkSourceGammaTreatment::kRespect, &texture);
     if (!texture) {
         return;
     }
 
     SkBitmap newBitmap;
 
     GrWrapTextureInBitmap(texture, texture->width(), texture->height(),
                           bitmap.isOpaque(), &newBitmap);
 
     INHERITED::drawSpriteWithFilter(draw, newBitmap, x, y, paint);
@@ skipping 884 matching lines @@
     // We should have already handled bitmaps larger than the max texture size.
     SkASSERT(bitmap.width() <= fContext->caps()->maxTextureSize() &&
              bitmap.height() <= fContext->caps()->maxTextureSize());
     // Unless the bitmap is inherently texture-backed, we should be respecting the max tile size
     // by the time we get here.
     SkASSERT(bitmap.getTexture() ||
              (bitmap.width() <= fContext->caps()->maxTileSize() &&
               bitmap.height() <= fContext->caps()->maxTileSize()));
 
     GrTexture* texture;
-    AutoBitmapTexture abt(fContext, bitmap, params, &texture);
+    SkSourceGammaTreatment gammaTreatment = this->surfaceProps().isGammaCorrect()
+        ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
+    AutoBitmapTexture abt(fContext, bitmap, params, gammaTreatment, &texture);
     if (nullptr == texture) {
         return;
     }
 
     SkRect dstRect = {0, 0, srcRect.width(), srcRect.height() };
     SkRect paintRect;
     SkScalar wInv = SkScalarInvert(SkIntToScalar(texture->width()));
     SkScalar hInv = SkScalarInvert(SkIntToScalar(texture->height()));
     paintRect.setLTRB(SkScalarMul(srcRect.fLeft,   wInv),
                       SkScalarMul(srcRect.fTop,    hInv),
@@ skipping 78 matching lines @@
         return;
     }
 
     int offX = bitmap.pixelRefOrigin().fX;
     int offY = bitmap.pixelRefOrigin().fY;
     int w = bitmap.width();
     int h = bitmap.height();
 
     GrTexture* texture;
     // draw sprite neither filters nor tiles.
-    AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(), &texture);
+    AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(),
+                          SkSourceGammaTreatment::kRespect, &texture);
     if (!texture) {
         return;
     }
 
     bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
 
     SkASSERT(!paint.getImageFilter());
 
     GrPaint grPaint;
     SkAutoTUnref<const GrFragmentProcessor> fp(
@@ skipping 235 matching lines @@
 
         SkRect srcR, dstR;
         while (iter.next(&srcR, &dstR)) {
             this->drawTextureProducer(producer, &srcR, &dstR, SkCanvas::kStrict_SrcRectConstraint,
                                       *draw.fMatrix, fClip, paint);
         }
         return;
     }
 
     static const GrTextureParams::FilterMode kMode = GrTextureParams::kNone_FilterMode;
+    bool gammaCorrect = this->surfaceProps().isGammaCorrect();
+    SkSourceGammaTreatment gammaTreatment = gammaCorrect
+        ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
     SkAutoTUnref<const GrFragmentProcessor> fp(
         producer->createFragmentProcessor(SkMatrix::I(),
                                           SkRect::MakeIWH(producer->width(), producer->height()),
                                           GrTextureProducer::kNo_FilterConstraint, true,
-                                          &kMode));
+                                          &kMode, gammaTreatment));
     GrPaint grPaint;
     if (!SkPaintToGrPaintWithTexture(this->context(), paint, *draw.fMatrix, fp,
-                                     producer->isAlphaOnly(),
-                                     this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                                     producer->isAlphaOnly(), gammaCorrect, &grPaint)) {
         return;
     }
 
     fDrawContext->drawImageNine(fClip, grPaint, *draw.fMatrix, producer->width(),
                                 producer->height(), center, dst);
 }
 
 void SkGpuDevice::drawImageNine(const SkDraw& draw, const SkImage* image,
                                 const SkIRect& center, const SkRect& dst, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
@@ skipping 381 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif