remove fConvolutionProcs from State, and just use it locally

src/core/SkBitmapScaler.cpp

 #include "SkBitmapScaler.h"
 #include "SkBitmapFilter.h"
 #include "SkRect.h"
 #include "SkTArray.h"
 #include "SkErrorInternals.h"
 #include "SkConvolver.h"
 
 // SkResizeFilter ----------------------------------------------------------------
 
 // Encapsulates computation and storage of the filters required for one complete
 // resize operation.
 class SkResizeFilter {
 public:
     SkResizeFilter(SkBitmapScaler::ResizeMethod method,
                    int srcFullWidth, int srcFullHeight,
                    int destWidth, int destHeight,
                    const SkIRect& destSubset,
-                   SkConvolutionProcs* convolveProcs);
+                   const SkConvolutionProcs& convolveProcs);
     ~SkResizeFilter() {
         SkDELETE( fBitmapFilter );
     }
 
     // Returns the filled filter values.
     const SkConvolutionFilter1D& xFilter() { return fXFilter; }
     const SkConvolutionFilter1D& yFilter() { return fYFilter; }
 
 private:
 
     SkBitmapFilter* fBitmapFilter;
 
     // Computes one set of filters either horizontally or vertically. The caller
     // will specify the "min" and "max" rather than the bottom/top and
     // right/bottom so that the same code can be re-used in each dimension.
     //
     // |srcDependLo| and |srcDependSize| gives the range for the source
     // depend rectangle (horizontally or vertically at the caller's discretion
     // -- see above for what this means).
     //
     // Likewise, the range of destination values to compute and the scale factor
     // for the transform is also specified.
 
     void computeFilters(int srcSize,
                         int destSubsetLo, int destSubsetSize,
                         float scale,
                         SkConvolutionFilter1D* output,
-                        SkConvolutionProcs* convolveProcs);
+                        const SkConvolutionProcs& convolveProcs);
 
     SkConvolutionFilter1D fXFilter;
     SkConvolutionFilter1D fYFilter;
 };
 
 SkResizeFilter::SkResizeFilter(SkBitmapScaler::ResizeMethod method,
                                int srcFullWidth, int srcFullHeight,
                                int destWidth, int destHeight,
                                const SkIRect& destSubset,
-                               SkConvolutionProcs* convolveProcs) {
+                               const SkConvolutionProcs& convolveProcs) {
 
     // method will only ever refer to an "algorithm method".
     SkASSERT((SkBitmapScaler::RESIZE_FIRST_ALGORITHM_METHOD <= method) &&
              (method <= SkBitmapScaler::RESIZE_LAST_ALGORITHM_METHOD));
 
     switch(method) {
         case SkBitmapScaler::RESIZE_BOX:
             fBitmapFilter = SkNEW(SkBoxFilter);
             break;
         case SkBitmapScaler::RESIZE_TRIANGLE:
@@ skipping 34 matching lines @@
 // factor. Downscaling from typical display resolutions is also bound
 // to produce interesting periods as those are chosen to have multiple
 // small factors.
 // Small periods reduce computational load and improve cache usage if
 // the coefficients can be shared. For periods of 1 we can consider
 // loading the factors only once outside the borders.
 void SkResizeFilter::computeFilters(int srcSize,
                                   int destSubsetLo, int destSubsetSize,
                                   float scale,
                                   SkConvolutionFilter1D* output,
-                                  SkConvolutionProcs* convolveProcs) {
+                                  const SkConvolutionProcs& convolveProcs) {
   int destSubsetHi = destSubsetLo + destSubsetSize;  // [lo, hi)
 
   // When we're doing a magnification, the scale will be larger than one. This
   // means the destination pixels are much smaller than the source pixels, and
   // that the range covered by the filter won't necessarily cover any source
   // pixel boundaries. Therefore, we use these clamped values (max of 1) for
   // some computations.
   float clampedScale = SkTMin(1.0f, scale);
 
   // This is how many source pixels from the center we need to count
@@ skipping 68 matching lines @@
     // be the center of the filter function since it could get clipped on the
     // edges, but it doesn't matter enough to worry about that case).
     short leftovers = output->FloatToFixed(1.0f) - fixedSum;
     fixedFilterValues[fixedFilterValues.count() / 2] += leftovers;
 
     // Now it's ready to go.
     output->AddFilter(srcBegin, &fixedFilterValues[0],
                       static_cast<int>(fixedFilterValues.count()));
   }
 
-  if (convolveProcs->fApplySIMDPadding) {
-      convolveProcs->fApplySIMDPadding( output );
+  if (convolveProcs.fApplySIMDPadding) {
+      convolveProcs.fApplySIMDPadding( output );
   }
 }
 
 static SkBitmapScaler::ResizeMethod ResizeMethodToAlgorithmMethod(
                                     SkBitmapScaler::ResizeMethod method) {
     // Convert any "Quality Method" into an "Algorithm Method"
     if (method >= SkBitmapScaler::RESIZE_FIRST_ALGORITHM_METHOD &&
     method <= SkBitmapScaler::RESIZE_LAST_ALGORITHM_METHOD) {
         return method;
     }
@@ skipping 19 matching lines @@
             return SkBitmapScaler::RESIZE_MITCHELL;
     }
 }
 
 // static
 bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
                             const SkBitmap& source,
                             ResizeMethod method,
                             int destWidth, int destHeight,
                             const SkIRect& destSubset,
-                            SkConvolutionProcs* convolveProcs,
+                            const SkConvolutionProcs& convolveProcs,
                             SkBitmap::Allocator* allocator) {
   // Ensure that the ResizeMethod enumeration is sound.
     SkASSERT(((RESIZE_FIRST_QUALITY_METHOD <= method) &&
         (method <= RESIZE_LAST_QUALITY_METHOD)) ||
         ((RESIZE_FIRST_ALGORITHM_METHOD <= method) &&
         (method <= RESIZE_LAST_ALGORITHM_METHOD)));
 
     SkIRect dest = { 0, 0, destWidth, destHeight };
     if (!dest.contains(destSubset)) {
         SkErrorInternals::SetError( kInvalidArgument_SkError,
@@ skipping 51 matching lines @@
     result.setIsOpaque(source.isOpaque());
     *resultPtr = result;
     return true;
 }
 
 // static
 bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
                             const SkBitmap& source,
                             ResizeMethod method,
                             int destWidth, int destHeight,
-                            SkConvolutionProcs* convolveProcs,
+                            const SkConvolutionProcs& convolveProcs,
                             SkBitmap::Allocator* allocator) {
     SkIRect destSubset = { 0, 0, destWidth, destHeight };
     return Resize(resultPtr, source, method, destWidth, destHeight, destSubset,
                   convolveProcs, allocator);
 }