Add the lazy decoder from PictureFlags to SkImageDecoder

src/images/SkImageDecoder.cpp

 /*
  * 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.
  */
 
 
 #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)
 
 static SkBitmap::Config gDeviceConfig = SkBitmap::kNo_Config;
 
 SkBitmap::Config SkImageDecoder::GetDeviceConfig()
 {
     return gDeviceConfig;
 }
@@ skipping 246 matching lines @@
     SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(file));
     if (stream.get()) {
         if (SkImageDecoder::DecodeStream(stream, bm, pref, mode, format)) {
             bm->pixelRef()->setURI(file);
             return true;
         }
     }
     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) {
         return false;
     }
     SkASSERT(buffer);
 
     SkMemoryStream  stream(buffer, size);
     return SkImageDecoder::DecodeStream(&stream, bm, pref, mode, format);
 }
@@ skipping 161 matching lines @@
             if (kUnknown_Format == *format) {
                 if (stream->rewind()) {
                     *format = GetStreamFormat(stream);
                 }
             }
         }
         delete codec;
     }
     return success;
 }