Remove the unused 16-bit gradient cache

src/effects/gradients/SkGradientShaderPriv.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGradientShaderPriv_DEFINED
 #define SkGradientShaderPriv_DEFINED
 
@@ skipping 99 matching lines @@
         SkColor fColorStorage[kStorageCount];
         SkScalar fPosStorage[kStorageCount];
         SkMatrix fLocalMatrixStorage;
         SkAutoMalloc fDynamicStorage;
     };
 
 public:
     SkGradientShaderBase(const Descriptor& desc, const SkMatrix& ptsToUnit);
     virtual ~SkGradientShaderBase();
 
-    // The cache is initialized on-demand when getCache16/32 is called.
+    // The cache is initialized on-demand when getCache32 is called.
     class GradientShaderCache : public SkRefCnt {
     public:
         GradientShaderCache(U8CPU alpha, bool dither, const SkGradientShaderBase& shader);
         ~GradientShaderCache();
 
-        const uint16_t*     getCache16();
         const SkPMColor*    getCache32();
 
         SkMallocPixelRef* getCache32PixelRef() const { return fCache32PixelRef; }
 
         unsigned getAlpha() const { return fCacheAlpha; }
         bool getDither() const { return fCacheDither; }
 
     private:
-        // Working pointers. If either is nullptr, we need to recompute the corresponding
-        // cache values.
-        uint16_t*   fCache16;
+        // Working pointer. If it's nullptr, we need to recompute the cache values.
         SkPMColor*  fCache32;
 
-        uint16_t*         fCache16Storage;    // Storage for fCache16, allocated on demand.
         SkMallocPixelRef* fCache32PixelRef;
         const unsigned    fCacheAlpha;        // The alpha value we used when we computed the cache.
                                               // Larger than 8bits so we can store uninitialized
                                               // value.
         const bool        fCacheDither;       // The dither flag used when we computed the cache.
 
         const SkGradientShaderBase& fShader;
 
-        // Make sure we only initialize the caches once.
-        SkOnce fCache16InitOnce,
-               fCache32InitOnce;
+        // Make sure we only initialize the cache once.
+        SkOnce fCache32InitOnce;
 
-        static void initCache16(GradientShaderCache* cache);
         static void initCache32(GradientShaderCache* cache);
 
-        static void Build16bitCache(uint16_t[], SkColor c0, SkColor c1, int count, bool dither);
         static void Build32bitCache(SkPMColor[], SkColor c0, SkColor c1, int count,
                                     U8CPU alpha, uint32_t gradFlags, bool dither);
     };
 
     class GradientShaderBaseContext : public SkShader::Context {
     public:
         GradientShaderBaseContext(const SkGradientShaderBase& shader, const ContextRec&);
 
         uint32_t getFlags() const override { return fFlags; }
 
@@ skipping 10 matching lines @@
         typedef SkShader::Context INHERITED;
     };
 
     bool isOpaque() const override;
 
     void getGradientTableBitmap(SkBitmap*) const;
 
     enum {
         /// Seems like enough for visual accuracy. TODO: if pos[] deserves
         /// it, use a larger cache.
-        kCache16Bits    = 8,
-        kCache16Count = (1 << kCache16Bits),
-        kCache16Shift   = 16 - kCache16Bits,
-        kSqrt16Shift    = 8 - kCache16Bits,
-
-        /// Seems like enough for visual accuracy. TODO: if pos[] deserves
-        /// it, use a larger cache.
         kCache32Bits    = 8,
         kCache32Count   = (1 << kCache32Bits),
         kCache32Shift   = 16 - kCache32Bits,
         kSqrt32Shift    = 8 - kCache32Bits,
 
         /// This value is used to *read* the dither cache; it may be 0
         /// if dithering is disabled.
         kDitherStride32 = kCache32Count,
-        kDitherStride16 = kCache16Count,
     };
 
     uint32_t getGradFlags() const { return fGradFlags; }
 
 protected:
     class GradientShaderBase4fContext;
 
     SkGradientShaderBase(SkReadBuffer& );
     void flatten(SkWriteBuffer&) const override;
     SK_TO_STRING_OVERRIDE()
@@ skipping 56 matching lines @@
 static inline int init_dither_toggle(int x, int y) {
     x &= 1;
     y = (y & 1) << 1;
     return (x | y) * SkGradientShaderBase::kDitherStride32;
 }
 
 static inline int next_dither_toggle(int toggle) {
     return toggle ^ SkGradientShaderBase::kDitherStride32;
 }
 
-static inline int init_dither_toggle16(int x, int y) {
-    return ((x ^ y) & 1) * SkGradientShaderBase::kDitherStride16;
-}
-
-static inline int next_dither_toggle16(int toggle) {
-    return toggle ^ SkGradientShaderBase::kDitherStride16;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrCoordTransform.h"
 #include "GrFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 
 class GrInvariantOutput;
@@ skipping 191 matching lines @@
     SkScalar fCachedYCoord;
     GrGLSLProgramDataManager::UniformHandle fColorsUni;
     GrGLSLProgramDataManager::UniformHandle fFSYUni;
 
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 #endif
 
 #endif