Fix drawVertices when there is a paint alpha

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 "GrTextureMaker.h"
 
 #include "SkGr.h"
@@ skipping 659 matching lines @@
     }
     if (ptOut) {
         *ptOut = pt;
     }
     return true;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
+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,
                                            const SkPaint& skPaint,
                                            const SkMatrix& viewM,
                                            const GrFragmentProcessor** shaderProcessor,
                                            SkXfermode::Mode* primColorMode,
                                            bool primitiveIsSrc,
                                            GrPaint* grPaint) {
     grPaint->setAntiAlias(skPaint.isAntiAlias());
 
     // Setup the initial color considering the shader, the SkPaint color, and the presence or not
     // of per-vertex colors.
     SkAutoTUnref<const GrFragmentProcessor> aufp;
-    const GrFragmentProcessor* shaderFP = NULL;
-    if (shaderProcessor) {
-        shaderFP = *shaderProcessor;
-    } else if (const SkShader* shader = skPaint.getShader()) {
-        aufp.reset(shader->asFragmentProcessor(context, viewM, NULL, skPaint.getFilterQuality(),
-                                               grPaint->getProcessorDataManager()));
-        shaderFP = aufp;
-        if (!shaderFP) {
-            return false;
+    const GrFragmentProcessor* shaderFP = nullptr;
+    if (!primColorMode || blend_requires_shader(*primColorMode, primitiveIsSrc)) {
+        if (shaderProcessor) {
+            shaderFP = *shaderProcessor;
+        } else if (const SkShader* shader = skPaint.getShader()) {
+            aufp.reset(shader->asFragmentProcessor(context, viewM, nullptr,
+                                                   skPaint.getFilterQuality(),
+                                                   grPaint->getProcessorDataManager()));
+            shaderFP = aufp;
+            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;
     if (shaderFP) {
         if (primColorMode) {
             // There is a blend between the primitive color and the shader color. The shader sees
@@ skipping 43 matching lines @@
                                                                                 *primColorMode));
             } else {
                 processor.reset(GrXfermodeFragmentProcessor::CreateFromSrcProcessor(processor,
                                                                                 *primColorMode));
 
             }
             if (processor) {
                 grPaint->addColorFragmentProcessor(processor);
             }
 
-            grPaint->setColor(SkColorToUnpremulGrColor(skPaint.getColor()) | 0xFF000000);
+            grPaint->setColor(SkColorToOpaqueGrColor(skPaint.getColor()));
 
             GrColor paintAlpha = SkColorAlphaToGrColor(skPaint.getColor());
-            grPaint->addColorFragmentProcessor(GrConstColorProcessor::Create(
-                paintAlpha, GrConstColorProcessor::kModulateRGBA_InputMode))->unref();
+            if (GrColor_WHITE != paintAlpha) {
+                grPaint->addColorFragmentProcessor(GrConstColorProcessor::Create(
+                    paintAlpha, GrConstColorProcessor::kModulateRGBA_InputMode))->unref();
+            }
         } else {
             // No shader, no primitive color.
             grPaint->setColor(SkColorToPremulGrColor(skPaint.getColor()));
             applyColorFilterToPaintColor = true;
         }
     }
 
     SkColorFilter* colorFilter = skPaint.getColorFilter();
     if (colorFilter) {
         if (applyColorFilterToPaintColor) {
@@ skipping 182 matching lines @@
         SkBitmap stretchedBmp = stretch_on_cpu(bitmap, stretch);
         return create_unstretched_bitmap_texture(ctx, stretchedBmp, GrUniqueKey());
     } else {
         SkAutoTUnref<GrTexture> unstretched(this->onRefUnstretchedTexture(ctx));
         if (!unstretched) {
             return nullptr;
         }
         return stretch_texture(unstretched, stretch, nullptr, GrUniqueKey());
     }
 }