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

src/core/SkBitmapProcState.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBitmapProcState.h"
 #include "SkColorPriv.h"
 #include "SkFilterProc.h"
@@ skipping 359 matching lines @@
     }
 }
 
 SkBitmapProcState::~SkBitmapProcState() {
     if (fScaledCacheID) {
         SkScaledImageCache::Unlock(fScaledCacheID);
     }
     SkDELETE(fBitmapFilter);
 }
 
+SkBitmapProcState::SkBitmapProcState(const SkBitmapProcState& src)
+    : fInvMatrix(src.fInvMatrix), fInvProc(src.fInvProc),
+      fInvSxFractionalInt(src.fInvSxFractionalInt), fInvKyFractionalInt(src.fInvKyFractionalInt),
+      fTileProcX(src.fTileProcX), fTileProcY(src.fTileProcY),
+      fTileLowBitsProcX(src.fTileLowBitsProcX), fTileLowBitsProcY(src.fTileLowBitsProcY),
+      fIntTileProcY(src.fIntTileProcY), fFilterOneX(src.fFilterOneX), fFilterOneY(src.fFilterOneY),
+      fPaintPMColor(src.fPaintPMColor), fInvSx(src.fInvSx), fInvKy(src.fInvKy),
+      fAlphaScale(src.fAlphaScale), fInvType(src.fInvType),
+      fTileModeX(src.fTileModeX), fTileModeY(src.fTileModeY), fFilterLevel(src.fFilterLevel),
+      fShaderProc32(src.fShaderProc32), fShaderProc16(src.fShaderProc16),
+      fMatrixProc(src.fMatrixProc), fSampleProc32(src.fSampleProc32),
+      fSampleProc16(src.fSampleProc16), fOrigBitmap(src.fOrigBitmap),
+      fScaledBitmap(src.fScaledBitmap)
+{
+    // TODO(dominikg): Doesn't work yet. Assert in SkBitmapProcShader.cpp on line 224 fails.
+    fBitmap = src.fBitmap == &src.fOrigBitmap ? &fOrigBitmap : &fScaledBitmap;
+
+    fBitmapFilter = src.fBitmapFilter;
+}
+
 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
     SkASSERT(fOrigBitmap.width() && fOrigBitmap.height());
 
     fBitmap = NULL;
     fInvMatrix = inv;
     fFilterLevel = paint.getFilterLevel();
 
     SkASSERT(NULL == fScaledCacheID);
 
     // possiblyScaleImage will look to see if it can rescale the image as a
     // preprocess; either by scaling up to the target size, or by selecting
     // a nearby mipmap level.  If it does, it will adjust the working
     // matrix as well as the working bitmap.  It may also adjust the filter
     // quality to avoid re-filtering an already perfectly scaled image.
     if (!this->possiblyScaleImage()) {
         if (!this->lockBaseBitmap()) {
             return false;
         }
     }
     // The above logic should have always assigned fBitmap, but in case it
     // didn't, we check for that now...
+    // TODO(dominikg): Ask humper@ if we can just use an SkASSERT(fBitmap)?
     if (NULL == fBitmap) {
         return false;
     }
 
     bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
                       SkShader::kClamp_TileMode == fTileModeY;
 
     if (!(clampClamp || trivialMatrix)) {
         fInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
@@ skipping 62 matching lines @@
         if (fInvType <= SkMatrix::kTranslate_Mask ||
                 !valid_for_filtering(fBitmap->width() | fBitmap->height())) {
             fFilterLevel = SkPaint::kNone_FilterLevel;
         }
     }
 
     // At this point, we know exactly what kind of sampling the per-scanline
     // shader will perform.
 
     fMatrixProc = this->chooseMatrixProc(trivialMatrix);
+    // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns NULL.
     if (NULL == fMatrixProc) {
         return false;
     }
 
     ///////////////////////////////////////////////////////////////////////
 
     // No need to do this if we're doing HQ sampling; if filter quality is
     // still set to HQ by the time we get here, then we must have installed
     // the shader procs above and can skip all this.
 
@@ skipping 21 matching lines @@
                 index |= 16;
                 break;
             case SkBitmap::kARGB_4444_Config:
                 index |= 24;
                 break;
             case SkBitmap::kA8_Config:
                 index |= 32;
                 fPaintPMColor = SkPreMultiplyColor(paint.getColor());
                 break;
             default:
+                // TODO(dominikg): Should we ever get here? SkASSERT(false) instead?
                 return false;
         }
 
     #if !SK_ARM_NEON_IS_ALWAYS
         static const SampleProc32 gSkBitmapProcStateSample32[] = {
             S32_opaque_D32_nofilter_DXDY,
             S32_alpha_D32_nofilter_DXDY,
             S32_opaque_D32_nofilter_DX,
             S32_alpha_D32_nofilter_DX,
             S32_opaque_D32_filter_DXDY,
@@ skipping 499 matching lines @@
     } else {
         size >>= 2;
     }
 
     if (fFilterLevel != SkPaint::kNone_FilterLevel) {
         size >>= 1;
     }
 
     return size;
 }