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 "SkTypes.h"
 
 class SkStream;
 
 /** \class SkImageDecoder
 
     Base class for decoding compressed images into a SkBitmap
 */
@@ skipping 64 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() {

[scroggo, 2013/07/15 15:09:28]

This does not generally relate to SkImageDecoder, so I don't think that it
belongs here.

+        return &fLruImageCache;

[scroggo, 2013/07/15 15:09:28]

SkImageDecoder.h is built by chromium, but SkImageDecoder.cpp is not (instead,
it builds SkImageDecoder_empty.cpp, because it does not use SkImageDecoder, but
some of our other files depend on it). This means that this static variable
(which chromium tries to avoid anyway) won't get initialized.

+    }
+
     /** \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);

[scroggo, 2013/07/15 15:09:28]

I support moving LazyDecodeBitmap to a header file for documentation/ease of
access, but I don't think SkImageDecoder is the right place for it.

Although it uses SkImageDecoder, SkImageDecoder does not use it, so it could
easily live in its own file(s).

I lean towards leaving the files in tools/ until/unless we decide to make it
public. LazyDecodeBitmap is only used by our tools, and may undergo some changes
before we get our clients to use it.

+
+    /**
      *  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