Allow SkLazyPixelRef to use SkScaledImageCache

src/lazy/SkLazyPixelRef.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLazyPixelRef_DEFINED
 #define SkLazyPixelRef_DEFINED
 
@@ skipping 15 matching lines @@
 /**
  *  PixelRef which defers decoding until SkBitmap::lockPixels() is called.
  */
 class SkLazyPixelRef : public SkPixelRef {
 
 public:
     /**
      *  Create a new SkLazyPixelRef.
      *  @param SkData Encoded data representing the pixels.
      *  @param DecodeProc Called to decode the pixels when needed. Must be non-NULL.
-     *  @param SkImageCache Object that handles allocating and freeing the pixel memory, as needed.
-     *         Must not be NULL.
+     *  @param SkImageCache Object that handles allocating and freeing
+     *         the pixel memory, as needed.  If NULL, use the global
+     *         SkScaledImageCache.
      */
     SkLazyPixelRef(SkData*, SkBitmapFactory::DecodeProc, SkImageCache*);
 
     virtual ~SkLazyPixelRef();
 
 #ifdef SK_DEBUG
     intptr_t getCacheId() const { return fCacheId; }
 #endif
 
 #if LAZY_CACHE_STATS
     static int32_t GetCacheHits() { return gCacheHits; }
     static int32_t GetCacheMisses() { return gCacheMisses; }
     static void ResetCacheStats() { gCacheHits = gCacheMisses = 0; }
 #endif
 
     // No need to flatten this object. When flattening an SkBitmap, SkOrderedWriteBuffer will check
     // the encoded data and write that instead.
     // Future implementations of SkFlattenableWriteBuffer will need to special case for
     // onRefEncodedData as well.
     SK_DECLARE_UNFLATTENABLE_OBJECT()
 
 protected:
     virtual void* onLockPixels(SkColorTable**) SK_OVERRIDE;
     virtual void onUnlockPixels() SK_OVERRIDE;
     virtual bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; }
     virtual SkData* onRefEncodedData() SK_OVERRIDE;
     virtual bool onImplementsDecodeInto() SK_OVERRIDE;
     virtual bool onDecodeInto(int pow2, SkBitmap*) SK_OVERRIDE;
 
+    /**
+     *  The allocator is used when (fImageCache==NULL) to allocate
+     *  concrete PixelRefs as needed.  If NULL, use the default allocator.
+     *  This is passed directly into SkBitmap::allocPixels().
+     */
+    virtual void setAllocator(SkBitmap::Allocator * allocator = NULL) {
+        fAllocator = allocator;

[scroggo, 2013/10/23 15:27:49]

SkBitmap::Allocator inherits from SkRefCnt. Typically we would take ownership
via

SkRefCnt_SafeAssign(fAllocator, allocator);

If for some reason we do not want to follow that pattern here, the comment
should explain that ownership of fAllocator is not transferred.

Is this meant to be protected? Are we going to have a subclass of SkLazyPixelRef
that calls it?

[hal.canary, 2013/10/23 16:11:52]

I'll make that change, unless there is any reason that the Allocator shouldn't
bother incrementing itself.
 
Good catch.  I would have (hopefully) caught this after I wrote my unit tests.

+    }
+
 private:
     bool                        fErrorInDecoding;
     SkData*                     fData;
     SkBitmapFactory::DecodeProc fDecodeProc;
     SkImageCache*               fImageCache;
+    // fCacheId is a (SkScaledImageCache::ID*) or a (SkImageCache::ID).
     intptr_t                    fCacheId;
     size_t                      fRowBytes;
     SkImage::Info               fLazilyCachedInfo;
+    SkBitmap::Allocator*        fAllocator;
 
 #if LAZY_CACHE_STATS
     static int32_t              gCacheHits;
     static int32_t              gCacheMisses;
 #endif
 
     // lazily initialized our cached info. Returns NULL on failure.
     const SkImage::Info* getCachedInfo();
 
     typedef SkPixelRef INHERITED;
 };
 
 #endif  // SkLazyPixelRef_DEFINED