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

src/effects/gradients/SkLinearGradient.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 "SkLinearGradient.h"
 
 static inline int repeat_bits(int x, const int bits) {
@@ skipping 53 matching lines @@
     , fStart(buffer.readPoint())
     , fEnd(buffer.readPoint()) {
 }
 
 void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writePoint(fStart);
     buffer.writePoint(fEnd);
 }
 
+#if 0
 bool SkLinearGradient::setContext(const SkBitmap& device, const SkPaint& paint,
                                  const SkMatrix& matrix) {
     if (!this->INHERITED::setContext(device, paint, matrix)) {
         return false;
     }
 
     unsigned mask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
     if ((fDstToIndex.getType() & ~mask) == 0) {
         // when we dither, we are (usually) not const-in-Y
         if ((fFlags & SkShader::kHasSpan16_Flag) && !paint.isDither()) {
             // only claim this if we do have a 16bit mode (i.e. none of our
             // colors have alpha), and if we are not dithering (which obviously
             // is not const in Y).
             fFlags |= SkShader::kConstInY16_Flag;
         }
     }
     return true;
 }
+#endif
 
 #define NO_CHECK_ITER               \
     do {                            \
     unsigned fi = fx >> SkGradientShaderBase::kCache32Shift; \
     SkASSERT(fi <= 0xFF);           \
     fx += dx;                       \
     *dstC++ = cache[toggle + fi];   \
     toggle = next_dither_toggle(toggle); \
     } while (0)
 
@@ skipping 87 matching lines @@
         unsigned fi = repeat_8bits(fx >> 8);
         SkASSERT(fi <= 0xFF);
         fx += dx;
         *dstC++ = cache[toggle + fi];
         toggle = next_dither_toggle(toggle);
     } while (--count != 0);
 }
 
 }
 
+#if 0
 void SkLinearGradient::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 28 matching lines @@
         do {
             dstProc(fDstToIndex, dstX, dstY, &srcPt);
             unsigned fi = proc(SkScalarToFixed(srcPt.fX));
             SkASSERT(fi <= 0xFFFF);
             *dstC++ = cache[toggle + (fi >> kCache32Shift)];
             toggle = next_dither_toggle(toggle);
             dstX += SK_Scalar1;
         } while (--count != 0);
     }
 }
+#endif
 
 SkShader::BitmapType SkLinearGradient::asABitmap(SkBitmap* bitmap,
                                                 SkMatrix* matrix,
                                                 TileMode xy[]) const {
     if (bitmap) {
         this->getGradientTableBitmap(bitmap);
     }
     if (matrix) {
         matrix->preConcat(fPtsToUnit);
     }
@@ skipping 113 matching lines @@
         unsigned fi = repeat_bits(fx >> SkGradientShaderBase::kCache16Shift,
                                   SkGradientShaderBase::kCache16Bits);
         SkASSERT(fi < SkGradientShaderBase::kCache16Count);
         fx += dx;
         *dstC++ = cache[toggle + fi];
         toggle = next_dither_toggle16(toggle);
     } while (--count != 0);
 }
 }
 
+#if 0
 static bool fixed_nearly_zero(SkFixed x) {
     return SkAbs32(x) < (SK_Fixed1 >> 12);
 }
 
 void SkLinearGradient::shadeSpan16(int x, int y,
                                   uint16_t* SK_RESTRICT dstC, int count) {
     SkASSERT(count > 0);
 
     SkPoint             srcPt;
     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
@@ skipping 35 matching lines @@
             SkASSERT(fi <= 0xFFFF);
 
             int index = fi >> kCache16Shift;
             *dstC++ = cache[toggle + index];
             toggle = next_dither_toggle16(toggle);
 
             dstX += SK_Scalar1;
         } while (--count != 0);
     }
 }
+#endif
 
 #if SK_SUPPORT_GPU
 
 #include "GrTBackendEffectFactory.h"
 
 /////////////////////////////////////////////////////////////////////
 
 class GrGLLinearGradient : public GrGLGradientEffect {
 public:
 
@@ skipping 116 matching lines @@
     str->append("SkLinearGradient (");
 
     str->appendf("start: (%f, %f)", fStart.fX, fStart.fY);
     str->appendf(" end: (%f, %f) ", fEnd.fX, fEnd.fY);
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif