Just pass the draw context to paint conversion

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"
 
 #include "GrCaps.h"
 #include "GrContext.h"
+#include "GrDrawContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrTexturePriv.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "GrYUVProvider.h"
 
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
@@ skipping 484 matching lines @@
 
 static inline bool blend_requires_shader(const SkXfermode::Mode mode, bool primitiveIsSrc) {
     if (primitiveIsSrc) {
         return SkXfermode::kSrc_Mode != mode;
     } else {
         return SkXfermode::kDst_Mode != mode;
     }
 }
 
 static inline bool skpaint_to_grpaint_impl(GrContext* context,
+                                           GrDrawContext* dc,
                                            const SkPaint& skPaint,
                                            const SkMatrix& viewM,
                                            sk_sp<GrFragmentProcessor>* shaderProcessor,
                                            SkXfermode::Mode* primColorMode,
                                            bool primitiveIsSrc,
-                                           bool allowSRGBInputs,
-                                           SkColorSpace* dstColorSpace,
                                            GrPaint* grPaint) {
     grPaint->setAntiAlias(skPaint.isAntiAlias());
-    grPaint->setAllowSRGBInputs(allowSRGBInputs);
+    grPaint->setAllowSRGBInputs(dc->isGammaCorrect());
 
     // Raw translation of the SkPaint color to our 4f format:
     GrColor4f origColor = GrColor4f::FromGrColor(SkColorToUnpremulGrColor(skPaint.getColor()));
 
     // Linearize, if the color is meant to be in sRGB gamma:
-    if (allowSRGBInputs) {
+    if (dc->isGammaCorrect()) {
         origColor.fRGBA[0] = exact_srgb_to_linear(origColor.fRGBA[0]);
         origColor.fRGBA[1] = exact_srgb_to_linear(origColor.fRGBA[1]);
         origColor.fRGBA[2] = exact_srgb_to_linear(origColor.fRGBA[2]);
     }
 
     // Setup the initial color considering the shader, the SkPaint color, and the presence or not
     // of per-vertex colors.
     sk_sp<GrFragmentProcessor> shaderFP;
     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;
             shaderFP = shader->asFragmentProcessor(SkShader::AsFPArgs(context, &viewM, nullptr,
                                                                       skPaint.getFilterQuality(),
-                                                                      dstColorSpace,
-                                                                      gammaTreatment));
+                                                                      dc->getColorSpace(),
+                                                                      dc->sourceGammaTreatment()));
             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.
     bool applyColorFilterToPaintColor = false;
@@ skipping 84 matching lines @@
 
     // When the xfermode is null on the SkPaint (meaning kSrcOver) we need the XPFactory field on
     // the GrPaint to also be null (also kSrcOver).
     SkASSERT(!grPaint->getXPFactory());
     SkXfermode* xfermode = skPaint.getXfermode();
     if (xfermode) {
         grPaint->setXPFactory(xfermode->asXPFactory());
     }
 
 #ifndef SK_IGNORE_GPU_DITHER
-    if (skPaint.isDither() && grPaint->numColorFragmentProcessors() > 0 && !allowSRGBInputs) {
+    if (skPaint.isDither() && grPaint->numColorFragmentProcessors() > 0 && !dc->isGammaCorrect()) {
         grPaint->addColorFragmentProcessor(GrDitherEffect::Make());
     }
 #endif
     return true;
 }
 
