Refactor read and write buffers.

src/core/SkOrderedReadBuffer.cpp

Index: src/core/SkOrderedReadBuffer.cpp
diff --git a/src/core/SkOrderedReadBuffer.cpp b/src/core/SkOrderedReadBuffer.cpp
deleted file mode 100644
index 1ebaac4da860993fca7061add986496fb3161f85..0000000000000000000000000000000000000000
--- a/src/core/SkOrderedReadBuffer.cpp
+++ /dev/null
@@ -1,320 +0,0 @@
-
-/*
- * 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"
-#include "SkOrderedReadBuffer.h"
-#include "SkStream.h"
-#include "SkTypeface.h"
-
-SkOrderedReadBuffer::SkOrderedReadBuffer() : INHERITED() {
-    fMemoryPtr = NULL;
-
-    fBitmapStorage = NULL;
-    fTFArray = NULL;
-    fTFCount = 0;
-
-    fFactoryTDArray = NULL;
-    fFactoryArray = NULL;
-    fFactoryCount = 0;
-    fBitmapDecoder = NULL;
-#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
-    fDecodedBitmapIndex = -1;
-#endif // DEBUG_NON_DETERMINISTIC_ASSERT
-}
-
-SkOrderedReadBuffer::SkOrderedReadBuffer(const void* data, size_t size) : INHERITED()  {
-    fReader.setMemory(data, size);
-    fMemoryPtr = NULL;
-
-    fBitmapStorage = NULL;
-    fTFArray = NULL;
-    fTFCount = 0;
-
-    fFactoryTDArray = NULL;
-    fFactoryArray = NULL;
-    fFactoryCount = 0;
-    fBitmapDecoder = NULL;
-#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
-    fDecodedBitmapIndex = -1;
-#endif // DEBUG_NON_DETERMINISTIC_ASSERT
-}
-
-SkOrderedReadBuffer::SkOrderedReadBuffer(SkStream* stream) {
-    const size_t length = stream->getLength();
-    fMemoryPtr = sk_malloc_throw(length);
-    stream->read(fMemoryPtr, length);
-    fReader.setMemory(fMemoryPtr, length);
-
-    fBitmapStorage = NULL;
-    fTFArray = NULL;
-    fTFCount = 0;
-
-    fFactoryTDArray = NULL;
-    fFactoryArray = NULL;
-    fFactoryCount = 0;
-    fBitmapDecoder = NULL;
-#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
-    fDecodedBitmapIndex = -1;
-#endif // DEBUG_NON_DETERMINISTIC_ASSERT
-}
-
-SkOrderedReadBuffer::~SkOrderedReadBuffer() {
-    sk_free(fMemoryPtr);
-    SkSafeUnref(fBitmapStorage);
-}
-
-bool SkOrderedReadBuffer::readBool() {
-    return fReader.readBool();
-}
-
-SkColor SkOrderedReadBuffer::readColor() {
-    return fReader.readInt();
-}
-
-SkFixed SkOrderedReadBuffer::readFixed() {
-    return fReader.readS32();
-}
-
-int32_t SkOrderedReadBuffer::readInt() {
-    return fReader.readInt();
-}
-
-SkScalar SkOrderedReadBuffer::readScalar() {
-    return fReader.readScalar();
-}
-
-uint32_t SkOrderedReadBuffer::readUInt() {
-    return fReader.readU32();
-}
-
-int32_t SkOrderedReadBuffer::read32() {
-    return fReader.readInt();
-}
-
-void SkOrderedReadBuffer::readString(SkString* string) {
-    size_t len;
-    const char* strContents = fReader.readString(&len);
-    string->set(strContents, len);
-}
-
-void* SkOrderedReadBuffer::readEncodedString(size_t* length, SkPaint::TextEncoding encoding) {
-    SkDEBUGCODE(int32_t encodingType = ) fReader.readInt();
-    SkASSERT(encodingType == encoding);
-    *length =  fReader.readInt();
-    void* data = sk_malloc_throw(*length);
-    memcpy(data, fReader.skip(SkAlign4(*length)), *length);
-    return data;
-}
-
-void SkOrderedReadBuffer::readPoint(SkPoint* point) {
-    point->fX = fReader.readScalar();
-    point->fY = fReader.readScalar();
-}
-
-void SkOrderedReadBuffer::readMatrix(SkMatrix* matrix) {
-    fReader.readMatrix(matrix);
-}
-
-void SkOrderedReadBuffer::readIRect(SkIRect* rect) {
-    memcpy(rect, fReader.skip(sizeof(SkIRect)), sizeof(SkIRect));
-}
-
-void SkOrderedReadBuffer::readRect(SkRect* rect) {
-    memcpy(rect, fReader.skip(sizeof(SkRect)), sizeof(SkRect));
-}
-
-void SkOrderedReadBuffer::readRegion(SkRegion* region) {
-    fReader.readRegion(region);
-}
-
-void SkOrderedReadBuffer::readPath(SkPath* path) {
-    fReader.readPath(path);
-}
-
-bool SkOrderedReadBuffer::readArray(void* value, size_t size, size_t elementSize) {
-    const size_t count = this->getArrayCount();
-    if (count == size) {
-        (void)fReader.skip(sizeof(uint32_t)); // Skip array count
-        const size_t byteLength = count * elementSize;
-        memcpy(value, fReader.skip(SkAlign4(byteLength)), byteLength);
-        return true;
-    }
-    SkASSERT(false);
-    fReader.skip(fReader.available());
-    return false;
-}
-
-bool SkOrderedReadBuffer::readByteArray(void* value, size_t size) {
-    return readArray(static_cast<unsigned char*>(value), size, sizeof(unsigned char));
-}
-
-bool SkOrderedReadBuffer::readColorArray(SkColor* colors, size_t size) {
-    return readArray(colors, size, sizeof(SkColor));
-}
-
-bool SkOrderedReadBuffer::readIntArray(int32_t* values, size_t size) {
-    return readArray(values, size, sizeof(int32_t));
-}
-
-bool SkOrderedReadBuffer::readPointArray(SkPoint* points, size_t size) {
-    return readArray(points, size, sizeof(SkPoint));
-}
-
-bool SkOrderedReadBuffer::readScalarArray(SkScalar* values, size_t size) {
-    return readArray(values, size, sizeof(SkScalar));
-}
-
-uint32_t SkOrderedReadBuffer::getArrayCount() {
-    return *(uint32_t*)fReader.peek();
-}
-
-void SkOrderedReadBuffer::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 SkOrderedWriteBuffer::writeBitmap)
-        if (fBitmapStorage) {
-            *bitmap = *fBitmapStorage->getBitmap(index);
-            fBitmapStorage->releaseRef(index);
-            return;
-        } 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, "SkOrderedWriteBuffer::writeBitmap "
-                                       "stored the SkBitmap in an SkBitmapHeap, but "
-                                       "SkOrderedReadBuffer has no SkBitmapHeapReader to "
-                                       "retrieve the SkBitmap.");
-        }
-    } else {
-        // The writer stored false, meaning the SkBitmap was not stored in an SkBitmapHeap.
-        const size_t length = this->readUInt();
-        if (length > 0) {
-#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
-            fDecodedBitmapIndex++;
-#endif // DEBUG_NON_DETERMINISTIC_ASSERT
-            // A non-zero size means the SkBitmap was encoded. Read the data and pixel
-            // offset.
-            const void* data = this->skip(length);
-            const int32_t xOffset = fReader.readS32();
-            const int32_t yOffset = fReader.readS32();
-            if (fBitmapDecoder != NULL && fBitmapDecoder(data, length, bitmap)) {
-                if (bitmap->width() == width && bitmap->height() == height) {
-#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
-                    if (0 != xOffset || 0 != yOffset) {
-                        SkDebugf("SkOrderedReadBuffer::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;
-                }
-
-                // 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;
-                }
-            }
-            // 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;
-        }
-    }
-    // Could not read the SkBitmap. Use a placeholder bitmap.
-    bitmap->allocPixels(SkImageInfo::MakeN32Premul(width, height));
-    bitmap->eraseColor(SK_ColorRED);
-}
-
-SkTypeface* SkOrderedReadBuffer::readTypeface() {
-
-    uint32_t index = fReader.readU32();
-    if (0 == index || index > (unsigned)fTFCount) {
-        if (index) {
-            SkDebugf("====== typeface index %d\n", index);
-        }
-        return NULL;
-    } else {
-        SkASSERT(fTFArray);
-        return fTFArray[index - 1];
-    }
-}
-
-SkFlattenable* SkOrderedReadBuffer::readFlattenable(SkFlattenable::Type ft) {
-    //
-    // TODO: confirm that ft matches the factory we decide to use
-    //
-
-    SkFlattenable::Factory factory = NULL;
-
-    if (fFactoryCount > 0) {
-        int32_t index = fReader.readU32();
-        if (0 == index) {
-            return NULL; // writer failed to give us the flattenable
-        }
-        index -= 1;     // we stored the index-base-1
-        SkASSERT(index < fFactoryCount);
-        factory = fFactoryArray[index];
-    } else if (fFactoryTDArray) {
-        int32_t index = fReader.readU32();
-        if (0 == index) {
-            return NULL; // writer failed to give us the flattenable
-        }
-        index -= 1;     // we stored the index-base-1
-        factory = (*fFactoryTDArray)[index];
-    } else {
-        factory = (SkFlattenable::Factory)readFunctionPtr();
-        if (NULL == factory) {
-            return NULL; // writer failed to give us the flattenable
-        }
-    }
-
-    // if we get here, factory may still be null, but if that is the case, the
-    // failure was ours, not the writer.
-    SkFlattenable* obj = NULL;
-    uint32_t sizeRecorded = fReader.readU32();
-    if (factory) {
-        uint32_t offset = fReader.offset();
-        obj = (*factory)(*this);
-        // check that we read the amount we expected
-        uint32_t sizeRead = fReader.offset() - offset;
-        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;
-}