Refactor read and write buffers.

src/core/SkPictureFlat.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPictureFlat_DEFINED
 #define SkPictureFlat_DEFINED
 
 //#define SK_DEBUG_SIZE
 
 #include "SkBitmapHeap.h"
 #include "SkChecksum.h"
 #include "SkChunkAlloc.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkPtrRecorder.h"
 #include "SkTDynamicHash.h"
 #include "SkTRefArray.h"
 
 enum DrawType {
     UNUSED,
     CLIP_PATH,
     CLIP_REGION,
@@ skipping 72 matching lines @@
     SkTypefacePlayback();
     virtual ~SkTypefacePlayback();
 
     int count() const { return fCount; }
 
     void reset(const SkRefCntSet*);
 
     void setCount(int count);
     SkRefCnt* set(int index, SkRefCnt*);
 
-    void setupBuffer(SkOrderedReadBuffer& buffer) const {
+    void setupBuffer(SkReadBuffer& buffer) const {
         buffer.setTypefaceArray((SkTypeface**)fArray, fCount);
     }
 
 protected:
     int fCount;
     SkRefCnt** fArray;
 };
 
 class SkFactoryPlayback {
 public:
     SkFactoryPlayback(int count) : fCount(count) {
         fArray = SkNEW_ARRAY(SkFlattenable::Factory, count);
     }
 
     ~SkFactoryPlayback() {
         SkDELETE_ARRAY(fArray);
     }
 
     SkFlattenable::Factory* base() const { return fArray; }
 
-    void setupBuffer(SkOrderedReadBuffer& buffer) const {
+    void setupBuffer(SkReadBuffer& buffer) const {
         buffer.setFactoryPlayback(fArray, fCount);
     }
 
 private:
     int fCount;
     SkFlattenable::Factory* fArray;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 //
@@ skipping 115 matching lines @@
     typedef SkRefCnt INHERITED;
 };
 
 class SkFlatData {
 public:
     // Flatten obj into an SkFlatData with this index.  controller owns the SkFlatData*.
     template <typename Traits, typename T>
     static SkFlatData* Create(SkFlatController* controller, const T& obj, int index) {
         // A buffer of 256 bytes should fit most paints, regions, and matrices.
         uint32_t storage[64];
-        SkOrderedWriteBuffer buffer(storage, sizeof(storage));
+        SkWriteBuffer buffer(storage, sizeof(storage));
 
         buffer.setBitmapHeap(controller->getBitmapHeap());
         buffer.setTypefaceRecorder(controller->getTypefaceSet());
         buffer.setNamedFactoryRecorder(controller->getNamedFactorySet());
         buffer.setFlags(controller->getWriteBufferFlags());
 
         Traits::flatten(buffer, obj);
-        size_t size = buffer.size();
+        size_t size = buffer.bytesWritten();
         SkASSERT(SkIsAlign4(size));
 
         // Allocate enough memory to hold SkFlatData struct and the flat data itself.
         size_t allocSize = sizeof(SkFlatData) + size;
         SkFlatData* result = (SkFlatData*) controller->allocThrow(allocSize);
 
         // Put the serialized contents into the data section of the new allocation.
         buffer.writeToMemory(result->data());
         // Stamp the index, size and checksum in the header.
         result->stampHeader(index, SkToS32(size));
         return result;
     }
 
     // Unflatten this into result, using bitmapHeap and facePlayback for bitmaps and fonts if given
     template <typename Traits, typename T>
     void unflatten(T* result,
                    SkBitmapHeap* bitmapHeap = NULL,
                    SkTypefacePlayback* facePlayback = NULL) const {
-        SkOrderedReadBuffer buffer(this->data(), fFlatSize);
+        SkReadBuffer buffer(this->data(), fFlatSize);
 
         if (bitmapHeap) {
             buffer.setBitmapStorage(bitmapHeap);
         }
         if (facePlayback) {
             facePlayback->setupBuffer(buffer);
         }
 
         Traits::unflatten(buffer, result);
         SkASSERT(fFlatSize == (int32_t)buffer.offset());
@@ skipping 244 matching lines @@
     }
 
     void unflatten(T* dst, const SkFlatData* element) const {
         element->unflatten<Traits>(dst,
                                    fController->getBitmapHeap(),
                                    fController->getTypefacePlayback());
     }
 
     // All SkFlatData* stored in fIndexedData and fHash are owned by the controller.
     SkAutoTUnref<SkFlatController> fController;
-    SkOrderedWriteBuffer fScratch;
+    SkWriteBuffer fScratch;
     bool fReady;
 
     // For index -> SkFlatData.  0-based, while all indices in the API are 1-based.  Careful!
     SkTDArray<const SkFlatData*> fIndexedData;
 
     // For SkFlatData -> cached SkFlatData, which has index().
     SkTDynamicHash<SkFlatData, SkFlatData,
                    SkFlatData::Identity, SkFlatData::Hash, SkFlatData::Equal> fHash;
 };
 
 struct SkPaintTraits {
-    static void flatten(SkOrderedWriteBuffer& buffer, const SkPaint& paint) {
+    static void flatten(SkWriteBuffer& buffer, const SkPaint& paint) {
         paint.flatten(buffer);
     }
-    static void unflatten(SkOrderedReadBuffer& buffer, SkPaint* paint) {
+    static void unflatten(SkReadBuffer& buffer, SkPaint* paint) {
         paint->unflatten(buffer);
     }
 };
 typedef SkFlatDictionary<SkPaint, SkPaintTraits> SkPaintDictionary;
 
 class SkChunkFlatController : public SkFlatController {
 public:
     SkChunkFlatController(size_t minSize)
     : fHeap(minSize)
     , fTypefaceSet(SkNEW(SkRefCntSet))
@@ skipping 22 matching lines @@
     }
 
 private:
     SkChunkAlloc               fHeap;
     SkAutoTUnref<SkRefCntSet>  fTypefaceSet;
     void*                      fLastAllocated;
     mutable SkTypefacePlayback fTypefacePlayback;
 };
 
 #endif