-bool SkPaintToGrPaint(GrContext* context, const SkPaint& skPaint, const SkMatrix& viewM,
-                      bool allowSRGBInputs, SkColorSpace* dstColorSpace, GrPaint* grPaint) {
-    return skpaint_to_grpaint_impl(context, skPaint, viewM, nullptr, nullptr, false,
-                                   allowSRGBInputs, dstColorSpace, grPaint);
+bool SkPaintToGrPaint(GrContext* context, GrDrawContext* dc, const SkPaint& skPaint,
+                      const SkMatrix& viewM, GrPaint* grPaint) {
+    return skpaint_to_grpaint_impl(context, dc, skPaint, viewM, nullptr, nullptr, false, grPaint);
 }
 
 /** Replaces the SkShader (if any) on skPaint with the passed in GrFragmentProcessor. */
 bool SkPaintToGrPaintReplaceShader(GrContext* context,
+                                   GrDrawContext* dc,
                                    const SkPaint& skPaint,
                                    sk_sp<GrFragmentProcessor> shaderFP,
-                                   bool allowSRGBInputs,
-                                   SkColorSpace* dstColorSpace,
                                    GrPaint* grPaint) {
     if (!shaderFP) {
         return false;
     }
-    return skpaint_to_grpaint_impl(context, skPaint, SkMatrix::I(), &shaderFP, nullptr, false,
-                                   allowSRGBInputs, dstColorSpace, grPaint);
+    return skpaint_to_grpaint_impl(context, dc, skPaint, SkMatrix::I(), &shaderFP, nullptr, false,
+                                   grPaint);
 }
 
 /** Ignores the SkShader (if any) on skPaint. */
 bool SkPaintToGrPaintNoShader(GrContext* context,
+                              GrDrawContext* dc,
                               const SkPaint& skPaint,
-                              bool allowSRGBInputs,
-                              SkColorSpace* dstColorSpace,
                               GrPaint* grPaint) {
     // Use a ptr to a nullptr to to indicate that the SkShader is ignored and not replaced.
     static sk_sp<GrFragmentProcessor> kNullShaderFP(nullptr);
     static sk_sp<GrFragmentProcessor>* kIgnoreShader = &kNullShaderFP;
-    return skpaint_to_grpaint_impl(context, skPaint, SkMatrix::I(), kIgnoreShader, nullptr, false,
-                                   allowSRGBInputs, dstColorSpace, grPaint);
+    return skpaint_to_grpaint_impl(context, dc, skPaint, SkMatrix::I(), kIgnoreShader, nullptr,
+                                   false, grPaint);
 }
 
 /** Blends the SkPaint's shader (or color if no shader) with a per-primitive color which must
 be setup as a vertex attribute using the specified SkXfermode::Mode. */
 bool SkPaintToGrPaintWithXfermode(GrContext* context,
+                                  GrDrawContext* dc,
                                   const SkPaint& skPaint,
                                   const SkMatrix& viewM,
                                   SkXfermode::Mode primColorMode,
                                   bool primitiveIsSrc,
-                                  bool allowSRGBInputs,
-                                  SkColorSpace* dstColorSpace,
                                   GrPaint* grPaint) {
-    return skpaint_to_grpaint_impl(context, skPaint, viewM, nullptr, &primColorMode, primitiveIsSrc,
-                                   allowSRGBInputs, dstColorSpace, grPaint);
+    return skpaint_to_grpaint_impl(context, dc, skPaint, viewM, nullptr, &primColorMode,
+                                   primitiveIsSrc, grPaint);
 }
 
 bool SkPaintToGrPaintWithTexture(GrContext* context,
+                                 GrDrawContext* dc,
                                  const SkPaint& paint,
                                  const SkMatrix& viewM,
                                  sk_sp<GrFragmentProcessor> fp,
                                  bool textureIsAlphaOnly,
-                                 bool allowSRGBInputs,
-                                 SkColorSpace* dstColorSpace,
                                  GrPaint* grPaint) {
     sk_sp<GrFragmentProcessor> shaderFP;
     if (textureIsAlphaOnly) {
         if (const SkShader* shader = paint.getShader()) {
-            SkSourceGammaTreatment gammaTreatment = allowSRGBInputs
-                ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
             shaderFP = shader->asFragmentProcessor(SkShader::AsFPArgs(context,
                                                                       &viewM,
                                                                       nullptr,
                                                                       paint.getFilterQuality(),
-                                                                      dstColorSpace,
-                                                                      gammaTreatment));
+                                                                      dc->getColorSpace(),
+                                                                      dc->sourceGammaTreatment()));
             if (!shaderFP) {
                 return false;
             }
             sk_sp<GrFragmentProcessor> fpSeries[] = { std::move(shaderFP), std::move(fp) };
             shaderFP = GrFragmentProcessor::RunInSeries(fpSeries, 2);
         } else {
             shaderFP = GrFragmentProcessor::MulOutputByInputUnpremulColor(fp);
         }
     } else {
         shaderFP = GrFragmentProcessor::MulOutputByInputAlpha(fp);
     }
 
-    return SkPaintToGrPaintReplaceShader(context, paint, std::move(shaderFP), allowSRGBInputs,
-                                         dstColorSpace, grPaint);
+    return SkPaintToGrPaintReplaceShader(context, dc, paint, std::move(shaderFP), grPaint);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrTextureParams::FilterMode GrSkFilterQualityToGrFilterMode(SkFilterQuality paintFilterQuality,
                                                             const SkMatrix& viewM,
                                                             const SkMatrix& localM,
                                                             bool* doBicubic) {
     *doBicubic = false;
@@ skipping 26 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;
 }