Make skpaint->grpaint flow work for composing draws

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"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrFontScaler.h"
 #include "GrGpu.h"
 #include "GrGpuResourcePriv.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
 #include "GrStrokeInfo.h"
 #include "GrTextContext.h"
 #include "GrTracing.h"
 #include "SkCanvasPriv.h"
 #include "SkDrawProcs.h"
 #include "SkErrorInternals.h"
 #include "SkGlyphCache.h"
 #include "SkGrTexturePixelRef.h"
+#include "SkGrPriv.h"
 #include "SkImage_Base.h"
 #include "SkImageFilter.h"
 #include "SkLayerInfo.h"
 #include "SkMaskFilter.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
 #include "SkPictureData.h"
 #include "SkRRect.h"
 #include "SkRecord.h"
 #include "SkStroke.h"
@@ skipping 340 matching lines @@
     fDrawContext.reset(fRenderTarget->getContext()->drawContext(&this->surfaceProps()));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPaint", fContext);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
         return;
     }
 
     fDrawContext->drawPaint(fRenderTarget, fClip, grPaint, *draw.fMatrix);
 }
 
 // must be in SkCanvas::PointMode order
 static const GrPrimitiveType gPointMode2PrimtiveType[] = {
     kPoints_GrPrimitiveType,
     kLines_GrPrimitiveType,
@@ skipping 28 matching lines @@
     CHECK_SHOULD_DRAW(draw);
 
     SkScalar width = paint.getStrokeWidth();
     if (width < 0) {
         return;
     }
 
     if (paint.getPathEffect() && 2 == count && SkCanvas::kLines_PointMode == mode) {
         GrStrokeInfo strokeInfo(paint, SkPaint::kStroke_Style);
         GrPaint grPaint;
-        if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+        if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
             return;
         }
         SkPath path;
         path.setIsVolatile(true);
         path.moveTo(pts[0]);
         path.lineTo(pts[1]);
         fDrawContext->drawPath(fRenderTarget, fClip, grPaint, *draw.fMatrix, path, strokeInfo);
         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 (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
         return;
     }
 
     fDrawContext->drawVertices(fRenderTarget,
                                fClip,
                                grPaint,
                                *draw.fMatrix,
                                gPointMode2PrimtiveType[mode],
                                SkToS32(count),
                                (SkPoint*)pts,
@@ skipping 42 matching lines @@
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(draw, path, paint, nullptr, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
         return;
     }
 
     fDrawContext->drawRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, rect, &strokeInfo);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rect,
                             const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawRRect", fContext);
     CHECK_FOR_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
         return;
     }
 
     GrStrokeInfo strokeInfo(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 50 matching lines @@
 
 void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
                              const SkRRect& inner, const SkPaint& paint) {
     SkStrokeRec stroke(paint);
     if (stroke.isFillStyle()) {
 
         CHECK_FOR_ANNOTATION(paint);
         CHECK_SHOULD_DRAW(draw);
 
         GrPaint grPaint;
-        if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+        if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
             return;
         }
 
         if (nullptr == paint.getMaskFilter() && nullptr == paint.getPathEffect()) {
             fDrawContext->drawDRRect(fRenderTarget, fClip, grPaint, *draw.fMatrix, outer, inner);
             return;
         }
     }
 
     SkPath path;
@@ skipping 31 matching lines @@
 
     if (usePath) {
         SkPath path;
         path.setIsVolatile(true);
         path.addOval(oval);
         this->drawPath(draw, path, paint, nullptr, true);
         return;
     }
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
         return;
     }
 
     fDrawContext->drawOval(fRenderTarget, fClip, grPaint, *draw.fMatrix, oval, strokeInfo);
 }
 
 #include "SkMaskFilter.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 314 matching lines @@
     // Setup texture to wrap bitmap
     GrTextureParams params(tm, textureFilterMode);
     SkAutoTUnref<GrTexture> texture(GrRefCachedBitmapTexture(context, *bitmapPtr, &params));
 
     if (!texture) {
         SkErrorInternals::SetError(kInternalError_SkError,
                                    "Couldn't convert bitmap to texture.");
         return;
     }
 
