allow more options for shader blitprocs

include/core/SkShader.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkShader_DEFINED
 #define SkShader_DEFINED
 
@@ skipping 124 matching lines @@
 
         /**
          *  Called for each span of the object being drawn. Your subclass should
          *  set the appropriate colors (with premultiplied alpha) that correspond
          *  to the specified device coordinates.
          */
         virtual void shadeSpan(int x, int y, SkPMColor[], int count) = 0;
 
         virtual void shadeSpan4f(int x, int y, SkPM4f[], int count);
 
+        struct BlitState;
+        typedef void (*BlitBW)(BlitState*,
+                               int x, int y, const SkPixmap&, int count);
+        typedef void (*BlitAA)(BlitState*,
+                               int x, int y, const SkPixmap&, int count, const SkAlpha[]);
+
         struct BlitState {
+            // inputs
             Context*    fCtx;
             SkXfermode* fXfer;
+
+            // outputs
             enum { N = 2 };
             void*       fStorage[N];
+            BlitBW      fBlitBW;
+            BlitAA      fBlitAA;
         };
-        typedef void (*BlitProc)(BlitState*,
-                                 int x, int y, const SkPixmap&, int count, const SkAlpha[]);
-        BlitProc chooseBlitProc(const SkImageInfo& info, BlitState* state) {
-            return this->onChooseBlitProc(info, state);
+
+        // Returns true if one or more of the blitprocs are set in the BlitState
+        bool chooseBlitProcs(const SkImageInfo& info, BlitState* state) {
+            state->fBlitBW = nullptr;
+            state->fBlitAA = nullptr;
+            if (this->onChooseBlitProcs(info, state)) {
+                SkASSERT(state->fBlitBW || state->fBlitAA);
+                return true;
+            }
+            return false;
         }
-        
+
         /**
          * The const void* ctx is only const because all the implementations are const.
          * This can be changed to non-const if a new shade proc needs to change the ctx.
          */
         typedef void (*ShadeProc)(const void* ctx, int x, int y, SkPMColor[], int count);
         virtual ShadeProc asAShadeProc(void** ctx);
 
         /**
          *  Similar to shadeSpan, but only returns the alpha-channel for a span.
          *  The default implementation calls shadeSpan() and then extracts the alpha
@@ skipping 14 matching lines @@
                                             // scanline
             kPerspective_MatrixClass        // slow perspective, need to mappoints each pixel
         };
         static MatrixClass ComputeMatrixClass(const SkMatrix&);
 
         uint8_t         getPaintAlpha() const { return fPaintAlpha; }
         const SkMatrix& getTotalInverse() const { return fTotalInverse; }
         MatrixClass     getInverseClass() const { return (MatrixClass)fTotalInverseClass; }
         const SkMatrix& getCTM() const { return fCTM; }
 
-        virtual BlitProc onChooseBlitProc(const SkImageInfo&, BlitState*) {
-            return nullptr;
-        }
+        virtual bool onChooseBlitProcs(const SkImageInfo&, BlitState*) { return false; }
 
     private:
         SkMatrix    fCTM;
         SkMatrix    fTotalInverse;
         uint8_t     fPaintAlpha;
         uint8_t     fTotalInverseClass;
 
         typedef SkNoncopyable INHERITED;
     };
 
@@ skipping 268 matching lines @@
     SkMatrix fLocalMatrix;
 
     // So the SkLocalMatrixShader can whack fLocalMatrix in its SkReadBuffer constructor.
     friend class SkLocalMatrixShader;
     friend class SkBitmapProcShader;    // for computeTotalInverse()
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif