Add destination color space to AsFPArgs. Eliminates last XFORMTODO.

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 347 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPaint", fContext);
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     fDrawContext->drawPaint(fClip, grPaint, *draw.fMatrix);
 }
 
 // must be in SkCanvas::PointMode order
 static const GrPrimitiveType gPointMode2PrimtiveType[] = {
     kPoints_GrPrimitiveType,
     kLines_GrPrimitiveType,
@@ skipping 30 matching lines @@
 
     SkScalar width = paint.getStrokeWidth();
     if (width < 0) {
         return;
     }
 
     if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
         GrStyle style(paint, SkPaint::kStroke_Style);
         GrPaint grPaint;
         if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                              this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                              this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                              &grPaint)) {
             return;
         }
         SkPath path;
         path.setIsVolatile(true);
         path.moveTo(pts[0]);
         path.lineTo(pts[1]);
         fDrawContext->drawPath(fClip, grPaint, *draw.fMatrix, path, style);
         return;
     }
 
     // we only handle non-antialiased hairlines and paints without path effects or mask filters,
     // else we let the SkDraw call our drawPath()
     if (width > 0 || paint.getPathEffect() || paint.getMaskFilter() ||
         (paint.isAntiAlias() && needs_antialiasing(mode, count, pts))) {
         draw.drawPoints(mode, count, pts, paint, true);
         return;
     }
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     fDrawContext->drawVertices(fClip,
                                grPaint,
                                *draw.fMatrix,
                                gPointMode2PrimtiveType[mode],
                                SkToS32(count),
                                (SkPoint*)pts,
                                nullptr,
@@ skipping 17 matching lines @@
         path.addRect(rect);
         GrBlurUtils::drawPathWithMaskFilter(fContext, fDrawContext.get(),
                                             fClip, path, paint,
                                             *draw.fMatrix, nullptr,
                                             draw.fRC->getBounds(), true);
         return;
     }
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     GrStyle style(paint);
     fDrawContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &style);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect,
                             const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawRRect", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     GrStyle style(paint);
     if (paint.getMaskFilter()) {
         // try to hit the fast path for drawing filtered round rects
 
         SkRRect devRRect;
         if (rect.transform(*draw.fMatrix, &devRRect)) {
             if (devRRect.allCornersCircular()) {
@@ skipping 55 matching lines @@
 
     if (inner.isEmpty()) {
         return this->drawRRect(draw, outer, paint);
     }
 
     SkStrokeRec stroke(paint);
 
     if (stroke.isFillStyle() && !paint.getMaskFilter() && !paint.getPathEffect()) {
         GrPaint grPaint;
         if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                              this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                              this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                              &grPaint)) {
             return;
         }
 
         fDrawContext->drawDRRect(fClip, grPaint, *draw.fMatrix, outer, inner);
         return;
     }
 
     SkPath path;
     path.setIsVolatile(true);
     path.addRRect(outer);
@@ skipping 24 matching lines @@
     }
 
     if (paint.getMaskFilter()) {
         // The RRect path can handle special case blurring
         SkRRect rr = SkRRect::MakeOval(oval);
         return this->drawRRect(draw, rr, paint);
     }
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     fDrawContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, GrStyle(paint));
 }
 
 #include "SkMaskFilter.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 void SkGpuDevice::drawStrokedLine(const SkPoint points[2],
@@ skipping 36 matching lines @@
                                    mid.fX+halfWidth, mid.fY + 0.5f*length + xtraLength);
     SkMatrix m;
     m.setSinCos(v.fX, -v.fY, mid.fX, mid.fY);
 
     SkMatrix local = m;
 
     m.postConcat(*draw.fMatrix);
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), newPaint, m,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     fDrawContext->fillRectWithLocalMatrix(fClip, grPaint, m, rect, local);
 }
 
 void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
                            const SkPaint& paint, const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     ASSERT_SINGLE_OWNER
@@ skipping 476 matching lines @@
         SkASSERT(GrTextureParams::kNone_FilterMode == params.filterMode());
         SkShader::TileMode tileModes[2] = { params.getTileModeX(), params.getTileModeY() };
         fp = GrBicubicEffect::Make(texture, std::move(colorSpaceXform), texMatrix, tileModes);
     } else {
         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)) {
+                                     this->surfaceProps().isGammaCorrect(),
+                                     fDrawContext->getColorSpace(), &grPaint)) {
         return;
     }
 
     if (kAlpha_8_SkColorType == bitmap.colorType() && paint.getShader()) {
         // We don't have local coords in this case and have previously set the transform
         // matrices directly on the texture processor.
         fDrawContext->drawRect(fClip, grPaint, viewMatrix, dstRect);
     } else {
         fDrawContext->fillRectToRect(fClip, grPaint, viewMatrix, dstRect, paintRect);
     }
