allow more options for shader blitprocs

src/effects/gradients/Sk4fLinearGradient.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "SkUtils.h"
 #include "SkXfermode.h"
@@ skipping 424 matching lines @@
         }
     } else {
         for (int i = 0; i < count; ++i) {
             fDstToPosProc(fDstToPos, sx, sy, &pt);
             ts[i] = pt.x();
             sx += SK_Scalar1;
         }
     }
 }
 
-SkShader::Context::BlitProc SkLinearGradient::
-LinearGradient4fContext::onChooseBlitProc(const SkImageInfo& info, BlitState* state) {
+bool SkLinearGradient::LinearGradient4fContext::onChooseBlitProcs(const SkImageInfo& info,
+                                                                  BlitState* state) {
     SkXfermode::Mode mode;
     if (!SkXfermode::AsMode(state->fXfer, &mode)) {
-        return nullptr;
+        return false;
     }
 
     const SkGradientShaderBase& shader = static_cast<const SkGradientShaderBase&>(fShader);
     if (mode != SkXfermode::kSrc_Mode &&
         !(mode == SkXfermode::kSrcOver_Mode && shader.colorsAreOpaque())) {
-        return nullptr;
+        return false;
     }
 
     switch (info.colorType()) {
         case kN32_SkColorType:
-            return D32_BlitProc;
+            state->fBlitBW = D32_BlitBW;
+            return true;
         case kRGBA_F16_SkColorType:
-            return D64_BlitProc;
+            state->fBlitBW = D64_BlitBW;
+            return true;
         default:
-            return nullptr;
+            return false;
     }
 }
 
 void SkLinearGradient::
-LinearGradient4fContext::D32_BlitProc(BlitState* state, int x, int y, const SkPixmap& dst,
-                                      int count, const SkAlpha aa[]) {
+LinearGradient4fContext::D32_BlitBW(BlitState* state, int x, int y, const SkPixmap& dst,
+                                    int count) {
     // FIXME: ignoring coverage for now
     const LinearGradient4fContext* ctx =
         static_cast<const LinearGradient4fContext*>(state->fCtx);
 
     if (dst.info().isLinear()) {
         if (ctx->fColorsArePremul) {
             ctx->shadePremulSpan<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::False>(
                 x, y, dst.writable_addr32(x, y), count);
         } else {
             ctx->shadePremulSpan<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::True>(
                 x, y, dst.writable_addr32(x, y), count);
         }
     } else {
         if (ctx->fColorsArePremul) {
             ctx->shadePremulSpan<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::False>(
                 x, y, dst.writable_addr32(x, y), count);
         } else {
             ctx->shadePremulSpan<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::True>(
                 x, y, dst.writable_addr32(x, y), count);
         }
     }
 }
 
 void SkLinearGradient::
-LinearGradient4fContext::D64_BlitProc(BlitState* state, int x, int y, const SkPixmap& dst,
-                                      int count, const SkAlpha aa[]) {
+LinearGradient4fContext::D64_BlitBW(BlitState* state, int x, int y, const SkPixmap& dst,
+                                    int count) {
     // FIXME: ignoring coverage for now
     const LinearGradient4fContext* ctx =
         static_cast<const LinearGradient4fContext*>(state->fCtx);
 
     if (ctx->fColorsArePremul) {
         ctx->shadePremulSpan<uint64_t, kLinear_SkColorProfileType, ApplyPremul::False>(
             x, y, dst.writable_addr64(x, y), count);
     } else {
         ctx->shadePremulSpan<uint64_t, kLinear_SkColorProfileType, ApplyPremul::True>(
             x, y, dst.writable_addr64(x, y), count);
     }
 }