free cache in destructor, in case endContext was not called. change Resize to return bool indicatin…

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
@@ skipping 215 matching lines @@
         // about 30% faster than Lanczos-3. The use of Hamming-1 has been deemed
         // an acceptable trade-off between quality and speed.
         case SkBitmapScaler::RESIZE_BETTER:
             return SkBitmapScaler::RESIZE_HAMMING;
         default:
             return SkBitmapScaler::RESIZE_MITCHELL;
     }
 }
 
 // static
-SkBitmap SkBitmapScaler::Resize(const SkBitmap& source,
-                                ResizeMethod method,
-                                int destWidth, int destHeight,
-                                const SkIRect& destSubset,
-                                SkConvolutionProcs* convolveProcs,
-                                SkBitmap::Allocator* allocator) {
+bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
+                            const SkBitmap& source,
+                            ResizeMethod method,
+                            int destWidth, int destHeight,
+                            const SkIRect& destSubset,
+                            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,
                                     "Sorry, you passed me a bitmap resize "
                                     " method I have never heard of: %d",
                                     method );
     }
 
     // If the size of source or destination is 0, i.e. 0x0, 0xN or Nx0, just
     // return empty.
     if (source.width() < 1 || source.height() < 1 ||
         destWidth < 1 || destHeight < 1) {
-        return SkBitmap();
+        // todo: seems like we could handle negative dstWidth/Height, since that
+        // is just a negative scale (flip)
+        return false;
     }
 
     method = ResizeMethodToAlgorithmMethod(method);
 
     // Check that we deal with an "algorithm methods" from this point onward.
     SkASSERT((SkBitmapScaler::RESIZE_FIRST_ALGORITHM_METHOD <= method) &&
         (method <= SkBitmapScaler::RESIZE_LAST_ALGORITHM_METHOD));
 
     SkAutoLockPixels locker(source);
-    if (!source.readyToDraw() || source.config() != SkBitmap::kARGB_8888_Config)
-        return SkBitmap();
+    if (!source.readyToDraw() ||
+        source.config() != SkBitmap::kARGB_8888_Config) {
+        return false;
+    }
 
     SkResizeFilter filter(method, source.width(), source.height(),
                           destWidth, destHeight, destSubset, convolveProcs);
 
     // Get a source bitmap encompassing this touched area. We construct the
     // offsets and row strides such that it looks like a new bitmap, while
     // referring to the old data.
     const unsigned char* sourceSubset =
         reinterpret_cast<const unsigned char*>(source.getPixels());
 
     // Convolve into the result.
     SkBitmap result;
     result.setConfig(SkBitmap::kARGB_8888_Config,
         destSubset.width(), destSubset.height());
     result.allocPixels(allocator, NULL);
-    if (!result.readyToDraw())
-        return SkBitmap();
+    if (!result.readyToDraw()) {
+        return false;
+    }
 
     BGRAConvolve2D(sourceSubset, static_cast<int>(source.rowBytes()),
         !source.isOpaque(), filter.xFilter(), filter.yFilter(),
         static_cast<int>(result.rowBytes()),
         static_cast<unsigned char*>(result.getPixels()),
         convolveProcs, true);
 
     // Preserve the "opaque" flag for use as an optimization later.
     result.setIsOpaque(source.isOpaque());
-
-    return result;
+    *resultPtr = result;
+    return true;
 }
 
 // static
-SkBitmap SkBitmapScaler::Resize(const SkBitmap& source,
-                                ResizeMethod method,
-                                int destWidth, int destHeight,
-                                SkConvolutionProcs* convolveProcs,
-                                SkBitmap::Allocator* allocator) {
+bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
+                            const SkBitmap& source,
+                            ResizeMethod method,
+                            int destWidth, int destHeight,
+                            SkConvolutionProcs* convolveProcs,
+                            SkBitmap::Allocator* allocator) {
     SkIRect destSubset = { 0, 0, destWidth, destHeight };
-    return Resize(source, method, destWidth, destHeight, destSubset,
+    return Resize(resultPtr, source, method, destWidth, destHeight, destSubset,
                   convolveProcs, allocator);
 }