Add the lazy decoder from PictureFlags to SkImageDecoder

include/core/SkImageDecoder.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkImageDecoder_DEFINED
 #define SkImageDecoder_DEFINED
 
 #include "SkBitmap.h"
 #include "SkBitmapFactory.h"
 #include "SkImage.h"
+#include "SkLruImageCache.h"
 #include "SkRect.h"
 #include "SkRefCnt.h"
+#include "SkPurgeableImageCache.h"

[caryclark, 2013/07/12 18:29:39]

this may be correct but why is it required? I don't see a reference in your
changes below

[sglez, 2013/07/13 04:11:27]

Good catch. I was using it when trying to implement Leon's MyCacheSelector. I
decided to wait until I got to talk to him, but forgot to remove this include

 #include "SkTypes.h"
 
 class SkStream;
 
 /** \class SkImageDecoder
 
     Base class for decoding compressed images into a SkBitmap
 */
 class SkImageDecoder : public SkNoncopyable {
 public:
@@ skipping 62 matching lines @@
     */
     void setRequireUnpremultipliedColors(bool request) {
         fRequireUnpremultipliedColors = request;
     }
 
     /** Returns true if the decoder will only return bitmaps with unpremultiplied
         colors.
     */
     bool getRequireUnpremultipliedColors() const { return fRequireUnpremultipliedColors; }
 
+    /**
+     * Returns a pointer to the LRU cache used by LazyDecodeBitmap.
+     */
+    static SkLruImageCache* getLruImageCache() {
+        return &fLruImageCache;
+    }
+
     /** \class Peeker
 
         Base class for optional callbacks to retrieve meta/chunk data out of
         an image as it is being decoded.
     */
     class Peeker : public SkRefCnt {
     public:
         SK_DECLARE_INST_COUNT(Peeker)
 
         /** Return true to continue decoding, or false to indicate an error, which
@@ skipping 191 matching lines @@
      */
     static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap,
                              SkBitmap::Config prefConfig, Mode,
                              Format* format = NULL);
     static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap){
         return DecodeMemory(buffer, size, bitmap, SkBitmap::kNo_Config,
                             kDecodePixels_Mode, NULL);
     }
 
     /**
+     * Decode the image with DecodeMemoryToTarget but defer the process until it is needed.
+     */
+    static bool LazyDecodeBitmap(const void* buffer, size_t size, SkBitmap* bitmap);
+
+    /**
      *  Decode memory.
      *  @param info Output parameter. Returns info about the encoded image.
      *  @param target Contains the address of pixel memory to decode into
      *         (which must be large enough to hold the width in info) and
      *         the row bytes to use. If NULL, returns info and does not
      *         decode pixels.
      *  @return bool Whether the function succeeded.
      *
      *  Sample usage:
      *  <code>
@@ skipping 140 matching lines @@
     Chooser*                fChooser;
     SkBitmap::Allocator*    fAllocator;
     int                     fSampleSize;
     SkBitmap::Config        fDefaultPref;   // use if fUsePrefTable is false
     SkBitmap::Config        fPrefTable[6];  // use if fUsePrefTable is true
     bool                    fDitherImage;
     bool                    fUsePrefTable;
     mutable bool            fShouldCancelDecode;
     bool                    fPreferQualityOverSpeed;
     bool                    fRequireUnpremultipliedColors;
+
+    static SkLruImageCache fLruImageCache;
+    static SkBitmapFactory fLazyBitmapFactory;
+
 };
 
 /** Calling newDecoder with a stream returns a new matching imagedecoder
     instance, or NULL if none can be found. The caller must manage its ownership
     of the stream as usual, calling unref() when it is done, as the returned
     decoder may have called ref() (and if so, the decoder is responsible for
     balancing its ownership when it is destroyed).
  */
 class SkImageDecoderFactory : public SkRefCnt {
 public:
@@ skipping 29 matching lines @@
 // not all of these will be available
 DECLARE_DECODER_CREATOR(BMPImageDecoder);
 DECLARE_DECODER_CREATOR(GIFImageDecoder);
 DECLARE_DECODER_CREATOR(ICOImageDecoder);
 DECLARE_DECODER_CREATOR(JPEGImageDecoder);
 DECLARE_DECODER_CREATOR(PNGImageDecoder);
 DECLARE_DECODER_CREATOR(WBMPImageDecoder);
 DECLARE_DECODER_CREATOR(WEBPImageDecoder);
 
 #endif