-    // Setup paint
-    GrColor paintColor = (kAlpha_8_SkColorType == bitmapPtr->colorType()) ?
-                         SkColor2GrColor(paint.getColor()) :
-                         SkColor2GrColorJustAlpha(paint.getColor());
 
     GrPaint grPaint;
 
     // Create and insert texture effect
     SkAutoTUnref<const GrFragmentProcessor> fp;
     if (doBicubic) {
         fp.reset(GrBicubicEffect::Create(grPaint.getProcessorDataManager(), texture,
                                          SkMatrix::I(),
                                          tm));
     } else {
         fp.reset(GrSimpleTextureEffect::Create(grPaint.getProcessorDataManager(), texture,
                                                SkMatrix::I(), params));
     }
 
-    // The bitmap read has to be first
-    grPaint.addColorFragmentProcessor(fp);
-    if (!SkPaint2GrPaintNoShader(context, paint, SkColor2GrColor(paint.getColor()), false,
-                                 &grPaint)) {
+    if (kAlpha_8_SkColorType == bitmapPtr->colorType()) {
+        fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
+    } else {
+        fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
+    }
+
+    if (!SkPaintToGrPaintReplaceShader(context, paint, fp, &grPaint)) {
         return;
     }
 
-    grPaint.setColor(paintColor);
-
     // Setup dst rect and final matrix
     SkRect dstRect = {0, 0, dstSize.fWidth, dstSize.fHeight};
 
     SkRect devRect;
     viewMatrix.mapRect(&devRect, dstRect);
 
     SkMatrix matrix;
     matrix.setIDiv(bitmapPtr->width(), bitmapPtr->height());
 
     SkMatrix dstRectToSrcRect;
@@ skipping 275 matching lines @@
     paintRect.setLTRB(SkScalarMul(srcRect.fLeft,   wInv),
                       SkScalarMul(srcRect.fTop,    hInv),
                       SkScalarMul(srcRect.fRight,  wInv),
                       SkScalarMul(srcRect.fBottom, hInv));
 
     SkRect textureDomain = SkRect::MakeEmpty();
 
     // Construct a GrPaint by setting the bitmap texture as the first effect and then configuring
     // the rest from the SkPaint.
     GrPaint grPaint;
-    SkAutoTUnref<GrFragmentProcessor> fp;
+    SkAutoTUnref<const GrFragmentProcessor> fp;
 
     if (needsTextureDomain && (SkCanvas::kStrict_SrcRectConstraint == constraint)) {
         // Use a constrained texture domain to avoid color bleeding
         SkScalar left, top, right, bottom;
         if (srcRect.width() > SK_Scalar1) {
             SkScalar border = SK_ScalarHalf / texture->width();
             left = paintRect.left() + border;
             right = paintRect.right() - border;
         } else {
             left = right = SkScalarHalf(paintRect.left() + paintRect.right());
@@ skipping 20 matching lines @@
     } else if (bicubic) {
         SkASSERT(GrTextureParams::kNone_FilterMode == params.filterMode());
         SkShader::TileMode tileModes[2] = { params.getTileModeX(), params.getTileModeY() };
         fp.reset(GrBicubicEffect::Create(grPaint.getProcessorDataManager(), texture, SkMatrix::I(),
                                          tileModes));
     } else {
         fp.reset(GrSimpleTextureEffect::Create(grPaint.getProcessorDataManager(), texture,
                                                SkMatrix::I(), params));
     }
 
-    grPaint.addColorFragmentProcessor(fp);
-    bool alphaOnly = !(kAlpha_8_SkColorType == bitmap.colorType());
-    GrColor paintColor = (alphaOnly) ? SkColor2GrColorJustAlpha(paint.getColor()) :
-                                       SkColor2GrColor(paint.getColor());
-    if (!SkPaint2GrPaintNoShader(this->context(), paint, paintColor, false, &grPaint)) {
+    if (kAlpha_8_SkColorType == bitmap.colorType()) {
+        fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
+    } else {
+        fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
+    }
+
+    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
         return;
     }
 
     fDrawContext->drawNonAARectToRect(fRenderTarget, fClip, grPaint, viewMatrix, dstRect,
                                       paintRect);
 }
 
 bool SkGpuDevice::filterTexture(GrContext* context, GrTexture* texture,
                                 int width, int height,
                                 const SkImageFilter* filter,
@@ skipping 24 matching lines @@
     int w = bitmap.width();
     int h = bitmap.height();
 
     GrTexture* texture;
     // draw sprite uses the default texture params
     AutoBitmapTexture abt(fContext, bitmap, nullptr, &texture);
     if (!texture) {
         return;
     }
 
+    bool alphaOnly = kAlpha_8_SkColorType == bitmap.colorType();
+
     SkImageFilter* filter = paint.getImageFilter();
     // This bitmap will own the filtered result as a texture.
     SkBitmap filteredBitmap;
 
     if (filter) {
         SkIPoint offset = SkIPoint::Make(0, 0);
         SkMatrix matrix(*draw.fMatrix);
         matrix.postTranslate(SkIntToScalar(-left), SkIntToScalar(-top));
         SkIRect clipBounds = SkIRect::MakeWH(bitmap.width(), bitmap.height());
         SkAutoTUnref<SkImageFilter::Cache> cache(getImageFilterCache());
         // This cache is transient, and is freed (along with all its contained
         // textures) when it goes out of scope.
         SkImageFilter::Context ctx(matrix, clipBounds, cache);
         if (this->filterTexture(fContext, texture, w, h, filter, ctx, &filteredBitmap,
                                 &offset)) {
             texture = (GrTexture*) filteredBitmap.getTexture();
             w = filteredBitmap.width();
             h = filteredBitmap.height();
             left += offset.x();
             top += offset.y();
         } else {
             return;
         }
+        SkASSERT(!GrPixelConfigIsAlphaOnly(texture->config()));
+        alphaOnly = false;
     }
 
     GrPaint grPaint;
-    grPaint.addColorTextureProcessor(texture, SkMatrix::I());
-
-    if (!SkPaint2GrPaintNoShader(this->context(), paint,
-                                 SkColor2GrColorJustAlpha(paint.getColor()), false, &grPaint)) {
+    SkAutoTUnref<const GrFragmentProcessor> fp(
+        GrSimpleTextureEffect::Create(grPaint.getProcessorDataManager(), texture, SkMatrix::I()));
+    if (alphaOnly) {
+        fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
+    } else {
+        fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
+    }
+    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
         return;
     }
 
     fDrawContext->drawNonAARectToRect(fRenderTarget,
                                       fClip,
                                       grPaint,
                                       SkMatrix::I(),
                                       SkRect::MakeXYWH(SkIntToScalar(left),
                                                        SkIntToScalar(top),
                                                        SkIntToScalar(w),
@@ skipping 91 matching lines @@
             w = filteredBitmap.width();
             h = filteredBitmap.height();
             x += offset.fX;
             y += offset.fY;
         } else {
             return;
         }
     }
 
     GrPaint grPaint;
-    grPaint.addColorTextureProcessor(devTex, SkMatrix::I());
+    SkAutoTUnref<const GrFragmentProcessor> fp(
+        GrSimpleTextureEffect::Create(grPaint.getProcessorDataManager(), devTex, SkMatrix::I()));
+    if (GrPixelConfigIsAlphaOnly(devTex->config())) {
+        // Can this happen?
+        fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
+   } else {
+        fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
+    }
 
-    if (!SkPaint2GrPaintNoShader(this->context(), paint,
-                                 SkColor2GrColorJustAlpha(paint.getColor()), false, &grPaint)) {
+    if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp, &grPaint)) {
         return;
     }
 
     SkRect dstRect = SkRect::MakeXYWH(SkIntToScalar(x),
                                       SkIntToScalar(y),
                                       SkIntToScalar(w),
                                       SkIntToScalar(h));
 
     // The device being drawn may not fill up its texture (e.g. saveLayer uses approximate
     // scratch texture).
@@ skipping 100 matching lines @@
 
 void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
                               int vertexCount, const SkPoint vertices[],
                               const SkPoint texs[], const SkColor colors[],
                               SkXfermode* xmode,
                               const uint16_t indices[], int indexCount,
                               const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawVertices", fContext);
 
-    const uint16_t* outIndices;
-    SkAutoTDeleteArray<uint16_t> outAlloc(nullptr);
-    GrPrimitiveType primType;
-    GrPaint grPaint;
-
     // If both textures and vertex-colors are nullptr, strokes hairlines with the paint's color.
     if ((nullptr == texs || nullptr == paint.getShader()) && nullptr == colors) {
 
         texs = nullptr;
 
         SkPaint copy(paint);
         copy.setStyle(SkPaint::kStroke_Style);
         copy.setStrokeWidth(0);
 
+        GrPaint grPaint;
         // we ignore the shader if texs is null.
-        if (!SkPaint2GrPaintNoShader(this->context(), copy,
-                                     SkColor2GrColor(copy.getColor()), nullptr == colors, &grPaint)) {
+        if (!SkPaintToGrPaintNoShader(this->context(), copy, &grPaint)) {
             return;
         }
 
-        primType = kLines_GrPrimitiveType;
         int triangleCount = 0;
         int n = (nullptr == indices) ? vertexCount : indexCount;
         switch (vmode) {
             case SkCanvas::kTriangles_VertexMode:
                 triangleCount = n / 3;
                 break;
             case SkCanvas::kTriangleStrip_VertexMode:
             case SkCanvas::kTriangleFan_VertexMode:
                 triangleCount = n - 2;
                 break;
         }
 
         VertState       state(vertexCount, indices, indexCount);
         VertState::Proc vertProc = state.chooseProc(vmode);
 
         //number of indices for lines per triangle with kLines
         indexCount = triangleCount * 6;
 
-        outAlloc.reset(new uint16_t[indexCount]);
-        outIndices = outAlloc.get();
-        uint16_t* auxIndices = outAlloc.get();
+        SkAutoTDeleteArray<uint16_t> lineIndices(new uint16_t[indexCount]);
         int i = 0;
         while (vertProc(&state)) {
-            auxIndices[i]     = state.f0;
-            auxIndices[i + 1] = state.f1;
-            auxIndices[i + 2] = state.f1;
-            auxIndices[i + 3] = state.f2;
-            auxIndices[i + 4] = state.f2;
-            auxIndices[i + 5] = state.f0;
+            lineIndices[i]     = state.f0;
+            lineIndices[i + 1] = state.f1;
+            lineIndices[i + 2] = state.f1;
+            lineIndices[i + 3] = state.f2;
+            lineIndices[i + 4] = state.f2;
+            lineIndices[i + 5] = state.f0;
             i += 6;
         }
-    } else {
-        outIndices = indices;
-        primType = gVertexMode2PrimitiveType[vmode];
-
-        if (nullptr == texs || nullptr == paint.getShader()) {
-            if (!SkPaint2GrPaintNoShader(this->context(), paint,
-                                         SkColor2GrColor(paint.getColor()),
-                                         nullptr == colors, &grPaint)) {
-                return;
-            }
-        } else {
-            if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix,
-                                 nullptr == colors, &grPaint)) {
-                return;
-            }
-        }
+        fDrawContext->drawVertices(fRenderTarget,
+                                   fClip,
+                                   grPaint,
+                                   *draw.fMatrix,
+                                   kLines_GrPrimitiveType,
+                                   vertexCount,
+                                   vertices,
+                                   texs,
+                                   colors,
+                                   lineIndices.get(),
+                                   indexCount);
+        return;
     }
 
