switch bitmapshader internals over to pixmap

src/core/SkBitmapController.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkBitmapController.h"
 #include "SkMatrix.h"
@@ skipping 24 matching lines @@
                                                              const SkMatrix& inv,
                                                              SkFilterQuality quality,
                                                              void* storage, size_t storageSize) {
     
     if (!valid_for_drawing(bm)) {
         return NULL;
     }
 
     State* state = this->onRequestBitmap(bm, inv, quality, storage, storageSize);
     if (state) {
-        if (!state->fLockedBitmap.getPixels()) {
-            state->fLockedBitmap.lockPixels();
-            if (!state->fLockedBitmap.getPixels()) {
-                SkInPlaceDeleteCheck(state, storage);
-                state = NULL;
-            }
+        if (NULL == state->fPixmap.addr()) {
+            SkInPlaceDeleteCheck(state, storage);
+            state = NULL;
         }
     }
     return state;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkBitmapCache.h"
 #include "SkBitmapScaler.h"
 #include "SkMipMap.h"
 #include "SkResourceCache.h"
 
 class SkDefaultBitmapControllerState : public SkBitmapController::State {
 public:
     SkDefaultBitmapControllerState(const SkBitmap& src, const SkMatrix& inv, SkFilterQuality qual);
 
 private:
+    SkBitmap                     fResultBitmap;
     SkAutoTUnref<const SkMipMap> fCurrMip;
     
     bool processHQRequest(const SkBitmap& orig);
     bool processMediumRequest(const SkBitmap& orig);
 };
 
 // Check to see that the size of the bitmap that would be produced by
 // scaling by the given inverted matrix is less than the maximum allowed.
 static inline bool cache_size_okay(const SkBitmap& bm, const SkMatrix& invMat) {
     size_t maximumAllocation = SkResourceCache::GetEffectiveSingleAllocationByteLimit();
@@ skipping 38 matching lines @@
     }
     if (SkScalarNearlyEqual(invScaleX, 1) && SkScalarNearlyEqual(invScaleY, 1)) {
         return false; // no need for HQ
     }
     
     SkScalar trueDestWidth  = origBitmap.width() / invScaleX;
     SkScalar trueDestHeight = origBitmap.height() / invScaleY;
     SkScalar roundedDestWidth = SkScalarRoundToScalar(trueDestWidth);
     SkScalar roundedDestHeight = SkScalarRoundToScalar(trueDestHeight);
     
-    if (!SkBitmapCache::Find(origBitmap, roundedDestWidth, roundedDestHeight, &fLockedBitmap)) {
-        if (!SkBitmapScaler::Resize(&fLockedBitmap,
+    if (!SkBitmapCache::Find(origBitmap, roundedDestWidth, roundedDestHeight, &fResultBitmap)) {
+        if (!SkBitmapScaler::Resize(&fResultBitmap,
                                     origBitmap,
                                     SkBitmapScaler::RESIZE_BEST,
                                     roundedDestWidth,
                                     roundedDestHeight,
                                     SkResourceCache::GetAllocator())) {
             return false; // we failed to create fScaledBitmap
         }
         
-        SkASSERT(fLockedBitmap.getPixels());
-        fLockedBitmap.setImmutable();
-        SkBitmapCache::Add(origBitmap, roundedDestWidth, roundedDestHeight, fLockedBitmap);
+        SkASSERT(fResultBitmap.getPixels());
+        fResultBitmap.setImmutable();
+        SkBitmapCache::Add(origBitmap, roundedDestWidth, roundedDestHeight, fResultBitmap);
     }
     
-    SkASSERT(fLockedBitmap.getPixels());
+    SkASSERT(fResultBitmap.getPixels());
     
     fInvMatrix.postScale(roundedDestWidth / origBitmap.width(),
                          roundedDestHeight / origBitmap.height());
     fQuality = kLow_SkFilterQuality;
     return true;
 }
 
 /*
  *  Modulo internal errors, this should always succeed *if* the matrix is downscaling
  *  (in this case, we have the inverse, so it succeeds if fInvMatrix is upscaling)
@@ skipping 29 matching lines @@
         
         SkScalar levelScale = SkScalarInvert(invScale);
         SkMipMap::Level level;
         if (fCurrMip->extractLevel(levelScale, &level)) {
             SkScalar invScaleFixup = level.fScale;
             fInvMatrix.postScale(invScaleFixup, invScaleFixup);
             
             const SkImageInfo info = origBitmap.info().makeWH(level.fWidth, level.fHeight);
             // todo: if we could wrap the fCurrMip in a pixelref, then we could just install
             //       that here, and not need to explicitly track it ourselves.
-            return fLockedBitmap.installPixels(info, level.fPixels, level.fRowBytes);
+            return fResultBitmap.installPixels(info, level.fPixels, level.fRowBytes);
         } else {
             // failed to extract, so release the mipmap
             fCurrMip.reset(NULL);
         }
     }
     return false;
 }
 
 SkDefaultBitmapControllerState::SkDefaultBitmapControllerState(const SkBitmap& src,
                                                                const SkMatrix& inv,
                                                                SkFilterQuality qual) {
     fInvMatrix = inv;
     fQuality = qual;
 
-    if (!this->processHQRequest(src) && !this->processMediumRequest(src)) {
-        fLockedBitmap = src;
+    if (this->processHQRequest(src) || this->processMediumRequest(src)) {
+        SkASSERT(fResultBitmap.getPixels());
+    } else {
+        fResultBitmap = src;
+        fResultBitmap.lockPixels();
+        // lock may fail to give us pixels
     }
     SkASSERT(fQuality <= kLow_SkFilterQuality);
+
+    // fResultBitmap.getPixels() may be null, but our caller knows to check fPixmap.addr()
+    // and will destroy us if it is NULL.
+    fPixmap.reset(fResultBitmap.info(), fResultBitmap.getPixels(), fResultBitmap.rowBytes(),
+                  fResultBitmap.getColorTable());
 }
 
 SkBitmapController::State* SkDefaultBitmapController::onRequestBitmap(const SkBitmap& bm,
                                                                       const SkMatrix& inverse,
                                                                       SkFilterQuality quality,
                                                                       void* storage, size_t size) {
     return SkInPlaceNewCheck<SkDefaultBitmapControllerState>(storage, size, bm, inverse, quality);
 }