Modify SkLazyPixelRef to use SkImageGenerator.

src/core/SkMallocPixelRef.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkMallocPixelRef.h"
 #include "SkBitmap.h"
 #include "SkFlattenableBuffers.h"
+#include "SkImageGenerator.h"
 
 SkMallocPixelRef::SkMallocPixelRef(void* storage, size_t size,
                                    SkColorTable* ctable, bool ownPixels) {
     if (NULL == storage) {
         SkASSERT(ownPixels);
         storage = sk_malloc_throw(size);
     }
     fStorage = storage;
     fSize = size;
     fCTable = ctable;
     SkSafeRef(ctable);
     fOwnPixels = ownPixels;
 
     this->setPreLocked(fStorage, fCTable);
 }
 
 SkMallocPixelRef::~SkMallocPixelRef() {
     SkSafeUnref(fCTable);
     if (fOwnPixels) {
         sk_free(fStorage);
     }
 }
 
+bool SkMallocPixelRef::Install(SkImageGenerator* generator,
+                               SkBitmap* destination) {
+    SkASSERT(generator != NULL);
+    SkAutoTDelete<SkImageGenerator> autodel(generator);
+    // Always gets deleted by this function.
+    SkImageInfo info;
+    SkBitmap tmp;
+    if ((NULL == generator)
+        || (!generator->getInfo(&info))
+        || (!tmp.setConfig(info, 0))) {
+        return false;
+    }
+    size_t rowBytes = tmp.rowBytes();
+    size_t size = tmp.getSize();
+    void* pixels = sk_malloc_throw(size);

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

Can we change this to sk_malloc_flags() so we can return NULL on allocation
failure?

+    if (!generator->getPixels(info, pixels, rowBytes)) {
+        sk_free(pixels);
+        return false;
+    }
+    SkAutoTUnref<SkMallocPixelRef> ref(SkNEW_ARGS(SkMallocPixelRef,
+                                                  (pixels, size, NULL, true)));
+    *destination = tmp;  // copy config, size, rowbytes.
+    destination->setPixelRef(ref);
+    destination->lockPixels();  // Since we're already allocated, we lock
+                                // right away, just like HeapAllocator.
+    return true;
+}
+
 void* SkMallocPixelRef::onLockPixels(SkColorTable** ct) {
     *ct = fCTable;
     return fStorage;
 }
 
 void SkMallocPixelRef::onUnlockPixels() {
     // nothing to do
 }
 
 void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
@@ skipping 13 matching lines @@
     buffer.readByteArray(fStorage, fSize);
     if (buffer.readBool()) {
         fCTable = SkNEW_ARGS(SkColorTable, (buffer));
     } else {
         fCTable = NULL;
     }
     fOwnPixels = true;
 
     this->setPreLocked(fStorage, fCTable);
 }