Modify SkLazyPixelRef to use SkImageGenerator.

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 "SkImageGenerator.h"
+#include "SkImageInfo.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.  If NULL, use the global
-     *         SkScaledImageCache.
+     *  Given a SkImageGenerator object, creates a new SkLazyPixelRef
+     *  and installs it into destination SkBitmap.
      */
-    SkLazyPixelRef(SkData*, SkBitmapFactory::DecodeProc, SkImageCache*);
-
-    virtual ~SkLazyPixelRef();
+    static bool Install(SkImageGenerator*, SkImageCache*, SkBitmap* dst);

[reed1, 2013/11/25 18:06:56]

Do we still support SkImageCache?

 
 #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.
+    // 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 ~SkLazyPixelRef();
+    virtual void* onLockPixels(SkColorTable** colorTable) 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 onImplementsDecodeInto() SK_OVERRIDE { return true; }
     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;
+    bool              fErrorInDecoding;
+    SkImageGenerator* fImageGenerator;
+    SkImageCache::ID  fCacheId;
+    SkImageInfo       fInfo;
+    size_t            fSize;
+    size_t            fRowBytes;
+    SkImageCache*     fImageCache;
 
 #if LAZY_CACHE_STATS
-    static int32_t              gCacheHits;
-    static int32_t              gCacheMisses;
+    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();
-
+    /**
+     *  @param SkImageCache Object that handles allocating and freeing
+     *         the pixel memory, as needed.
+     */
+    SkLazyPixelRef(SkImageGenerator*,
+                   const SkImageInfo&,
+                   size_t size,
+                   size_t rowBytes,
+                   SkImageCache*);
 
     typedef SkPixelRef INHERITED;
 };
 
 #endif  // SkLazyPixelRef_DEFINED