Add SkColorSpace to GrDrawContext

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 164 matching lines @@
                              direction, radius, sigma, true, bounds);
         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();
@@ skipping 28 matching lines @@
              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,
+                                                                width, height, config, colorSpace,
                                                                 0, kDefault_GrSurfaceOrigin,
                                                                 &props));
     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,
+                                                                width, height, config, colorSpace,
                                                                 0, kDefault_GrSurfaceOrigin,
                                                                 &props));
     if (!tmpDrawContext) {
         return nullptr;
     }
 
     sk_sp<GrDrawContext> srcDrawContext;
 
     SkASSERT(SkIsPow2(scaleFactorX) && SkIsPow2(scaleFactorY));
 
@@ skipping 111 matching lines @@
         dstDrawContext.swap(tmpDrawContext);
     }
 
     return srcDrawContext;
 }
 
 }
 
 #endif