Refactor read and write buffers.

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"
-#include "SkOrderedReadBuffer.h"
+#include "SkReadBuffer.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 
-SkOrderedReadBuffer::SkOrderedReadBuffer() : INHERITED() {
+static uint32_t default_flags() {
+    uint32_t flags = 0;
+#ifdef SK_SCALAR_IS_FLOAT
+    flags |= SkReadBuffer::kScalarIsFloat_Flag;
+#endif
+    if (8 == sizeof(void*)) {
+        flags |= SkReadBuffer::kPtrIs64Bit_Flag;
+    }
+    return flags;
+}
+
+SkReadBuffer::SkReadBuffer() {
+    fFlags = default_flags();
     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()  {
+SkReadBuffer::SkReadBuffer(const void* data, size_t size) {
+    fFlags = default_flags();
     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) {
+SkReadBuffer::SkReadBuffer(SkStream* stream) {
+    fFlags = default_flags();
     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() {
+SkReadBuffer::~SkReadBuffer() {
     sk_free(fMemoryPtr);
     SkSafeUnref(fBitmapStorage);
 }
 
-bool SkOrderedReadBuffer::readBool() {
+bool SkReadBuffer::readBool() {
     return fReader.readBool();
 }
 
-SkColor SkOrderedReadBuffer::readColor() {
+SkColor SkReadBuffer::readColor() {
     return fReader.readInt();
 }
 
-SkFixed SkOrderedReadBuffer::readFixed() {
+SkFixed SkReadBuffer::readFixed() {
     return fReader.readS32();
 }
 
-int32_t SkOrderedReadBuffer::readInt() {
+int32_t SkReadBuffer::readInt() {
     return fReader.readInt();
 }
 
-SkScalar SkOrderedReadBuffer::readScalar() {
+SkScalar SkReadBuffer::readScalar() {
     return fReader.readScalar();
 }
 
-uint32_t SkOrderedReadBuffer::readUInt() {
+uint32_t SkReadBuffer::readUInt() {
     return fReader.readU32();
 }
 
-int32_t SkOrderedReadBuffer::read32() {
+int32_t SkReadBuffer::read32() {
     return fReader.readInt();
 }
 
-void SkOrderedReadBuffer::readString(SkString* string) {
+void SkReadBuffer::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) {
+void* SkReadBuffer::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) {
+void SkReadBuffer::readPoint(SkPoint* point) {
     point->fX = fReader.readScalar();
     point->fY = fReader.readScalar();
 }
 
-void SkOrderedReadBuffer::readMatrix(SkMatrix* matrix) {
+void SkReadBuffer::readMatrix(SkMatrix* matrix) {
     fReader.readMatrix(matrix);
 }
 
-void SkOrderedReadBuffer::readIRect(SkIRect* rect) {
+void SkReadBuffer::readIRect(SkIRect* rect) {
     memcpy(rect, fReader.skip(sizeof(SkIRect)), sizeof(SkIRect));
 }
 
-void SkOrderedReadBuffer::readRect(SkRect* rect) {
+void SkReadBuffer::readRect(SkRect* rect) {
     memcpy(rect, fReader.skip(sizeof(SkRect)), sizeof(SkRect));
 }
 
-void SkOrderedReadBuffer::readRegion(SkRegion* region) {
+void SkReadBuffer::readRegion(SkRegion* region) {
     fReader.readRegion(region);
 }
 
-void SkOrderedReadBuffer::readPath(SkPath* path) {
+void SkReadBuffer::readPath(SkPath* path) {
     fReader.readPath(path);
 }
 
-bool SkOrderedReadBuffer::readArray(void* value, size_t size, size_t elementSize) {
+bool SkReadBuffer::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) {
+bool SkReadBuffer::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) {
+bool SkReadBuffer::readColorArray(SkColor* colors, size_t size) {
     return readArray(colors, size, sizeof(SkColor));
 }
 
-bool SkOrderedReadBuffer::readIntArray(int32_t* values, size_t size) {
+bool SkReadBuffer::readIntArray(int32_t* values, size_t size) {
     return readArray(values, size, sizeof(int32_t));
 }
 
-bool SkOrderedReadBuffer::readPointArray(SkPoint* points, size_t size) {
+bool SkReadBuffer::readPointArray(SkPoint* points, size_t size) {
     return readArray(points, size, sizeof(SkPoint));
 }
 
-bool SkOrderedReadBuffer::readScalarArray(SkScalar* values, size_t size) {
+bool SkReadBuffer::readScalarArray(SkScalar* values, size_t size) {
     return readArray(values, size, sizeof(SkScalar));
 }
 
-uint32_t SkOrderedReadBuffer::getArrayCount() {
+uint32_t SkReadBuffer::getArrayCount() {
     return *(uint32_t*)fReader.peek();
 }
 
-void SkOrderedReadBuffer::readBitmap(SkBitmap* bitmap) {
+void 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 SkOrderedWriteBuffer::writeBitmap)
+        fReader.readU32(); // bitmap generation ID (see SkWriteBuffer::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 "
+            SkErrorInternals::SetError(kParseError_SkError, "SkWriteBuffer::writeBitmap "
                                        "stored the SkBitmap in an SkBitmapHeap, but "
-                                       "SkOrderedReadBuffer has no SkBitmapHeapReader to "
+                                       "SkReadBuffer 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,"
+                        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;
@@ skipping 23 matching lines @@
             // 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() {
+SkTypeface* SkReadBuffer::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) {
+SkFlattenable* SkReadBuffer::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
@@ skipping 27 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;
 }