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
 
 #include "SkBitmapFactory.h"
 #include "SkImage.h"
+#include "SkImageCache.h"
 #include "SkPixelRef.h"
 #include "SkFlattenable.h"
+#include "SkScaledImageCache.h"
 
 class SkColorTable;
 class SkData;
 class SkImageCache;
 
 #ifdef SK_DEBUG
     #define LAZY_CACHE_STATS 1
 #elif !defined(LAZY_CACHE_STATS)
     #define LAZY_CACHE_STATS 0
 #endif
 
 /**
  *  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
 
+    /**
+     *  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);

[reed1, 2013/10/24 21:07:04]

Why is this API introduced at this time?

[hal.canary, 2013/10/25 16:37:10]

It needs to be done, since "Make current image cache in skia use a simple
allocator interface that maps to the DM allocator in chromium and uses malloc
elsewhere." is in the roadmap.

It makes sense to do it now, since it fits into the decode_into_bitmap()
function.

+
     // 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;
 
 private:
     bool                        fErrorInDecoding;
     SkData*                     fData;
     SkBitmapFactory::DecodeProc fDecodeProc;
     SkImageCache*               fImageCache;
-    intptr_t                    fCacheId;
+    union {
+        SkImageCache::ID        fCacheId;
+        SkScaledImageCache::ID* fScaledCacheId;

[scroggo, 2013/10/24 20:41:39]

I thought you were going to change the declaration of ID from a struct to an
intptr_t?

[hal.canary, 2013/10/25 16:37:10]

I would have, but this way allows me to skip a dozen useless cast operations,
each of which is an opportunity to make a mistake.

+    };
     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();
+    void* lockScaledImageCachePixels();
+    void* lockImageCachePixels();
+
 
     typedef SkPixelRef INHERITED;
 };
 
 #endif  // SkLazyPixelRef_DEFINED