Refactor read and write buffers.

src/core/SkPicturePlayback.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 "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkTypeface.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
 #include <new>
 #include "SkBBoxHierarchy.h"
 #include "SkPictureStateTree.h"
 #include "SkTSort.h"
 
 template <typename T> int SafeCount(const T* obj) {
     return obj ? obj->count() : 0;
 }
 
 /*  Define this to spew out a debug statement whenever we skip the remainder of
@@ skipping 292 matching lines @@
 // these are all inside the ARRAYS tag
 #define PICT_BITMAP_BUFFER_TAG  SkSetFourByteTag('b', 't', 'm', 'p')
 #define PICT_PAINT_BUFFER_TAG   SkSetFourByteTag('p', 'n', 't', ' ')
 #define PICT_PATH_BUFFER_TAG    SkSetFourByteTag('p', 't', 'h', ' ')
 
 // Always write this guy last (with no length field afterwards)
 #define PICT_EOF_TAG     SkSetFourByteTag('e', 'o', 'f', ' ')
 
 #include "SkStream.h"
 
-static void writeTagSize(SkOrderedWriteBuffer& buffer, uint32_t tag,
+static void writeTagSize(SkWriteBuffer& buffer, uint32_t tag,
                          uint32_t size) {
     buffer.writeUInt(tag);
     buffer.writeUInt(size);
 }
 
 static void writeTagSize(SkWStream* stream, uint32_t tag,
                          uint32_t size) {
     stream->write32(tag);
     stream->write32(size);
 }
@@ skipping 27 matching lines @@
 
     SkAutoSTMalloc<16, SkTypeface*> storage(count);
     SkTypeface** array = (SkTypeface**)storage.get();
     rec.copyToArray((SkRefCnt**)array);
 
     for (int i = 0; i < count; i++) {
         array[i]->serialize(stream);
     }
 }
 
-void SkPicturePlayback::flattenToBuffer(SkOrderedWriteBuffer& buffer) const {
+void SkPicturePlayback::flattenToBuffer(SkWriteBuffer& buffer) const {
     int i, n;
 
     if ((n = SafeCount(fBitmaps)) > 0) {
         writeTagSize(buffer, PICT_BITMAP_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writeBitmap((*fBitmaps)[i]);
         }
     }
 
     if ((n = SafeCount(fPaints)) > 0) {
@@ skipping 20 matching lines @@
             fPictureRefs[i]->serialize(stream, encoder);
         }
     }
 
     // Write some of our data into a writebuffer, and then serialize that
     // into our stream
     {
         SkRefCntSet  typefaceSet;
         SkFactorySet factSet;
 
-        SkOrderedWriteBuffer buffer;
-        buffer.setFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag);
+        SkWriteBuffer buffer;
+        buffer.setFlags(SkWriteBuffer::kCrossProcess_Flag);
         buffer.setTypefaceRecorder(&typefaceSet);
         buffer.setFactoryRecorder(&factSet);
         buffer.setBitmapEncoder(encoder);
 
         this->flattenToBuffer(buffer);
 
         // We have to write these to sets into the stream *before* we write
         // the buffer, since parsing that buffer will require that we already
         // have these sets available to use.
         writeFactories(stream, factSet);
         writeTypefaces(stream, typefaceSet);
 
-        writeTagSize(stream, PICT_BUFFER_SIZE_TAG, buffer.size());
+        writeTagSize(stream, PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
         buffer.writeToStream(stream);
     }
 
     stream->write32(PICT_EOF_TAG);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
- *  Return the corresponding SkFlattenableReadBuffer flags, given a set of
+ *  Return the corresponding SkReadBuffer flags, given a set of
  *  SkPictInfo flags.
  */
 static uint32_t pictInfoFlagsToReadBufferFlags(uint32_t pictInfoFlags) {
     static const struct {
         uint32_t    fSrc;
         uint32_t    fDst;
     } gSD[] = {
-        { SkPictInfo::kCrossProcess_Flag,   SkFlattenableReadBuffer::kCrossProcess_Flag },
-        { SkPictInfo::kScalarIsFloat_Flag,  SkFlattenableReadBuffer::kScalarIsFloat_Flag },
-        { SkPictInfo::kPtrIs64Bit_Flag,     SkFlattenableReadBuffer::kPtrIs64Bit_Flag },
+        { SkPictInfo::kCrossProcess_Flag,   SkReadBuffer::kCrossProcess_Flag },
+        { SkPictInfo::kScalarIsFloat_Flag,  SkReadBuffer::kScalarIsFloat_Flag },
+        { SkPictInfo::kPtrIs64Bit_Flag,     SkReadBuffer::kPtrIs64Bit_Flag },
     };
 
     uint32_t rbMask = 0;
     for (size_t i = 0; i < SK_ARRAY_COUNT(gSD); ++i) {
         if (pictInfoFlags & gSD[i].fSrc) {
             rbMask |= gSD[i].fDst;
         }
     }
     return rbMask;
 }
@@ skipping 68 matching lines @@
                 fPictureCount = 0;
                 return false;
             }
         } break;
         case PICT_BUFFER_SIZE_TAG: {
             SkAutoMalloc storage(size);
             if (stream->read(storage.get(), size) != size) {
                 return false;
             }
 
-            SkOrderedReadBuffer buffer(storage.get(), size);
+            SkReadBuffer buffer(storage.get(), size);
             buffer.setFlags(pictInfoFlagsToReadBufferFlags(info.fFlags));
 
             fFactoryPlayback->setupBuffer(buffer);
             fTFPlayback.setupBuffer(buffer);
             buffer.setBitmapDecoder(proc);
 
             while (!buffer.eof()) {
                 tag = buffer.readUInt();
                 size = buffer.readUInt();
                 if (!this->parseBufferTag(buffer, tag, size)) {
                     return false;
                 }
             }
             SkDEBUGCODE(haveBuffer = true;)
         } break;
     }
     return true;    // success
 }
 
-bool SkPicturePlayback::parseBufferTag(SkOrderedReadBuffer& buffer,
+bool SkPicturePlayback::parseBufferTag(SkReadBuffer& buffer,
                                        uint32_t tag, size_t size) {
     switch (tag) {
         case PICT_BITMAP_BUFFER_TAG: {
             fBitmaps = SkTRefArray<SkBitmap>::Create(size);
             for (size_t i = 0; i < size; ++i) {
                 SkBitmap* bm = &fBitmaps->writableAt(i);
                 buffer.readBitmap(bm);
                 bm->setImmutable();
             }
         } break;
@@ skipping 1023 matching lines @@
     for (index = 0; index < fPictureCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "picture%p, ", fPictureRefs[index]);
     if (fPictureCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
     const_cast<SkPicturePlayback*>(this)->dumpStream();
 }
 
 #endif