Work in progress to make SkShader immutable.

src/core/SkShader.cpp

 /*
  * 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.
  */
 
 
 #include "SkScalar.h"
 #include "SkShader.h"
@@ skipping 24 matching lines @@
 
 void SkShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     bool hasLocalM = this->hasLocalMatrix();
     buffer.writeBool(hasLocalM);
     if (hasLocalM) {
         buffer.writeMatrix(fLocalMatrix);
     }
 }
 
-bool SkShader::setContext(const SkBitmap& device,
-                          const SkPaint& paint,
-                          const SkMatrix& matrix) {
+SkShader::Context::Context(const SkMatrix& matrix, uint8_t paintAlpha,
+                           SkBitmap::Config deviceConfig)
+    : fTotalInverse(matrix)
+    , fPaintAlpha(paintAlpha)
+    , fDeviceConfig(SkToU8(deviceConfig))
+    , fTotalInverseClass((uint8_t) ComputeMatrixClass(fTotalInverse))
+    , fExtraStorage(NULL)
+{
+    // debugcode...
+    fStorageAllocated = false;
+}
+
+SkShader::Context* SkShader::setContext(const SkBitmap& device,
+                                        const SkPaint& paint,
+                                        const SkMatrix& matrix) {
     SkASSERT(!this->setContextHasBeenCalled());
 
     const SkMatrix* m = &matrix;
     SkMatrix        total;
 
-    fDeviceConfig = SkToU8(device.config());
-    fPaintAlpha = paint.getAlpha();
+    // FIXME: Store localMatrix on paint.
     if (this->hasLocalMatrix()) {
         total.setConcat(matrix, this->getLocalMatrix());
         m = &total;
     }
-    if (m->invert(&fTotalInverse)) {
-        fTotalInverseClass = (uint8_t)ComputeMatrixClass(fTotalInverse);
+    SkMatrix totalInverse;
+    if (m->invert(&totalInverse)) {
+        Context* context = SkNEW_ARGS(Context, (totalInverse, paint.getAlpha(), device.config()));
+        // Initialize the subclass storage space.
+        context->reset(this);
+        // Now call into subclasses.
+        if (!this->onSetContext(context, device, paint, matrix)) {
+            SkDELETE(context);
+            return NULL;
+        }
         SkDEBUGCODE(fInSetContext = true;)
-        return true;
+        return context;
     }
-    return false;
+    return NULL;
 }
 
-void SkShader::endContext() {
+void SkShader::endContext(Context* c) {
     SkASSERT(fInSetContext);
+    SkDELETE(c);
     SkDEBUGCODE(fInSetContext = false;)
 }
 
 SkShader::ShadeProc SkShader::asAShadeProc(void** ctx) {
     return NULL;
 }
 
 #include "SkColorPriv.h"
 
-void SkShader::shadeSpan16(int x, int y, uint16_t span16[], int count) {
+void SkShader::shadeSpan16(Context* c, int x, int y, uint16_t span16[], int count) {
     SkASSERT(span16);
     SkASSERT(count > 0);
     SkASSERT(this->canCallShadeSpan16());
 
     // basically, if we get here, the subclass screwed up
     SkDEBUGFAIL("kHasSpan16 flag is set, but shadeSpan16() not implemented");
 }
 
 #define kTempColorQuadCount 6   // balance between speed (larger) and saving stack-space
 #define kTempColorCount     (kTempColorQuadCount << 2)
 
 #ifdef SK_CPU_BENDIAN
     #define SkU32BitShiftToByteOffset(shift)    (3 - ((shift) >> 3))
 #else
     #define SkU32BitShiftToByteOffset(shift)    ((shift) >> 3)
 #endif
 
-void SkShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
+void SkShader::shadeSpanAlpha(Context* context, int x, int y, uint8_t alpha[], int count) {
     SkASSERT(count > 0);
 
     SkPMColor   colors[kTempColorCount];
 
     while ((count -= kTempColorCount) >= 0) {
-        this->shadeSpan(x, y, colors, kTempColorCount);
+        this->shadeSpan(context, x, y, colors, kTempColorCount);
         x += kTempColorCount;
 
         const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
         int quads = kTempColorQuadCount;
         do {
             U8CPU a0 = srcA[0];
             U8CPU a1 = srcA[4];
             U8CPU a2 = srcA[8];
             U8CPU a3 = srcA[12];
             srcA += 4*4;
             *alpha++ = SkToU8(a0);
             *alpha++ = SkToU8(a1);
             *alpha++ = SkToU8(a2);
             *alpha++ = SkToU8(a3);
         } while (--quads != 0);
     }
     SkASSERT(count < 0);
     SkASSERT(count + kTempColorCount >= 0);
     if (count += kTempColorCount) {
-        this->shadeSpan(x, y, colors, count);
+        this->shadeSpan(context, x, y, colors, count);
 
         const uint8_t* srcA = (const uint8_t*)colors + SkU32BitShiftToByteOffset(SK_A32_SHIFT);
         do {
             *alpha++ = *srcA;
             srcA += 4;
         } while (--count != 0);
     }
 #if 0
     do {
         int n = count;
@@ skipping 97 matching lines @@
     if (fInheritColor) {
         return;
     }
     buffer.writeColor(fColor);
 }
 
 uint32_t SkColorShader::getFlags() {
     return fFlags;
 }
 
-uint8_t SkColorShader::getSpan16Alpha() const {
+uint8_t SkColorShader::getSpan16Alpha(Context* c) const {
     return SkGetPackedA32(fPMColor);
 }
 
-bool SkColorShader::setContext(const SkBitmap& device, const SkPaint& paint,
-                               const SkMatrix& matrix) {
-    if (!this->INHERITED::setContext(device, paint, matrix)) {
+bool SkColorShader::onSetContext(Context* context, const SkBitmap& device,
+                                 const SkPaint& paint, const SkMatrix& matrix) {
+    if (!this->INHERITED::onSetContext(context, device, paint, matrix)) {
         return false;
     }
 
     unsigned a;
 
     if (fInheritColor) {
         fColor = paint.getColor();
         a = SkColorGetA(fColor);
     } else {
         a = SkAlphaMul(SkColorGetA(fColor), SkAlpha255To256(paint.getAlpha()));
@@ skipping 17 matching lines @@
     if (255 == a) {
         fFlags |= kOpaqueAlpha_Flag;
         if (paint.isDither() == false) {
             fFlags |= kHasSpan16_Flag;
         }
     }
 
     return true;
 }
 
-void SkColorShader::shadeSpan(int x, int y, SkPMColor span[], int count) {
+void SkColorShader::shadeSpan(Context* c, int x, int y, SkPMColor span[], int count) {
     sk_memset32(span, fPMColor, count);
 }
 
-void SkColorShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
+void SkColorShader::shadeSpan16(Context* c, int x, int y, uint16_t span[], int count) {
     sk_memset16(span, fColor16, count);
 }
 
-void SkColorShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
+void SkColorShader::shadeSpanAlpha(Context* c, int x, int y, uint8_t alpha[], int count) {
     memset(alpha, SkGetPackedA32(fPMColor), count);
 }
 
 // if we had a asAColor method, that would be more efficient...
 SkShader::BitmapType SkColorShader::asABitmap(SkBitmap* bitmap, SkMatrix* matrix,
                                               TileMode modes[]) const {
     return kNone_BitmapType;
 }
 
 SkShader::GradientType SkColorShader::asAGradient(GradientInfo* info) const {
@@ skipping 22 matching lines @@
 
     str->append(")");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkEmptyShader.h"
 
 uint32_t SkEmptyShader::getFlags() { return 0; }
-uint8_t SkEmptyShader::getSpan16Alpha() const { return 0; }
+uint8_t SkEmptyShader::getSpan16Alpha(Context* c) const { return 0; }
 
-bool SkEmptyShader::setContext(const SkBitmap&, const SkPaint&,
-                               const SkMatrix&) { return false; }
+bool SkEmptyShader::onSetContext(Context*, const SkBitmap&, const SkPaint&,
+                                 const SkMatrix&) { return false; }
 
-void SkEmptyShader::shadeSpan(int x, int y, SkPMColor span[], int count) {
+void SkEmptyShader::shadeSpan(Context *c, int x, int y, SkPMColor span[], int count) {
     SkDEBUGFAIL("should never get called, since setContext() returned false");
 }
 
-void SkEmptyShader::shadeSpan16(int x, int y, uint16_t span[], int count) {
+void SkEmptyShader::shadeSpan16(Context *c, int x, int y, uint16_t span[], int count) {
     SkDEBUGFAIL("should never get called, since setContext() returned false");
 }
 
-void SkEmptyShader::shadeSpanAlpha(int x, int y, uint8_t alpha[], int count) {
+void SkEmptyShader::shadeSpanAlpha(Context *c, int x, int y, uint8_t alpha[], int count) {
     SkDEBUGFAIL("should never get called, since setContext() returned false");
 }
 
 #ifdef SK_DEVELOPER
 void SkEmptyShader::toString(SkString* str) const {
     str->append("SkEmptyShader: (");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif