Revert of Extract most of the mutable state of SkShader into a separate Context object.

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
 
 #include "SkGradientShader.h"
 #include "SkClampRange.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMallocPixelRef.h"
 #include "SkUnitMapper.h"
 #include "SkUtils.h"
 #include "SkTemplates.h"
 #include "SkBitmapCache.h"
 #include "SkShader.h"
-#include "SkOnce.h"
 
 static inline void sk_memset32_dither(uint32_t dst[], uint32_t v0, uint32_t v1,
                                int count) {
     if (count > 0) {
         if (v0 == v1) {
             sk_memset32(dst, v0, count);
         } else {
             int pairs = count >> 1;
             for (int i = 0; i < pairs; i++) {
                 *dst++ = v0;
@@ skipping 62 matching lines @@
         int                 fCount;
         SkShader::TileMode  fTileMode;
         SkUnitMapper*       fMapper;
         uint32_t            fFlags;
     };
 
 public:
     SkGradientShaderBase(const Descriptor& desc);
     virtual ~SkGradientShaderBase();
 
-    // The cache is initialized on-demand when getCache16/32 is called.
-    class GradientShaderCache : public SkRefCnt {
-    public:
-        GradientShaderCache(U8CPU alpha, const SkGradientShaderBase& shader);
-        ~GradientShaderCache();
-
-        const uint16_t*     getCache16();
-        const SkPMColor*    getCache32();
-
-        SkMallocPixelRef* getCache32PixelRef() const { return fCache32PixelRef; }
-
-        unsigned getAlpha() const { return fCacheAlpha; }
-
-    private:
-        // Working pointers. If either is NULL, we need to recompute the corresponding cache values.
-        uint16_t*   fCache16;
-        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 SkGradientShaderBase& fShader;
-
-        // Make sure we only initialize the caches once.
-        bool    fCache16Inited, fCache32Inited;
-        SkMutex fCache16Mutex, fCache32Mutex;
-
-        static void initCache16(GradientShaderCache* cache);
-        static void initCache32(GradientShaderCache* cache);
-
-        static void Build16bitCache(uint16_t[], SkColor c0, SkColor c1, int count);
-        static void Build32bitCache(SkPMColor[], SkColor c0, SkColor c1, int count,
-                                    U8CPU alpha, uint32_t gradFlags);
-    };
-
-    class GradientShaderBaseContext : public SkShader::Context {
-    public:
-        GradientShaderBaseContext(const SkGradientShaderBase& shader, const SkBitmap& device,
-                                  const SkPaint& paint, const SkMatrix& matrix);
-        ~GradientShaderBaseContext() {}
-
-        virtual uint32_t getFlags() const SK_OVERRIDE { return fFlags; }
-
-    protected:
-        SkMatrix    fDstToIndex;
-        SkMatrix::MapXYProc fDstToIndexProc;
-        uint8_t     fDstToIndexClass;
-        uint8_t     fFlags;
-
-        SkAutoTUnref<GradientShaderCache> fCache;
-
-    private:
-        typedef SkShader::Context INHERITED;
-    };
-
+    virtual bool setContext(const SkBitmap&, const SkPaint&, const SkMatrix&) SK_OVERRIDE;
+    virtual uint32_t getFlags() SK_OVERRIDE { return fFlags; }
     virtual bool isOpaque() const SK_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,
     };
 
+
 protected:
     SkGradientShaderBase(SkReadBuffer& );
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
     SK_TO_STRING_OVERRIDE()
 
     SkUnitMapper* fMapper;
     SkMatrix    fPtsToUnit;     // set by subclass
+    SkMatrix    fDstToIndex;
+    SkMatrix::MapXYProc fDstToIndexProc;
     TileMode    fTileMode;
     TileProc    fTileProc;
     int         fColorCount;
+    uint8_t     fDstToIndexClass;
+    uint8_t     fFlags;
     uint8_t     fGradFlags;
 
     struct Rec {
         SkFixed     fPos;   // 0...1
         uint32_t    fScale; // (1 << 24) / range
     };
     Rec*        fRecs;
 
+    const uint16_t*     getCache16() const;
+    const SkPMColor*    getCache32() const;
+
     void commonAsAGradient(GradientInfo*) const;
 
 private:
     enum {
         kColorStorageCount = 4, // more than this many colors, and we'll use sk_malloc for the space
 
         kStorageSize = kColorStorageCount * (sizeof(SkColor) + sizeof(Rec))
     };
     SkColor     fStorage[(kStorageSize + 3) >> 2];
-    SkColor*    fOrigColors; // original colors, before modulation by paint in context.
+    SkColor*    fOrigColors; // original colors, before modulation by paint in setContext
     bool        fColorsAreOpaque;
 
-    GradientShaderCache* getCache(U8CPU alpha) const;
-    mutable SkMutex                           fCacheMutex;
-    mutable SkAutoTUnref<GradientShaderCache> fCache;
+    mutable uint16_t*   fCache16;   // working ptr. If this is NULL, we need to recompute the cache values
+    mutable SkPMColor*  fCache32;   // working ptr. If this is NULL, we need to recompute the cache values
 
+    mutable uint16_t*   fCache16Storage;    // storage for fCache16, allocated on demand
+    mutable SkMallocPixelRef* fCache32PixelRef;
+    mutable unsigned    fCacheAlpha;        // the alpha value we used when we computed the cache. larger than 8bits so we can store uninitialized value
+
+    static void Build16bitCache(uint16_t[], SkColor c0, SkColor c1, int count);
+    static void Build32bitCache(SkPMColor[], SkColor c0, SkColor c1, int count,
+                                U8CPU alpha, uint32_t gradFlags);
+    void setCacheAlpha(U8CPU alpha) const;
     void initCommon();
 
     typedef SkShader INHERITED;
 };
 
 static inline int init_dither_toggle(int x, int y) {
     x &= 1;
     y = (y & 1) << 1;
     return (x | y) * SkGradientShaderBase::kDitherStride32;
 }
@@ skipping 191 matching lines @@
     GrGLUniformManager::UniformHandle fColorStartUni;
     GrGLUniformManager::UniformHandle fColorMidUni;
     GrGLUniformManager::UniformHandle fColorEndUni;
 
     typedef GrGLEffect INHERITED;
 };
 
 #endif
 
 #endif