@@ skipping 70 matching lines @@
 
     GrPaint grPaint;
     sk_sp<GrFragmentProcessor> fp(GrSimpleTextureEffect::Make(texture.get(), nullptr,
                                                               SkMatrix::I()));
     if (GrPixelConfigIsAlphaOnly(texture->config())) {
         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)) {
+                                       this->surfaceProps().isGammaCorrect(),
+                                       fDrawContext->getColorSpace(), &grPaint)) {
         return;
     }
 
     const SkIRect& subset = result->subset();
 
     fDrawContext->fillRectToRect(fClip,
                                  grPaint,
                                  SkMatrix::I(),
                                  SkRect::Make(SkIRect::MakeXYWH(left + offset.fX, top + offset.fY,
                                                                 subset.width(), subset.height())),
@@ skipping 267 matching lines @@
     bool gammaCorrect = this->surfaceProps().isGammaCorrect();
     SkSourceGammaTreatment gammaTreatment = gammaCorrect
         ? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
     sk_sp<GrFragmentProcessor> fp(
         producer->createFragmentProcessor(SkMatrix::I(),
                                           SkRect::MakeIWH(producer->width(), producer->height()),
                                           GrTextureProducer::kNo_FilterConstraint, true,
                                           &kMode, fDrawContext->getColorSpace(), gammaTreatment));
     GrPaint grPaint;
     if (!SkPaintToGrPaintWithTexture(this->context(), paint, *draw.fMatrix, std::move(fp),
-                                     producer->isAlphaOnly(), gammaCorrect, &grPaint)) {
+                                     producer->isAlphaOnly(), gammaCorrect,
+                                     fDrawContext->getColorSpace(), &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 47 matching lines @@
 
         texs = nullptr;
 
         SkPaint copy(paint);
         copy.setStyle(SkPaint::kStroke_Style);
         copy.setStrokeWidth(0);
 
         GrPaint grPaint;
         // we ignore the shader if texs is null.
         if (!SkPaintToGrPaintNoShader(this->context(), copy,
-                                      this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                                      this->surfaceProps().isGammaCorrect(),
+                                      fDrawContext->getColorSpace(), &grPaint)) {
             return;
         }
 
         int triangleCount = 0;
         int n = (nullptr == indices) ? vertexCount : indexCount;
         switch (vmode) {
             case SkCanvas::kTriangles_VertexMode:
                 triangleCount = n / 3;
                 break;
             case SkCanvas::kTriangleStrip_VertexMode:
@@ skipping 52 matching lines @@
             SkXfermode::Mode colorMode;
             if (xmode) {
                 if (!xmode->asMode(&colorMode)) {
                     return;
                 }
             } else {
                 colorMode = SkXfermode::kModulate_Mode;
             }
             if (!SkPaintToGrPaintWithXfermode(this->context(), paint, *draw.fMatrix, colorMode,
                                               false, this->surfaceProps().isGammaCorrect(),
-                                              &grPaint)) {
+                                              fDrawContext->getColorSpace(), &grPaint)) {
                 return;
             }
         } else {
             // We have a shader, but no colors to blend it against.
             if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                                  this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                                  this->surfaceProps().isGammaCorrect(),
+                                  fDrawContext->getColorSpace(), &grPaint)) {
                 return;
             }
         }
     } else {
         if (colors) {
             // We have colors, but either have no shader or no texture coords (which implies that
             // we should ignore the shader).
             if (!SkPaintToGrPaintWithPrimitiveColor(this->context(), paint,
                                                     this->surfaceProps().isGammaCorrect(),
-                                                    &grPaint)) {
+                                                    fDrawContext->getColorSpace(), &grPaint)) {
                 return;
             }
         } else {
             // No colors and no shaders. Just draw with the paint color.
             if (!SkPaintToGrPaintNoShader(this->context(), paint,
-                                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                                          this->surfaceProps().isGammaCorrect(),
+                                          fDrawContext->getColorSpace(), &grPaint)) {
                 return;
             }
         }
     }
 
     fDrawContext->drawVertices(fClip,
                                grPaint,
                                *draw.fMatrix,
                                primType,
                                vertexCount,
@@ skipping 17 matching lines @@
 
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawText", fContext);
 
     SkPaint p(paint);
     p.setShader(atlas->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
 
     GrPaint grPaint;
     if (colors) {
         if (!SkPaintToGrPaintWithXfermode(this->context(), p, *draw.fMatrix, mode, true,
-                                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                                          this->surfaceProps().isGammaCorrect(),
+                                          fDrawContext->getColorSpace(), &grPaint)) {
             return;
         }
     } else {
         if (!SkPaintToGrPaint(this->context(), p, *draw.fMatrix,
-                              this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                              this->surfaceProps().isGammaCorrect(),
+                              fDrawContext->getColorSpace(), &grPaint)) {
             return;
         }
     }
 
     SkDEBUGCODE(this->validate();)
     fDrawContext->drawAtlas(fClip, grPaint, *draw.fMatrix, count, xform, texRect, colors);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawText(const SkDraw& draw, const void* text,
                            size_t byteLength, SkScalar x, SkScalar y,
                            const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawText", fContext);
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawText(fClip, grPaint, paint, *draw.fMatrix,
                            (const char *)text, byteLength, x, y, draw.fRC->getBounds());
 }
 
 void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text, size_t byteLength,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPosText", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
     if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix,
-                          this->surfaceProps().isGammaCorrect(), &grPaint)) {
+                          this->surfaceProps().isGammaCorrect(), fDrawContext->getColorSpace(),
+                          &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawPosText(fClip, grPaint, paint, *draw.fMatrix,
                               (const char *)text, byteLength, pos, scalarsPerPos, offset,
                               draw.fRC->getBounds());
 }
 
@@ skipping 64 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