Introduce GrColorSpaceXform, for gamut conversion on textures

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 1127 matching lines @@
               bitmap.height() <= fContext->caps()->maxTileSize()));
 
     GrTexture* texture;
     SkSourceGammaTreatment gammaTreatment = this->surfaceProps().isGammaCorrect()
         ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
     AutoBitmapTexture abt(fContext, bitmap, params, gammaTreatment, &texture);
     if (nullptr == texture) {
         return;
     }
 
+    SkColorSpace* dstColorSpace = nullptr; // XFORMTODO
+    sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(bitmap.colorSpace(),
+                                                                       dstColorSpace);
     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),
                       SkScalarMul(srcRect.fRight,  wInv),
                       SkScalarMul(srcRect.fBottom, hInv));
 
     SkMatrix texMatrix;
@@ skipping 24 matching lines @@
         }
         if (srcRect.height() > SK_Scalar1) {
             SkScalar border = SK_ScalarHalf / texture->height();
             top = paintRect.top() + border;
             bottom = paintRect.bottom() - border;
         } else {
             top = bottom = SkScalarHalf(paintRect.top() + paintRect.bottom());
         }
         textureDomain.setLTRB(left, top, right, bottom);
         if (bicubic) {
-            fp = GrBicubicEffect::Make(texture, texMatrix, textureDomain);
+            fp = GrBicubicEffect::Make(texture, std::move(colorSpaceXform), texMatrix,
+                                       textureDomain);
         } else {
-            fp = GrTextureDomainEffect::Make(texture, texMatrix, textureDomain,
-                                             GrTextureDomain::kClamp_Mode, params.filterMode());
+            fp = GrTextureDomainEffect::Make(texture, std::move(colorSpaceXform), texMatrix,
+                                             textureDomain, GrTextureDomain::kClamp_Mode,
+                                             params.filterMode());
         }
     } else if (bicubic) {
         SkASSERT(GrTextureParams::kNone_FilterMode == params.filterMode());
         SkShader::TileMode tileModes[2] = { params.getTileModeX(), params.getTileModeY() };
-        fp = GrBicubicEffect::Make(texture, texMatrix, tileModes);
+        fp = GrBicubicEffect::Make(texture, std::move(colorSpaceXform), texMatrix, tileModes);
     } else {
-        fp = GrSimpleTextureEffect::Make(texture, texMatrix, params);
+        fp = GrSimpleTextureEffect::Make(texture, std::move(colorSpaceXform), texMatrix, params);
     }
 
     GrPaint grPaint;
     if (!SkPaintToGrPaintWithTexture(this->context(), paint, viewMatrix, std::move(fp),
                                      kAlpha_8_SkColorType == bitmap.colorType(),
                                      this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
     if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
@@ skipping 66 matching lines @@
 
     SkASSERT(result->isTextureBacked());
     sk_sp<GrTexture> texture = result->asTextureRef(fContext);
 
     SkPaint tmpUnfiltered(paint);
     tmpUnfiltered.setImageFilter(nullptr);
 
     bool alphaOnly = kAlpha_8_GrPixelConfig == texture->config();
 
     GrPaint grPaint;
-    sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(texture.get(), SkMatrix::I()));
+    sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(texture.get(), nullptr,
+                                                              SkMatrix::I()));
     if (alphaOnly) {
         fp = GrFragmentProcessor::MulOutputByInputUnpremulColor(std::move(fp));
     } else {
         fp = GrFragmentProcessor::MulOutputByInputAlpha(std::move(fp));
     }
     if (!SkPaintToGrPaintReplaceShader(this->context(), tmpUnfiltered, std::move(fp),
                                        this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
     }
 
@@ skipping 113 matching lines @@
         return;
     }
 
     const SkImageInfo ii = dev->imageInfo();
     int w = ii.width();
     int h = ii.height();
 
     SkASSERT(!paint.getImageFilter());
 
     GrPaint grPaint;
-    sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(devTex.get(), SkMatrix::I()));
+    sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(devTex.get(), nullptr,
+                                                              SkMatrix::I()));
     if (GrPixelConfigIsAlphaOnly(devTex->config())) {
         // Can this happen?
         fp = GrFragmentProcessor::MulOutputByInputUnpremulColor(std::move(fp));
    } else {
         fp = GrFragmentProcessor::MulOutputByInputAlpha(std::move(fp));
     }
 
     if (!SkPaintToGrPaintReplaceShader(this->context(), paint, std::move(fp),
                                        this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
@@ skipping 428 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