remove shadeSpan16 from shader

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 54 matching lines @@
     };
 
     enum {
         kTileModeCount = kMirror_TileMode + 1
     };
 
     // override these in your subclass
 
     enum Flags {
         //!< set if all of the colors will be opaque
-        kOpaqueAlpha_Flag  = 0x01,
-
-        //! set if this shader's shadeSpan16() method can be called
-        kHasSpan16_Flag = 0x02,
-
-        /** Set this bit if the shader's native data type is instrinsically 16
-            bit, meaning that calling the 32bit shadeSpan() entry point will
-            mean the the impl has to up-sample 16bit data into 32bit. Used as a
-            a means of clearing a dither request if the it will have no effect
-        */
-        kIntrinsicly16_Flag = 0x04,
+        kOpaqueAlpha_Flag = 1 << 0,
 
         /** set if the spans only vary in X (const in Y).
             e.g. an Nx1 bitmap that is being tiled in Y, or a linear-gradient
             that varies from left-to-right. This flag specifies this for
             shadeSpan().
          */
-        kConstInY32_Flag = 0x08,
-
-        /** same as kConstInY32_Flag, but is set if this is true for shadeSpan16
-            which may not always be the case, since shadeSpan16 may be
-            predithered, which would mean it was not const in Y, even though
-            the 32bit shadeSpan() would be const.
-         */
-        kConstInY16_Flag = 0x10
+        kConstInY32_Flag = 1 << 1,
     };
 
     /**
      *  Returns true if the shader is guaranteed to produce only opaque
      *  colors, subject to the SkPaint using the shader to apply an opaque
      *  alpha value. Subclasses should override this to allow some
      *  optimizations.
      */
     virtual bool isOpaque() const { return false; }
 
@@ skipping 20 matching lines @@
         /**
          *  Called sometimes before drawing with this shader. Return the type of
          *  alpha your shader will return. The default implementation returns 0.
          *  Your subclass should override if it can (even sometimes) report a
          *  non-zero value, since that will enable various blitters to perform
          *  faster.
          */
         virtual uint32_t getFlags() const { return 0; }
 
         /**
-         *  Return the alpha associated with the data returned by shadeSpan16(). If
-         *  kHasSpan16_Flag is not set, this value is meaningless.
-         */
-        virtual uint8_t getSpan16Alpha() const { return fPaintAlpha; }
-
-        /**
          *  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;
 
         /**
          * 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);
 
         /**
-         *  Called only for 16bit devices when getFlags() returns
-         *  kOpaqueAlphaFlag | kHasSpan16_Flag
-         */
-        virtual void shadeSpan16(int x, int y, uint16_t[], int count);
-
-        /**
          *  Similar to shadeSpan, but only returns the alpha-channel for a span.
          *  The default implementation calls shadeSpan() and then extracts the alpha
          *  values from the returned colors.
          */
         virtual void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count);
 
-        /**
-         *  Helper function that returns true if this shader's shadeSpan16() method
-         *  can be called.
-         */
-        bool canCallShadeSpan16() {
-            return SkShader::CanCallShadeSpan16(this->getFlags());
-        }
-
         // Notification from blitter::blitMask in case we need to see the non-alpha channels
         virtual void set3DMask(const SkMask*) {}
 
     protected:
         // Reference to shader, so we don't have to dupe information.
         const SkShader& fShader;
 
         enum MatrixClass {
             kLinear_MatrixClass,            // no perspective
             kFixedStepInX_MatrixClass,      // fast perspective, need to call fixedStepInX() each
@@ skipping 23 matching lines @@
 
     /**
      *  Return the size of a Context returned by createContext.
      *
      *  Override this if your subclass overrides createContext, to return the correct size of
      *  your subclass' context.
      */
     virtual size_t contextSize() const;
 
     /**
-     *  Helper to check the flags to know if it is legal to call shadeSpan16()
-     */
-    static bool CanCallShadeSpan16(uint32_t flags) {
-        return (flags & kHasSpan16_Flag) != 0;
-    }
-
-    /**
      *  Returns true if this shader is just a bitmap, and if not null, returns the bitmap,
      *  localMatrix, and tilemodes. If this is not a bitmap, returns false and ignores the
      *  out-parameters.
      */
     bool isABitmap(SkBitmap* outTexture, SkMatrix* outMatrix, TileMode xy[2]) const {
         return this->onIsABitmap(outTexture, outMatrix, xy);
     }
 
     bool isABitmap() const {
         return this->isABitmap(nullptr, nullptr, nullptr);
@@ skipping 204 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