Break up SkLazyPixelRef functionally into class hierarchy.

src/lazy/SkCachingPixelRef.h

Index: src/lazy/SkCachingPixelRef.h
diff --git a/src/lazy/SkCachingPixelRef.h b/src/lazy/SkCachingPixelRef.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0ba38e7ae2333399ebaa8b36d5b5fb754583eed
--- /dev/null
+++ b/src/lazy/SkCachingPixelRef.h
@@ -0,0 +1,84 @@
+/*
+ * 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-decoded.

[scroggo, 2013/11/01 15:48:00]

re-decode.

[hal.canary, 2013/11/01 16:31:09]

Done.

+ *
+ *  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);
+    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);
+
+    /**
+     * Return some information about the pixels, allowing this class
+     * to allocate pixels.  @return false if anything goes wrong.
+     */
+    virtual bool onDecodeInfo(SkISize*,
+                              SkBitmap::Config*,
+                              SkAlphaType*) = 0;
+    /**
+     * Decode into the given pixels, a block of memory of size
+     * (size->fHeight * fRowBytes) bytes.
+     * @return false if anything goes wrong.
+     */
+    virtual bool onDecode(void* pixels, size_t rowBytes) = 0;
+
+private:
+    bool                        fErrorInDecoding;
+    SkScaledImageCache*         fCache;
+    SkScaledImageCache::ID*     fScaledCacheId;
+    SkISize                     fBitmapSize;
+    SkBitmap::Config            fBitmapConfig;
+    SkAlphaType                 fBitmapAlphaType;
+
+    // Cache info from onDecodeInfo(). Returns false on failure.
+    bool updateInfo();
+
+    typedef SkPixelRef INHERITED;
+};
+
+#endif  // SkCachingPixelRef_DEFINED
+