Break up SkLazyPixelRef functionally into class hierarchy.

src/lazy/SkLazyCachingPixelRef.h

Index: src/lazy/SkLazyCachingPixelRef.h
diff --git a/src/lazy/SkLazyCachingPixelRef.h b/src/lazy/SkLazyCachingPixelRef.h
new file mode 100644
index 0000000000000000000000000000000000000000..c13a2cd02b4e4efbf183d7298dad457e9c47d2f8
--- /dev/null
+++ b/src/lazy/SkLazyCachingPixelRef.h
@@ -0,0 +1,99 @@
+/*
+ * 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 SkLazyCachingPixelRef_DEFINED
+#define SkLazyCachingPixelRef_DEFINED
+
+#include "SkBitmapFactory.h"
+#include "SkCachingPixelRef.h"
+
+class SkData;
+
+/**
+ *  PixelRef which defers decoding until SkBitmap::lockPixels() is
+ *  called.  Makes use of a supplied decode procedure.  Will decode at
+ *  the procedure's preferred size.
+ */
+class SkLazyCachingPixelRef : public SkCachingPixelRef {
+public:
+    /**
+     *  @param data Encoded data representing the pixels.  NULL is
+     *         equivalent to an empty data, and will be passed to
+     *         DecodeProc with length zero.
+     *
+     *  @param procedure Called to decode the pixels when
+     *         needed. If NULL, use SkImageDecoder::DecodeMemoryToTarget.
+     */
+    SkLazyCachingPixelRef(SkData* data,
+                          SkBitmapFactory::DecodeProc procedure);
+
+    virtual ~SkLazyCachingPixelRef();
+
+    virtual SkData* onRefEncodedData() SK_OVERRIDE { return SkSafeRef(fData); }
+
+    /**
+     *  A simplified version of SkBitmapFactory.  Installs a new
+     *  SkLazyCachingPixelRef into the provided bitmap.  Will
+     *  immediately call onDecodeInfo() to configure the bitmap, but
+     *  will defer decoding until the first time the bitmap's pixels
+     *  are locked.
+     *
+     *  @param data Encoded data representing the pixels.  NULL is
+     *         equivalent to an empty data, and will be passed to
+     *         DecodeProc with length zero.
+     *
+     *  @param procedure Called to decode the pixels when
+     *         needed. If NULL, use SkImageDecoder::DecodeMemoryToTarget.
+     *
+     *  @param destination Bitmap that will be modified on success.
+     *
+     *  @returns true on success.
+     */
+    static bool Install(SkBitmapFactory::DecodeProc procedure,
+                        SkData* data,
+                        SkBitmap* destination);
+
+    // 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:
+    /**
+     *  Return some information about the pixels, allowing this class
+     *  to allocate pixels.  @return false if anything goes wrong.
+     *
+     *  This implementation calls SkBitmapFactory::DecodeProc with a
+     *  NULL target.
+     */
+    virtual bool onDecodeInfo(SkImageInfo* info) SK_OVERRIDE;
+    /**
+     *  Decode into the given pixels, a block of memory of size
+     *  (info.fHeight * rowBytes) bytes.
+     *
+     *  @param info Should be identical to the info returned by
+     *         onDecodeInfo so that the implementation can confirm
+     *         that the caller knows what its asking for (config,
+     *         size).
+     *
+     *  @return false if anything goes wrong.
+     */
+    virtual bool onDecodePixels(const SkImageInfo& info,
+                                void* pixels,
+                                size_t rowBytes) SK_OVERRIDE;
+
+private:
+    SkData*                     fData;
+    SkBitmapFactory::DecodeProc fDecodeProc;
+
+    typedef SkCachingPixelRef INHERITED;
+};
+
+#endif  // SkLazyCachingPixelRef_DEFINED
+