Add the lazy decoder from PictureFlags to SkImageDecoder

src/images/SkImageDecoder.cpp

Index: src/images/SkImageDecoder.cpp
diff --git a/src/images/SkImageDecoder.cpp b/src/images/SkImageDecoder.cpp
index 5d94bb1c2db97efd618320213210ef91ee363329..9b8ae726acb26938d605244b0ccf34e8debe2fa7 100644
--- a/src/images/SkImageDecoder.cpp
+++ b/src/images/SkImageDecoder.cpp
@@ -8,12 +8,16 @@
 
 #include "SkImageDecoder.h"
 #include "SkBitmap.h"
+#include "SkData.h"
+#include "SkForceLinking.h"
 #include "SkImagePriv.h"
 #include "SkPixelRef.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkCanvas.h"
 
+__SK_FORCE_IMAGE_DECODER_LINKING;

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

If we move __SK_FORCE_IMAGE_DECODER_LINKING here, we might as well move all of
the contents of SkForceLinking here.

The code for forcing linking has moved around a bit - it was here in the past.
I'll have to look back at it's history to reaffirm that its current location
makes sense. (You're free to investigate as well. It moved to SkForceLinking in
https://codereview.chromium.org/15806010)

+
 SK_DEFINE_INST_COUNT(SkImageDecoder::Peeker)
 SK_DEFINE_INST_COUNT(SkImageDecoder::Chooser)
 SK_DEFINE_INST_COUNT(SkImageDecoderFactory)
@@ -280,6 +284,22 @@ bool SkImageDecoder::DecodeFile(const char file[], SkBitmap* bm,
     return false;
 }
 
+SkLruImageCache SkImageDecoder::fLruImageCache(1024*1024);

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

Leon, why 1024^2? I copied this from what you have in PictureRenderFlags but I
don't really understand the choice of size.

Also, this is not a verbatim copy of lazy_decode_bitmap. I didn't implement your
elastic cache class. I'll talk to you on Monday?

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

This was arbitrary. I may have based it off of a number used elsewhere. If we
are to actually use it in production code, we should test to find the ideal
size.

+SkBitmapFactory SkImageDecoder::fLazyBitmapFactory(&SkImageDecoder::DecodeMemoryToTarget);
+
+bool SkImageDecoder::LazyDecodeBitmap(const void* buffer, size_t size, SkBitmap* bitmap) {
+    void* copiedBuffer = sk_malloc_throw(size);
+    memcpy(copiedBuffer, buffer, size);
+    SkAutoDataUnref data(SkData::NewFromMalloc(copiedBuffer, size));
+
+    static bool gOnce;
+    if (!gOnce) {

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

This is not threadsafe. In its current use in our tools, we never call this
function from anything but the main thread, but if we are to make it public, we
should acquire a mutex.

Searching through our code, it appears we do not generally lock a mutex for a
lazy initialization like this...

+        fLazyBitmapFactory.setImageCache(&fLruImageCache);
+        gOnce = true;
+    }
+    return fLazyBitmapFactory.installPixelRef(data, bitmap);
+}
+
 bool SkImageDecoder::DecodeMemory(const void* buffer, size_t size, SkBitmap* bm,
                           SkBitmap::Config pref, Mode mode, Format* format) {
     if (0 == size) {