stop calling SkBitmap::flatten

src/core/SkReadBuffer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkErrorInternals.h"
@@ skipping 173 matching lines @@
 }
 
 bool SkReadBuffer::readScalarArray(SkScalar* values, size_t size) {
     return readArray(values, size, sizeof(SkScalar));
 }
 
 uint32_t SkReadBuffer::getArrayCount() {
     return *(uint32_t*)fReader.peek();
 }
 
-void SkReadBuffer::readBitmap(SkBitmap* bitmap) {
+bool SkReadBuffer::readBitmap(SkBitmap* bitmap) {
     const int width = this->readInt();
     const int height = this->readInt();
     // The writer stored a boolean value to determine whether an SkBitmapHeap was used during
     // writing.
     if (this->readBool()) {
         // An SkBitmapHeap was used for writing. Read the index from the stream and find the
         // corresponding SkBitmap in fBitmapStorage.
         const uint32_t index = fReader.readU32();
         fReader.readU32(); // bitmap generation ID (see SkWriteBuffer::writeBitmap)
         if (fBitmapStorage) {
             *bitmap = *fBitmapStorage->getBitmap(index);
             fBitmapStorage->releaseRef(index);
-            return;
+            return true;
         } else {
             // The bitmap was stored in a heap, but there is no way to access it. Set an error and
             // fall through to use a place holder bitmap.
             SkErrorInternals::SetError(kParseError_SkError, "SkWriteBuffer::writeBitmap "
                                        "stored the SkBitmap in an SkBitmapHeap, but "
                                        "SkReadBuffer has no SkBitmapHeapReader to "
                                        "retrieve the SkBitmap.");
         }
     } else {
         // The writer stored false, meaning the SkBitmap was not stored in an SkBitmapHeap.
@@ skipping 14 matching lines @@
                         SkDebugf("SkReadBuffer::readBitmap: heights match,"
                                  " but offset is not zero. \nInfo about the bitmap:"
                                  "\n\tIndex: %d\n\tDimensions: [%d %d]\n\tEncoded"
                                  " data size: %d\n\tOffset: (%d, %d)\n",
                                  fDecodedBitmapIndex, width, height, length, xOffset,
                                  yOffset);
                     }
 #endif // DEBUG_NON_DETERMINISTIC_ASSERT
                     // If the width and height match, there should be no offset.
                     SkASSERT(0 == xOffset && 0 == yOffset);
-                    return;
+                    return true;
                 }
 
                 // This case can only be reached if extractSubset was called, so
                 // the recorded width and height must be smaller than or equal to
                 // the encoded width and height.
                 // FIXME (scroggo): This assert assumes that our decoder and the
                 // sources encoder agree on the width and height which may not
                 // always be the case. Removing until it can be investigated
                 // further.
                 //SkASSERT(width <= bitmap->width() && height <= bitmap->height());
 
                 SkBitmap subsetBm;
                 SkIRect subset = SkIRect::MakeXYWH(xOffset, yOffset, width, height);
                 if (bitmap->extractSubset(&subsetBm, subset)) {
                     bitmap->swap(subsetBm);
-                    return;
+                    return true;
                 }
             }
             // This bitmap was encoded when written, but we are unable to decode, possibly due to
             // not having a decoder.
             SkErrorInternals::SetError(kParseError_SkError,
                                        "Could not decode bitmap. Resulting bitmap will be red.");
         } else {
             // A size of zero means the SkBitmap was simply flattened.
-            bitmap->unflatten(*this);
-            return;
+            if (this->pictureVersion() > 0 && this->pictureVersion() < 27) {

[scroggo, 2014/05/20 13:27:50]

Is there a valid reason for pictureVersion to be <= 0? Would it not break in
other ways?

[reed1, 2014/05/20 17:49:58]

When version is 0, we are an un-versioned buffer (i.e. in ram, not read back
from a disk). This oddness is hidden in the rebased version where we always call
isVersionLT()

+                SkBitmap tmp;
+                tmp.unflatten(*this);
+                // just throw this guy away
+            }
         }
     }
     // Could not read the SkBitmap. Use a placeholder bitmap.
-    bitmap->allocPixels(SkImageInfo::MakeN32Premul(width, height));
-    bitmap->eraseColor(SK_ColorRED);
+    bitmap->setConfig(SkImageInfo::MakeUnknown(width, height));
+    return false;
 }
 
 SkTypeface* SkReadBuffer::readTypeface() {
 
     uint32_t index = fReader.readU32();
     if (0 == index || index > (unsigned)fTFCount) {
         if (index) {
             SkDebugf("====== typeface index %d\n", index);
         }
         return NULL;
@@ skipping 44 matching lines @@
         if (sizeRecorded != sizeRead) {
             // we could try to fix up the offset...
             sk_throw();
         }
     } else {
         // we must skip the remaining data
         fReader.skip(sizeRecorded);
     }
     return obj;
 }