Remove all usage of SkSurfaceProps::isGammaCorrect()

src/effects/SkGpuBlurUtils.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuBlurUtils.h"
 
 #include "SkRect.h"
@@ skipping 165 matching lines @@
         convolve_gaussian_1d(drawContext, clip, midRect, srcOffset, texture,
                              direction, radius, sigma, false, bounds);
     }
 }
 
 namespace SkGpuBlurUtils {
 
 sk_sp<GrDrawContext> GaussianBlur(GrContext* context,
                                   GrTexture* origSrc,
                                   sk_sp<SkColorSpace> colorSpace,
-                                  bool gammaCorrect,
                                   const SkIRect& dstBounds,
                                   const SkIRect* srcBounds,
                                   float sigmaX,
                                   float sigmaY) {
     SkASSERT(context);
     SkIRect clearRect;
     int scaleFactorX, radiusX;
     int scaleFactorY, radiusY;
     int maxTextureSize = context->caps()->maxTextureSize();
     sigmaX = adjust_sigma(sigmaX, maxTextureSize, &scaleFactorX, &radiusX);
@@ skipping 23 matching lines @@
     SkASSERT(kBGRA_8888_GrPixelConfig == srcTexture->config() ||
              kRGBA_8888_GrPixelConfig == srcTexture->config() ||
              kSRGBA_8888_GrPixelConfig == srcTexture->config() ||
              kSBGRA_8888_GrPixelConfig == srcTexture->config() ||
              kAlpha_8_GrPixelConfig == srcTexture->config());
 
     const int width = dstBounds.width();
     const int height = dstBounds.height();
     const GrPixelConfig config = srcTexture->config();
 
-    const SkSurfaceProps props(gammaCorrect ? SkSurfaceProps::kGammaCorrect_Flag : 0,
-                               SkSurfaceProps::kLegacyFontHost_InitType);
-
     sk_sp<GrDrawContext> dstDrawContext(context->newDrawContext(SkBackingFit::kApprox,
                                                                 width, height, config, colorSpace,
-                                                                0, kDefault_GrSurfaceOrigin,
-                                                                &props));
+                                                                0, kDefault_GrSurfaceOrigin));
     if (!dstDrawContext) {
         return nullptr;
     }
 
     // For really small blurs (certainly no wider than 5x5 on desktop gpus) it is faster to just
     // launch a single non separable kernel vs two launches
     if (sigmaX > 0.0f && sigmaY > 0.0f &&
             (2 * radiusX + 1) * (2 * radiusY + 1) <= MAX_KERNEL_SIZE) {
         // We shouldn't be scaling because this is a small size blur
         SkASSERT((1 == scaleFactorX) && (1 == scaleFactorY));
 
         convolve_gaussian_2d(dstDrawContext.get(), clip, localDstBounds, srcOffset,
                              srcTexture.get(), radiusX, radiusY, sigmaX, sigmaY, srcBounds);
 
         return dstDrawContext;
     } 
 
     sk_sp<GrDrawContext> tmpDrawContext(context->newDrawContext(SkBackingFit::kApprox,
                                                                 width, height, config, colorSpace,
-                                                                0, kDefault_GrSurfaceOrigin,
-                                                                &props));
+                                                                0, kDefault_GrSurfaceOrigin));
     if (!tmpDrawContext) {
         return nullptr;
     }
 
     sk_sp<GrDrawContext> srcDrawContext;
 
     SkASSERT(SkIsPow2(scaleFactorX) && SkIsPow2(scaleFactorY));
 
     for (int i = 1; i < scaleFactorX || i < scaleFactorY; i *= 2) {
         GrPaint paint;
-        paint.setGammaCorrect(gammaCorrect);
+        paint.setGammaCorrect(dstDrawContext->isGammaCorrect());
         SkMatrix matrix;
         matrix.setIDiv(srcTexture->width(), srcTexture->height());
         SkIRect dstRect(srcRect);
         if (srcBounds && i == 1) {
             SkRect domain;
             matrix.mapRect(&domain, SkRect::Make(*srcBounds));
             domain.inset((i < scaleFactorX) ? SK_ScalarHalf / srcTexture->width() : 0.0f,
                          (i < scaleFactorY) ? SK_ScalarHalf / srcTexture->height() : 0.0f);
             sk_sp<GrFragmentProcessor> fp(GrTextureDomainEffect::Make(
                                                         srcTexture.get(),
@@ skipping 73 matching lines @@
         // Clear one pixel to the right and below, to accommodate bilinear upsampling.
         clearRect = SkIRect::MakeXYWH(srcRect.fLeft, srcRect.fBottom, srcRect.width() + 1, 1);
         srcDrawContext->clear(&clearRect, 0x0, false);
         clearRect = SkIRect::MakeXYWH(srcRect.fRight, srcRect.fTop, 1, srcRect.height());
         srcDrawContext->clear(&clearRect, 0x0, false);
 
         SkMatrix matrix;
         matrix.setIDiv(srcDrawContext->width(), srcDrawContext->height());
 
         GrPaint paint;
-        paint.setGammaCorrect(gammaCorrect);
+        paint.setGammaCorrect(dstDrawContext->isGammaCorrect());
         // FIXME:  this should be mitchell, not bilinear.
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
         sk_sp<GrTexture> tex(srcDrawContext->asTexture());
         paint.addColorTextureProcessor(tex.get(), nullptr, matrix, params);
         paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
 
         SkIRect dstRect(srcRect);
         scale_irect(&dstRect, scaleFactorX, scaleFactorY);
 
         dstDrawContext->fillRectToRect(clip, paint, SkMatrix::I(),
                                        SkRect::Make(dstRect), SkRect::Make(srcRect));
 
         srcDrawContext = dstDrawContext;
         srcRect = dstRect;
         dstDrawContext.swap(tmpDrawContext);
     }
 
     return srcDrawContext;
 }
 
 }
 
 #endif