Work in progress to make SkShader immutable.

src/core/SkBlitter.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 "SkBlitter.h"
@@ skipping 559 matching lines @@
         SkSafeRef(proxy);
         fMask = NULL;
     }
 
     virtual ~Sk3DShader() {
         SkSafeUnref(fProxy);
     }
 
     void setMask(const SkMask* mask) { fMask = mask; }
 
-    virtual bool setContext(const SkBitmap& device, const SkPaint& paint,
-                            const SkMatrix& matrix) SK_OVERRIDE {
-        if (!this->INHERITED::setContext(device, paint, matrix)) {
+    virtual bool onSetContext(Context* c, const SkBitmap& device, const SkPaint& paint,
+                              const SkMatrix& matrix) SK_OVERRIDE {
+        if (!this->INHERITED::onSetContext(c, device, paint, matrix)) {
             return false;
         }
         if (fProxy) {
-            if (!fProxy->setContext(device, paint, matrix)) {
-                // must keep our set/end context calls balanced
-                this->INHERITED::endContext();
+            if (!fProxy->onSetContext(c, device, paint, matrix)) {
                 return false;
             }
         } else {
             fPMColor = SkPreMultiplyColor(paint.getColor());
         }
         return true;
     }
 
     virtual void endContext() SK_OVERRIDE {
         if (fProxy) {
             fProxy->endContext();
         }
         this->INHERITED::endContext();
     }
 
-    virtual void shadeSpan(int x, int y, SkPMColor span[], int count) SK_OVERRIDE {
+    virtual void shadeSpan(Context* c, int x, int y, SkPMColor span[], int count) SK_OVERRIDE {
         if (fProxy) {
-            fProxy->shadeSpan(x, y, span, count);
+            fProxy->shadeSpan(c, x, y, span, count);
         }
 
         if (fMask == NULL) {
             if (fProxy == NULL) {
                 sk_memset32(span, fPMColor, count);
             }
             return;
         }
 
         SkASSERT(fMask->fBounds.contains(x, y));
@@ skipping 79 matching lines @@
     }
 
 private:
     SkShader*       fProxy;
     SkPMColor       fPMColor;
     const SkMask*   fMask;
 
     typedef SkShader INHERITED;
 };
 
+// Remember, this class is going to hang onto another blitter. I think it's okay for
+// him to just let that blitter handle the Context.
 class Sk3DBlitter : public SkBlitter {
 public:
     Sk3DBlitter(SkBlitter* proxy, Sk3DShader* shader, void (*killProc)(void*))
             : fProxy(proxy), f3DShader(shader), fKillProc(killProc) {
         shader->ref();
     }
 
     virtual ~Sk3DBlitter() {
         f3DShader->unref();
         fKillProc(fProxy);
@@ skipping 216 matching lines @@
     }
 
     /*
      *  We need to have balanced calls to the shader:
      *      setContext
      *      endContext
      *  We make the first call here, in case it fails we can abort the draw.
      *  The endContext() call is made by the blitter (assuming setContext did
      *  not fail) in its destructor.
      */
-    if (shader && !shader->setContext(device, *paint, matrix)) {
-        SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
-        return blitter;
+    SkShader::Context* context = NULL;
+    if (shader) {
+        context = shader->setContext(device, *paint, matrix);
+        if (!context) {
+            SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
+            return blitter;
+        }
     }
 
 
     switch (device.config()) {
         case SkBitmap::kA8_Config:
             if (drawCoverage) {
                 SkASSERT(NULL == shader);
+                SkASSERT(NULL == context);
                 SkASSERT(NULL == paint->getXfermode());
                 SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Coverage_Blitter,
                                       storage, storageSize, (device, *paint));
             } else if (shader) {
+                // I've just made the blitters slightly larger. Make sure they're still
+                // small enough to fit in storage
+                SkASSERT(sizeof(SkA8_Shader_Blitter) <= storageSize);
                 SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Shader_Blitter,
-                                      storage, storageSize, (device, *paint));
+                                      storage, storageSize, (device, *paint, context));
             } else {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Blitter,
                                       storage, storageSize, (device, *paint));
             }
             break;
 
         case SkBitmap::kRGB_565_Config:
-            blitter = SkBlitter_ChooseD565(device, *paint, storage, storageSize);
+            blitter = SkBlitter_ChooseD565(device, *paint, context, storage, storageSize);
             break;
 
         case SkBitmap::kARGB_8888_Config:
             if (shader) {
+                SkASSERT(sizeof(SkARGB32_Shader_Blitter) <= storageSize);
                 SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Shader_Blitter,
-                                      storage, storageSize, (device, *paint));
+                                      storage, storageSize, (device, *paint, context));
             } else if (paint->getColor() == SK_ColorBLACK) {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Black_Blitter,
                                       storage, storageSize, (device, *paint));
             } else if (paint->getAlpha() == 0xFF) {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Opaque_Blitter,
                                       storage, storageSize, (device, *paint));
             } else {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Blitter,
                                       storage, storageSize, (device, *paint));
             }
@@ skipping 15 matching lines @@
     return blitter;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const uint16_t gMask_0F0F = 0xF0F;
 const uint32_t gMask_00FF00FF = 0xFF00FF;
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkShaderBlitter::SkShaderBlitter(const SkBitmap& device, const SkPaint& paint)
+SkShaderBlitter::SkShaderBlitter(const SkBitmap& device, const SkPaint& paint,
+                                 SkShader::Context* context)
         : INHERITED(device) {
     fShader = paint.getShader();
     SkASSERT(fShader);
     SkASSERT(fShader->setContextHasBeenCalled());
 
     fShader->ref();
     fShaderFlags = fShader->getFlags();
+
+    fContext = context;
+    SkASSERT(fContext);
 }
 
 SkShaderBlitter::~SkShaderBlitter() {
     SkASSERT(fShader->setContextHasBeenCalled());
-    fShader->endContext();
+    fShader->endContext(fContext);
     fShader->unref();
 }