-#if 0
-    if (xmode && texs && colors) {
-        if (!SkXfermode::IsMode(xmode, SkXfermode::kModulate_Mode)) {
-            SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
-            return;
-        }
-    }
-#endif
+    GrPrimitiveType primType = gVertexMode2PrimitiveType[vmode];
 
     SkAutoSTMalloc<128, GrColor> convertedColors(0);
     if (colors) {
         // need to convert byte order and from non-PM to PM
         convertedColors.reset(vertexCount);
         SkColor color;
         for (int i = 0; i < vertexCount; ++i) {
             color = colors[i];
             if (paint.getAlpha() != 255) {
                 color = SkColorSetA(color, SkMulDiv255Round(SkColorGetA(color), paint.getAlpha()));
             }
-            convertedColors[i] = SkColor2GrColor(color);
+            /// TODO: Perform the premul after interpolating
+            convertedColors[i] = SkColorToPremulGrColor(color);
         }
         colors = convertedColors.get();
     }
+    GrPaint grPaint;
+    if (texs && colors && paint.getShader()) {
+        // When there are texs and colors the shader and colors are combined using xmode. A null
+        // xmode is defined to mean modulate.
+        SkXfermode::Mode colorMode;
+        if (xmode) {
+            if (!xmode->asMode(&colorMode)) {
+                return;
+            }
+        } else {
+            colorMode = SkXfermode::kModulate_Mode;
+        }
+        if (!SkPaintToGrPaintWithXfermode(this->context(), paint, *draw.fMatrix, colorMode, false,
+                                          &grPaint)) {
+            return;
+        }
+    } else if (!texs) {
+        // Defined to ignore the shader unless texs is provided.
+        if (!SkPaintToGrPaintNoShader(this->context(), paint, &grPaint)) {
+            return;
+        }
+    } else if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
+        return;
+    }
+
     fDrawContext->drawVertices(fRenderTarget,
                                fClip,
                                grPaint,
                                *draw.fMatrix,
                                primType,
                                vertexCount,
                                vertices,
                                texs,
                                colors,
-                               outIndices,
+                               indices,
                                indexCount);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawAtlas(const SkDraw& draw, const SkImage* atlas, const SkRSXform xform[],
                             const SkRect texRect[], const SkColor colors[], int count,
                             SkXfermode::Mode mode, const SkPaint& paint) {
     if (paint.isAntiAlias()) {
         this->INHERITED::drawAtlas(draw, atlas, xform, texRect, colors, count, mode, paint);
         return;
     }
 
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
     
     SkPaint p(paint);
     p.setShader(atlas->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode))->unref();
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), p, *draw.fMatrix, !colors, &grPaint)) {
-        return;
-    }
-    
-    SkDEBUGCODE(this->validate();)
-    
-#if 0
     if (colors) {
-        if (SkXfermode::kModulate_Mode != mode) {
-            SkDebugf("Unsupported vertex-color/texture xfer mode.\n");
+        if (!SkPaintToGrPaintWithXfermode(this->context(), p, *draw.fMatrix, mode, true,
+                                          &grPaint)) {
+            return;
+        }
+    } else {
+        if (!SkPaintToGrPaint(this->context(), p, *draw.fMatrix, &grPaint)) {
             return;
         }
     }
-#endif
-    
+
+    SkDEBUGCODE(this->validate();)
     fDrawContext->drawAtlas(fRenderTarget, 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) {
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawText", fContext);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
                            (const char *)text, byteLength, x, y, draw.fClip->getBounds());
 }
 
 void SkGpuDevice::drawPosText(const SkDraw& draw, const void* text, size_t byteLength,
                               const SkScalar pos[], int scalarsPerPos,
                               const SkPoint& offset, const SkPaint& paint) {
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawPosText", fContext);
     CHECK_SHOULD_DRAW(draw);
 
     GrPaint grPaint;
-    if (!SkPaint2GrPaint(this->context(), paint, *draw.fMatrix, true, &grPaint)) {
+    if (!SkPaintToGrPaint(this->context(), paint, *draw.fMatrix, &grPaint)) {
         return;
     }
 
     SkDEBUGCODE(this->validate();)
 
     fDrawContext->drawPosText(fRenderTarget, fClip, grPaint, paint, *draw.fMatrix,
                               (const char *)text, byteLength, pos, scalarsPerPos, offset,
                               draw.fClip->getBounds());
 }
 
@@ skipping 127 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif