Break up SkLazyPixelRef functionally into class hierarchy.

src/lazy/SkCachingPixelRef.h

+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCachingPixelRef_DEFINED
+#define SkCachingPixelRef_DEFINED
+
+#include "SkImage.h"
+#include "SkPixelRef.h"
+#include "SkScaledImageCache.h"
+
+class SkColorTable;
+class SkImageCache;
+
+/**
+ *  PixelRef which defers decoding until SkBitmap::lockPixels() is
+ *  called.  Caches the decoded images in the global
+ *  SkScaledImageCache.  When the pixels are unlocked, this cache may
+ *  or be destroyed before the next lock.  If so, onLockPixels will
+ *  attempt to re-decode.
+ *
+ *  Decoding is handled by the pure-virtual functions onDecodeInfo()
+ *  and onDecode().  Subclasses of this class need only provide those
+ *  two functions.
+ */
+class SkCachingPixelRef : public SkPixelRef {
+public:
+    /**
+     *  Create a new SkCachingPixelRef.  If cache is NULL, use the
+     *  default global cache.
+     *
+     *  Allowing the use of a non-global cache is useful for testing.
+     *  Note that the SkCachingPixelRef does not take ownership of the
+     *  SkScaledImageCache.
+     */
+    explicit SkCachingPixelRef(SkScaledImageCache* cache = NULL);

[reed1, 2013/11/01 21:41:10]

Do we have a use-case in mind for taking the cache explicitly? If not, I suggest
for simplicity we skip this parameter, and only add it in later as needed (esp.
easy since this is a private subclass).

[hal.canary, 2013/11/04 13:38:49]

I restored the use-case in the unit test.

+    virtual ~SkCachingPixelRef();
+
+protected:
+    virtual void* onLockPixels(SkColorTable** colorTable) SK_OVERRIDE;
+    virtual void onUnlockPixels() SK_OVERRIDE;
+    virtual bool onLockPixelsAreWritable() const SK_OVERRIDE { return false; }
+    virtual bool onImplementsDecodeInto() SK_OVERRIDE  { return true; }
+    virtual bool onDecodeInto(int pow2, SkBitmap*) SK_OVERRIDE;
+
+    /**
+     *  Configure the supplied bitmap for this pixelRef, based on
+     *  information provided by onDecodeInfo().  Does not set the
+     *  bitmap's pixelRef. */
+    bool configure(SkBitmap* bitmap);
+
+    /**
+     *  Cache info from onDecodeInfo(). Returns NULL on failure.
+     */
+    const SkImageInfo* getInfo();
+
+    /**
+     *  Return some information about the pixels, allowing this class
+     *  to allocate pixels.  @return false if anything goes wrong.
+     */
+    virtual bool onDecodeInfo(SkImageInfo* info) = 0;
+    /**
+     *  Decode into the given pixels, a block of memory of size
+     *  (info->fHeight * rowBytes) bytes.  Should follow the format
+     *  reported by onDecodeInfo().
+     *  @return false if anything goes wrong.
+     */
+    virtual bool onDecode(void* pixels, size_t rowBytes) = 0;
+
+private:
+    bool                        fErrorInDecoding;
+    SkScaledImageCache*         fCache;
+    SkScaledImageCache::ID*     fScaledCacheId;
+    SkImageInfo                 fInfo;
+
+    typedef SkPixelRef INHERITED;
+};
+
+#endif  // SkCachingPixelRef_DEFINED
+