Expand pixelref to return SkImageInfo and rowbytes

src/lazy/SkLazyPixelRef.h

Index: src/lazy/SkLazyPixelRef.h
diff --git a/src/lazy/SkLazyPixelRef.h b/src/lazy/SkLazyPixelRef.h
new file mode 100644
index 0000000000000000000000000000000000000000..480eac913fcb2b8c0024a4e18b953a701ac7327c
--- /dev/null
+++ b/src/lazy/SkLazyPixelRef.h
@@ -0,0 +1,97 @@
+/*
+ * 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 {

[scroggo, 2013/12/06 14:50:33]

This file was deleted by Hal.

+
+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.  If NULL, use the global
+     *         SkScaledImageCache.
+     */
+    SkLazyPixelRef(const SkImageInfo&, 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 bool onNewLockPixels(LockRec*) 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;
+    union {
+        SkImageCache::ID        fCacheId;
+        SkScaledImageCache::ID* fScaledCacheId;
+    };
+    size_t                      fRowBytes;
+    SkImageInfo                 fLazilyCachedInfo;
+
+#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();
+    bool lockScaledImageCachePixels(LockRec*);
+    bool lockImageCachePixels(LockRec*);
+
+
+    typedef SkPixelRef INHERITED;
+};
+
+#endif  // SkLazyPixelRef_DEFINED