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

src/core/SkBlitter_A8.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 "SkCoreBlitters.h"
@@ skipping 210 matching lines @@
             for (int i = 0; i < width; i++) {
                 device[i] = SkToU8(srcA + SkAlphaMul(device[i], scale));
             }
             device += fDevice.rowBytes();
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////
 
-SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
-                                         SkShader::Context* shaderContext)
-    : INHERITED(device, paint, shaderContext) {
+SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint)
+    : INHERITED(device, paint) {
     if ((fXfermode = paint.getXfermode()) != NULL) {
         fXfermode->ref();
-        SkASSERT(fShaderContext);
+        SkASSERT(fShader);
     }
 
     int width = device.width();
     fBuffer = (SkPMColor*)sk_malloc_throw(sizeof(SkPMColor) * (width + (SkAlign4(width) >> 2)));
     fAAExpand = (uint8_t*)(fBuffer + width);
 }
 
 SkA8_Shader_Blitter::~SkA8_Shader_Blitter() {
     if (fXfermode) SkSafeUnref(fXfermode);
     sk_free(fBuffer);
 }
 
 void SkA8_Shader_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x >= 0 && y >= 0 &&
              (unsigned)(x + width) <= (unsigned)fDevice.width());
 
     uint8_t* device = fDevice.getAddr8(x, y);
-    SkShader::Context* shaderContext = fShaderContext;
 
-    if ((shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) && !fXfermode) {
+    if ((fShader->getFlags() & SkShader::kOpaqueAlpha_Flag) && !fXfermode) {
         memset(device, 0xFF, width);
     } else {
         SkPMColor*  span = fBuffer;
 
-        shaderContext->shadeSpan(x, y, span, width);
+        fShader->shadeSpan(x, y, span, width);
         if (fXfermode) {
             fXfermode->xferA8(device, span, width, NULL);
         } else {
             for (int i = width - 1; i >= 0; --i) {
                 unsigned    srcA = SkGetPackedA32(span[i]);
                 unsigned    scale = 256 - SkAlpha255To256(srcA);
 
                 device[i] = SkToU8(srcA + SkAlphaMul(device[i], scale));
             }
         }
     }
 }
 
 static inline uint8_t aa_blend8(SkPMColor src, U8CPU da, int aa) {
     SkASSERT((unsigned)aa <= 255);
 
     int src_scale = SkAlpha255To256(aa);
     int sa = SkGetPackedA32(src);
     int dst_scale = 256 - SkAlphaMul(sa, src_scale);
 
     return SkToU8((sa * src_scale + da * dst_scale) >> 8);
 }
 
 void SkA8_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                                     const int16_t runs[]) {
-    SkShader::Context* shaderContext = fShaderContext;
-    SkXfermode*        mode = fXfermode;
-    uint8_t*           aaExpand = fAAExpand;
-    SkPMColor*         span = fBuffer;
-    uint8_t*           device = fDevice.getAddr8(x, y);
-    int                opaque = shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag;
+    SkShader*   shader = fShader;
+    SkXfermode* mode = fXfermode;
+    uint8_t*    aaExpand = fAAExpand;
+    SkPMColor*  span = fBuffer;
+    uint8_t*    device = fDevice.getAddr8(x, y);
+    int         opaque = fShader->getFlags() & SkShader::kOpaqueAlpha_Flag;
 
     for (;;) {
         int count = *runs;
         if (count == 0) {
             break;
         }
         int aa = *antialias;
         if (aa) {
             if (opaque && aa == 255 && mode == NULL) {
                 memset(device, 0xFF, count);
             } else {
-                shaderContext->shadeSpan(x, y, span, count);
+                shader->shadeSpan(x, y, span, count);
                 if (mode) {
                     memset(aaExpand, aa, count);
                     mode->xferA8(device, span, count, aaExpand);
                 } else {
                     for (int i = count - 1; i >= 0; --i) {
                         device[i] = aa_blend8(span[i], device[i], aa);
                     }
                 }
             }
         }
         device += count;
         runs += count;
         antialias += count;
         x += count;
     }
 }
 
 void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
     if (mask.fFormat == SkMask::kBW_Format) {
         this->INHERITED::blitMask(mask, clip);
         return;
     }
 
     int x = clip.fLeft;
     int y = clip.fTop;
     int width = clip.width();
     int height = clip.height();
     uint8_t* device = fDevice.getAddr8(x, y);
     const uint8_t* alpha = mask.getAddr8(x, y);
-    SkShader::Context* shaderContext = fShaderContext;
 
     SkPMColor*  span = fBuffer;
 
     while (--height >= 0) {
-        shaderContext->shadeSpan(x, y, span, width);
+        fShader->shadeSpan(x, y, span, width);
         if (fXfermode) {
             fXfermode->xferA8(device, span, width, alpha);
         } else {
             for (int i = width - 1; i >= 0; --i) {
                 device[i] = aa_blend8(span[i], device[i], alpha[i]);
             }
         }
 
         y += 1;
         device += fDevice.rowBytes();
@@ skipping 75 matching lines @@
     while (--height >= 0) {
         memcpy(dst, src, width);
         dst += dstRB;
         src += srcRB;
     }
 }
 
 const SkBitmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) {
     return NULL;
 }