fix composeshader to respect the paint's alpha

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 82 matching lines @@
     newRec.fMatrix = &tmpM;
 
     return fShaderA->validContext(newRec) && fShaderB->validContext(newRec);
 }
 
 SkShader::Context* SkComposeShader::createContext(const ContextRec& rec, void* storage) const {
     if (!this->validContext(rec)) {
         return NULL;
     }
 
-    // TODO : must fix this to not "cheat" and modify fPaint
-    SkAutoAlphaRestore  restore(const_cast<SkPaint*>(rec.fPaint), 0xFF);
-
     char* aStorage = (char*) storage + sizeof(ComposeShaderContext);
     char* bStorage = aStorage + fShaderA->contextSize();
 
     // we preconcat our localMatrix (if any) with the device matrix
     // before calling our sub-shaders
-
     SkMatrix tmpM;
     tmpM.setConcat(*rec.fMatrix, this->getLocalMatrix());
 
+    // Our sub-shaders need to see opaque, so by combining them we don't double-alphatize the
+    // result. ComposeShader itself will respect the alpha, and post-apply it after calling the
+    // sub-shaders.
+    SkPaint opaquePaint(*rec.fPaint);
+    opaquePaint.setAlpha(0xFF);
+    
     ContextRec newRec(rec);
     newRec.fMatrix = &tmpM;
+    newRec.fPaint = &opaquePaint;
 
     SkShader::Context* contextA = fShaderA->createContext(newRec, aStorage);
     SkShader::Context* contextB = fShaderB->createContext(newRec, bStorage);
 
     // Both functions must succeed; otherwise validContext should have returned
     // false.
     SkASSERT(contextA);
     SkASSERT(contextB);
 
     return SkNEW_PLACEMENT_ARGS(storage, ComposeShaderContext, (*this, rec, contextA, contextB));
@@ skipping 14 matching lines @@
 // 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::ComposeShaderContext::shadeSpan(int x, int y, SkPMColor result[], int count) {
     SkShader::Context* shaderContextA = fShaderContextA;
     SkShader::Context* shaderContextB = fShaderContextB;
     SkXfermode*        mode = static_cast<const SkComposeShader&>(fShader).fMode;
     unsigned           scale = SkAlpha255To256(this->getPaintAlpha());
 
+#ifdef SK_BUILD_FOR_ANDROID
+    scale = 256;    // ugh -- maintain old bug/behavior for now
+#endif
+
     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;
             }
@@ skipping 20 matching lines @@
         do {
             int n = count;
             if (n > TMP_COLOR_COUNT) {
                 n = TMP_COLOR_COUNT;
             }
 
             shaderContextA->shadeSpan(x, y, result, n);
             shaderContextB->shadeSpan(x, y, tmp, n);
             mode->xfer32(result, tmp, n, NULL);
 
-            if (256 == scale) {
+            if (256 != scale) {
                 for (int i = 0; i < n; i++) {
                     result[i] = SkAlphaMulQ(result[i], scale);
                 }
             }
 
             result += n;
             x += n;
             count -= n;
         } while (count > 0);
     }
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkComposeShader::toString(SkString* str) const {
     str->append("SkComposeShader: (");
 
     str->append("ShaderA: ");
     fShaderA->toString(str);
     str->append(" ShaderB: ");
     fShaderB->toString(str);
     str->append(" Xfermode: ");
     fMode->toString(str);
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif