Work (in progress) to make SkShader immutable.

src/core/SkComposeShader.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 "SkComposeShader.h"
@@ skipping 27 matching lines @@
     }
     fMode = buffer.readXfermode();
 }
 
 SkComposeShader::~SkComposeShader() {
     SkSafeUnref(fMode);
     fShaderB->unref();
     fShaderA->unref();
 }
 
+size_t SkComposeShader::shaderImplSize() const {
+    return sizeof(ComposeImpl) + fShaderA->shaderImplSize()
+           + fShaderB->shaderImplSize();
+}
+
 class SkAutoAlphaRestore {
 public:
     SkAutoAlphaRestore(SkPaint* paint, uint8_t newAlpha) {
         fAlpha = paint->getAlpha();
         fPaint = paint;
         paint->setAlpha(newAlpha);
     }
 
     ~SkAutoAlphaRestore() {
         fPaint->setAlpha(fAlpha);
     }
 private:
     SkPaint*    fPaint;
     uint8_t     fAlpha;
 };
 #define SkAutoAlphaRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoAlphaRestore)
 
 void SkComposeShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeFlattenable(fShaderA);
     buffer.writeFlattenable(fShaderB);
     buffer.writeFlattenable(fMode);
 }
 
 /*  We call setContext on our two worker shaders. However, we
     always let them see opaque alpha, and if the paint really
     is translucent, then we apply that after the fact.
 
-    We need to keep the calls to setContext/endContext balanced, since if we
-    return false, our endContext() will not be called.
  */
-bool SkComposeShader::setContext(const SkBitmap& device,
-                                 const SkPaint& paint,
-                                 const SkMatrix& matrix) {
-    if (!this->INHERITED::setContext(device, paint, matrix)) {
+bool SkComposeShader::validContext(const SkBitmap& device,
+                                   const SkPaint& paint,
+                                   const SkMatrix& matrix) {
+    if (!this->INHERITED::validContext(device, paint, matrix)) {
         return false;
     }
 
     // we preconcat our localMatrix (if any) with the device matrix
     // before calling our sub-shaders
 
     SkMatrix tmpM;
 
     tmpM.setConcat(matrix, this->getLocalMatrix());
 
+    return fShaderA->validContext(device, paint, tmpM)
+           && fShaderB->validContext(device, paint, tmpM);
+}
+
+SkShaderGenerator::ShaderImpl* SkComposeShader::createShaderImpl(
+        const SkBitmap& device, const SkPaint& paint,
+        const SkMatrix& matrix, void* storage) const
+{
+    SkASSERT(this->validContext(device, paint, matrix));
+
+    // we preconcat our localMatrix (if any) with the device matrix
+    // before calling our sub-shaders
+
+    SkMatrix tmpM;
+
+    tmpM.setConcat(matrix, this->getLocalMatrix());
+
     SkAutoAlphaRestore  restore(const_cast<SkPaint*>(&paint), 0xFF);
 
-    bool setContextA = fShaderA->setContext(device, paint, tmpM);
-    bool setContextB = fShaderB->setContext(device, paint, tmpM);
-    if (!setContextA || !setContextB) {
-        if (setContextB) {
-            fShaderB->endContext();
-        }
-        else if (setContextA) {
-            fShaderA->endContext();
-        }
-        this->INHERITED::endContext();
-        return false;
-    }
-    return true;
+    char* aStorage = (char*) storage + sizeof(ComposeImpl);
+    char* bStorage = aStorage + fShaderA->shaderImplSize();
+
+    ShaderImpl* implA = fShaderA->createShaderImpl(device, paint, matrix,
+                                                   aStorage);
+    ShaderImpl* implB = fShaderB->createShaderImpl(device, paint, matrix,
+                                                   bStorage);
+
+    // Both functions must succeed; otherwise validContext should have returned
+    // false.
+    SkASSERT(implA);
+    SkASSERT(implB);
+
+    return SkNEW_PLACEMENT_ARGS(storage, ComposeImpl,
+                                (*this, device, paint, matrix, implA, implB));
 }
 
-void SkComposeShader::endContext() {
-    fShaderB->endContext();
-    fShaderA->endContext();
-    this->INHERITED::endContext();
+SkComposeShader::ComposeImpl::ComposeImpl(const SkComposeShader& shader,
+        const SkBitmap& device, const SkPaint& paint, const SkMatrix& matrix,
+        ShaderImpl* shaderImplA, ShaderImpl* shaderImplB)
+    : INHERITED(shader, device, paint, matrix)
+    , fShaderImplA(shaderImplA)
+    , fShaderImplB(shaderImplB) {}
+
+void SkComposeShader::ComposeImpl::~ComposeImpl() {
+    fShaderImplA->~ShaderImpl();
+    fShaderImplB->~ShaderImpl();
 }
 
 // larger is better (fewer times we have to loop), but we shouldn't
 // take up too much stack-space (each element is 4 bytes)
 #define TMP_COLOR_COUNT     64
 
 void SkComposeShader::shadeSpan(int x, int y, SkPMColor result[], int count) {
-    SkShader*   shaderA = fShaderA;
-    SkShader*   shaderB = fShaderB;
-    SkXfermode* mode = fMode;
+    SkXfermode* mode = static_cast<const SkComposeShader&>(fShader).fMode;
     unsigned    scale = SkAlpha255To256(this->getPaintAlpha());
 
     SkPMColor   tmp[TMP_COLOR_COUNT];
 
     if (NULL == mode) {   // implied SRC_OVER
         // TODO: when we have a good test-case, should use SkBlitRow::Proc32
         // for these loops
         do {
             int n = count;
             if (n > TMP_COLOR_COUNT) {
                 n = TMP_COLOR_COUNT;
             }
 
-            shaderA->shadeSpan(x, y, result, n);
-            shaderB->shadeSpan(x, y, tmp, n);
+            fShaderImplA->shadeSpan(x, y, result, n);
+            fShaderImplB->shadeSpan(x, y, tmp, n);
 
             if (256 == scale) {
                 for (int i = 0; i < n; i++) {
                     result[i] = SkPMSrcOver(tmp[i], result[i]);
                 }
             } else {
                 for (int i = 0; i < n; i++) {
                     result[i] = SkAlphaMulQ(SkPMSrcOver(tmp[i], result[i]),
                                             scale);
                 }
             }
 
             result += n;
             x += n;
             count -= n;
         } while (count > 0);
     } else {    // use mode for the composition
         do {
             int n = count;
             if (n > TMP_COLOR_COUNT) {
                 n = TMP_COLOR_COUNT;
             }
 
-            shaderA->shadeSpan(x, y, result, n);
-            shaderB->shadeSpan(x, y, tmp, n);
+            fShaderImplA->shadeSpan(x, y, result, n);
+            fShaderImplB->shadeSpan(x, y, tmp, n);
             mode->xfer32(result, tmp, n, NULL);
 
             if (256 == scale) {
                 for (int i = 0; i < n; i++) {
                     result[i] = SkAlphaMulQ(result[i], scale);
                 }
             }
 
             result += n;
             x += n;
@@ skipping 11 matching lines @@
     str->append(" ShaderB: ");
     fShaderB->toString(str);
     str->append(" Xfermode: ");
     fMode->toString(str);
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif