refactor bitmapshader to use a controller

src/core/SkBitmapProcState.h

 /*
  * Copyright 2007 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.
  */
 
 #ifndef SkBitmapProcState_DEFINED
 #define SkBitmapProcState_DEFINED
 
 #include "SkBitmap.h"
+#include "SkBitmapController.h"
 #include "SkBitmapFilter.h"
+#include "SkInPlace.h"
 #include "SkMatrix.h"
 #include "SkMipMap.h"
 #include "SkPaint.h"
 
 typedef SkFixed3232    SkFractionalInt;
 #define SkScalarToFractionalInt(x)  SkScalarToFixed3232(x)
 #define SkFractionalIntToFixed(x)   SkFixed3232ToFixed(x)
 #define SkFixedToFractionalInt(x)   SkFixedToFixed3232(x)
 #define SkFractionalIntToInt(x)     SkFixed3232ToInt(x)
 
 class SkPaint;
 
 struct SkBitmapProcState {
+    SkBitmapProcState();
+    ~SkBitmapProcState();
+
     typedef void (*ShaderProc32)(const SkBitmapProcState&, int x, int y,
                                  SkPMColor[], int count);
 
     typedef void (*ShaderProc16)(const SkBitmapProcState&, int x, int y,
                                  uint16_t[], int count);
 
     typedef void (*MatrixProc)(const SkBitmapProcState&,
                                uint32_t bitmapXY[],
                                int count,
                                int x, int y);
 
     typedef void (*SampleProc32)(const SkBitmapProcState&,
                                  const uint32_t[],
                                  int count,
                                  SkPMColor colors[]);
 
     typedef void (*SampleProc16)(const SkBitmapProcState&,
                                  const uint32_t[],
                                  int count,
                                  uint16_t colors[]);
 
     typedef U16CPU (*FixedTileProc)(SkFixed);   // returns 0..0xFFFF
     typedef U16CPU (*FixedTileLowBitsProc)(SkFixed, int);   // returns 0..0xF
     typedef U16CPU (*IntTileProc)(int value, int count);   // returns 0..count-1
 
     const SkBitmap*     fBitmap;            // chooseProcs - orig or scaled
-    SkMatrix            fInvMatrix;         // chooseProcs
+    SkMatrix            fInvMatrix;         // copy of what is in fBMState, can we remove the dup?
+
     SkMatrix::MapXYProc fInvProc;           // chooseProcs
 
     SkFractionalInt     fInvSxFractionalInt;
     SkFractionalInt     fInvKyFractionalInt;
 
     FixedTileProc       fTileProcX;         // chooseProcs
     FixedTileProc       fTileProcY;         // chooseProcs
     FixedTileLowBitsProc fTileLowBitsProcX; // chooseProcs
     FixedTileLowBitsProc fTileLowBitsProcY; // chooseProcs
     IntTileProc         fIntTileProcY;      // chooseProcs
@@ skipping 52 matching lines @@
     friend class SkBitmapProcShader;
 
     ShaderProc32        fShaderProc32;      // chooseProcs
     ShaderProc16        fShaderProc16;      // chooseProcs
     // These are used if the shaderproc is NULL
     MatrixProc          fMatrixProc;        // chooseProcs
     SampleProc32        fSampleProc32;      // chooseProcs
     SampleProc16        fSampleProc16;      // chooseProcs
 
     SkBitmap            fOrigBitmap;        // CONSTRUCTOR
-    SkBitmap            fScaledBitmap;      // chooseProcs
 
-    SkAutoTUnref<const SkMipMap> fCurrMip;
-
-    void processHQRequest();
-    void processMediumRequest();
+    enum {
+        kBMStateSize = 136  // found by inspection. if too small, we will call new/delete
+    };
+    SkSInPlace<kBMStateSize>   fBMAllocator;
+    SkBitmapController::State* fBMState;
 
     MatrixProc chooseMatrixProc(bool trivial_matrix);
     bool chooseProcs(const SkMatrix& inv, const SkPaint&);
     bool chooseScanlineProcs(bool trivialMatrix, bool clampClamp, const SkPaint& paint);
     ShaderProc32 chooseShaderProc32();
 
-    // returns false if we failed to "lock" the pixels at all. Typically this
-    // means we have to abort the shader.
-    bool lockBaseBitmap();
-
     // Return false if we failed to setup for fast translate (e.g. overflow)
     bool setupForTranslate();
 
 #ifdef SK_DEBUG
     static void DebugMatrixProc(const SkBitmapProcState&,
                                 uint32_t[], int count, int x, int y);
 #endif
 };
 
 /*  Macros for packing and unpacking pairs of 16bit values in a 32bit uint.
@@ skipping 37 matching lines @@
 void ClampX_ClampY_filter_affine(const SkBitmapProcState& s,
                                  uint32_t xy[], int count, int x, int y);
 void ClampX_ClampY_nofilter_affine(const SkBitmapProcState& s,
                                    uint32_t xy[], int count, int x, int y);
 void S32_D16_filter_DX(const SkBitmapProcState& s,
                        const uint32_t* xy, int count, uint16_t* colors);
 void S32_D16_filter_DXDY(const SkBitmapProcState& s,
                          const uint32_t* xy, int count, uint16_t* colors);
 
 #endif