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

include/core/SkColorShader.h

Index: include/core/SkColorShader.h
diff --git a/include/core/SkColorShader.h b/include/core/SkColorShader.h
index 975156c0eb3a9e10120a02a92070030a72d3912e..56e5add4a31a446667ed5c121f92432de9f80657 100644
--- a/include/core/SkColorShader.h
+++ b/include/core/SkColorShader.h
@@ -30,16 +30,35 @@ public:
     */
     SkColorShader(SkColor c);
 
-    virtual ~SkColorShader();
-
-    virtual uint32_t getFlags() SK_OVERRIDE;
-    virtual uint8_t getSpan16Alpha() const SK_OVERRIDE;
     virtual bool isOpaque() const SK_OVERRIDE;
-    virtual bool setContext(const SkBitmap& device, const SkPaint& paint,
-                            const SkMatrix& matrix) SK_OVERRIDE;
-    virtual void shadeSpan(int x, int y, SkPMColor span[], int count) SK_OVERRIDE;
-    virtual void shadeSpan16(int x, int y, uint16_t span[], int count) SK_OVERRIDE;
-    virtual void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) SK_OVERRIDE;
+
+    virtual SkShader::Context* createContext(const SkBitmap& device,
+                                             const SkPaint& paint,
+                                             const SkMatrix& matrix,
+                                             void* storage) const SK_OVERRIDE;
+
+    virtual size_t contextSize() const SK_OVERRIDE {
+        return sizeof(ColorShaderContext);
+    }
+
+    class ColorShaderContext : public SkShader::Context {
+    public:
+        ColorShaderContext(const SkColorShader& shader, const SkBitmap& device,
+                           const SkPaint& paint, const SkMatrix& matrix);
+
+        virtual uint32_t getFlags() const SK_OVERRIDE;
+        virtual uint8_t getSpan16Alpha() const SK_OVERRIDE;
+        virtual void shadeSpan(int x, int y, SkPMColor span[], int count) SK_OVERRIDE;

[Stephen White, 2014/04/03 16:08:57]

It seems a little odd to me that the actual processing is performed on the
Context. Would it make sense to leave processing on the shader, and simply have
it take a Context? That would require a context downcast in each subclass I
suppose.

[scroggo, 2014/04/03 16:32:35]

At one point I considered that approach. I think I moved away from that for a
couple of reasons:

- It means we have to hang on to pointers to two objects, and use them in tandem
(although I think ultimately in this approach we hang on to the shader in order
to call resetShaderContext). The context does hang on to its shader, but only as
a const reference.

- What does it mean if I passed the wrong context to a shader? (This probably
wouldn't happen, but the API allows you to provide different context objects.)

- It seemed like most of the information I wanted to process was on the context
(though some is on the shader - I haven't actually counted all the callers), so
it seemed like an extra hassle to have every function read all its info off the
passed in object.

All that said, I'm not opposed in principle to doing the processing in the
shader; I just thought this way was more convenient.

+        virtual void shadeSpan16(int x, int y, uint16_t span[], int count) SK_OVERRIDE;
+        virtual void shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) SK_OVERRIDE;
+
+    private:
+        SkPMColor   fPMColor;
+        uint32_t    fFlags;
+        uint16_t    fColor16;
+
+        typedef SkShader::Context INHERITED;
+    };
 
     // we return false for this, use asAGradient
     virtual BitmapType asABitmap(SkBitmap* outTexture,
@@ -56,11 +75,7 @@ protected:
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
-
     SkColor     fColor;         // ignored if fInheritColor is true
-    SkPMColor   fPMColor;       // cached after setContext()
-    uint32_t    fFlags;         // cached after setContext()
-    uint16_t    fColor16;       // cached after setContext()
     SkBool8     fInheritColor;
 
     typedef SkShader INHERITED;