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

src/effects/gradients/SkRadialGradient.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRadialGradient.h"
 #include "SkRadialGradient_Table.h"
@@ skipping 139 matching lines @@
     : SkGradientShaderBase(desc),
       fCenter(center),
       fRadius(radius)
 {
     // make sure our table is insync with our current #define for kSQRT_TABLE_SIZE
     SkASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE);
 
     rad_to_unit_matrix(center, radius, &fPtsToUnit);
 }
 
+#if 0
 void SkRadialGradient::shadeSpan16(int x, int y, uint16_t* dstCParam,
                          int count) {
     SkASSERT(count > 0);
 
     uint16_t* SK_RESTRICT dstC = dstCParam;
 
     SkPoint             srcPt;
     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
     TileProc            proc = fTileProc;
     const uint16_t* SK_RESTRICT cache = this->getCache16();
@@ skipping 35 matching lines @@
             SkASSERT(fi <= 0xFFFF);
 
             int index = fi >> (16 - kCache16Bits);
             *dstC++ = cache[toggle + index];
             toggle = next_dither_toggle16(toggle);
 
             dstX += SK_Scalar1;
         } while (--count != 0);
     }
 }
+#endif
 
 SkShader::BitmapType SkRadialGradient::asABitmap(SkBitmap* bitmap,
     SkMatrix* matrix, SkShader::TileMode* xy) const {
     if (bitmap) {
         this->getGradientTableBitmap(bitmap);
     }
     if (matrix) {
         matrix->setScale(SkIntToScalar(kCache32Count),
                          SkIntToScalar(kCache32Count));
         matrix->preConcat(fPtsToUnit);
@@ skipping 157 matching lines @@
 }
 
 void shadeSpan_radial_repeat(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
                              SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
                              int count, int toggle) {
     shadeSpan_radial<repeat_tileproc_nonstatic>(fx, dx, fy, dy, dstC, cache, count, toggle);
 }
 
 }  // namespace
 
+#if 0
 void SkRadialGradient::shadeSpan(int x, int y,
                                 SkPMColor* SK_RESTRICT dstC, int count) {
     SkASSERT(count > 0);
 
     SkPoint             srcPt;
     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
     TileProc            proc = fTileProc;
     const SkPMColor* SK_RESTRICT cache = this->getCache32();
     int toggle = init_dither_toggle(x, y);
 
@@ skipping 27 matching lines @@
         SkScalar dstY = SkIntToScalar(y);
         do {
             dstProc(fDstToIndex, dstX, dstY, &srcPt);
             unsigned fi = proc(SkScalarToFixed(srcPt.length()));
             SkASSERT(fi <= 0xFFFF);
             *dstC++ = cache[fi >> SkGradientShaderBase::kCache32Shift];
             dstX += SK_Scalar1;
         } while (--count != 0);
     }
 }
+#endif
 
 /////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrTBackendEffectFactory.h"
 
 class GrGLRadialGradient : public GrGLGradientEffect {
 public:
 
@@ skipping 124 matching lines @@
     str->appendScalar(fCenter.fY);
     str->append(") radius: ");
     str->appendScalar(fRadius);
     str->append(" ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif