class SkWriteBuffer {
public:
- SkWriteBuffer();
- SkWriteBuffer(void* initialStorage, size_t storageSize);
- ~SkWriteBuffer();
-
enum Flags {
kCrossProcess_Flag = 1 << 0,
kValidation_Flag = 1 << 1,
};
- void setFlags(uint32_t flags) { fFlags = flags; }
- uint32_t getFlags() const { return fFlags; }
- bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
+ SkWriteBuffer(uint32_t flags = 0);
+ SkWriteBuffer(void* initialStorage, size_t storageSize, uint32_t flags = 0);
+ ~SkWriteBuffer();
+
bool isCrossProcess() const {
return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
}
void setBitmapEncoder(SkPicture::EncodeBitmap bitmapEncoder);
private:
- uint32_t fFlags;
+ bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
+
+ const uint32_t fFlags;
SkFactorySet* fFactorySet;
SkNamedFactorySet* fNamedFactorySet;
SkWriter32 fWriter;
#include "SkWriteBuffer.h"
SkData* SkValidatingSerializeFlattenable(SkFlattenable* flattenable) {
- SkWriteBuffer writer;
- writer.setFlags(SkWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
writer.writeFlattenable(flattenable);
uint32_t size = writer.bytesWritten();
void* data = sk_malloc_throw(size);
///////////////////////////////////////////////////////////////////////////////
-SkFlatController::SkFlatController()
+SkFlatController::SkFlatController(uint32_t writeBufferFlags)
: fBitmapHeap(NULL)
, fTypefaceSet(NULL)
, fTypefacePlayback(NULL)
, fFactorySet(NULL)
-, fWriteBufferFlags(0) {}
+, fWriteBufferFlags(writeBufferFlags) {}
SkFlatController::~SkFlatController() {
SkSafeUnref(fBitmapHeap);
public:
SK_DECLARE_INST_COUNT(SkFlatController)
- SkFlatController();
+ SkFlatController(uint32_t writeBufferFlags = 0);
virtual ~SkFlatController();
/**
* Return a new block of memory for the SkFlatDictionary to use.
*/
SkNamedFactorySet* setNamedFactorySet(SkNamedFactorySet*);
- /**
- * Set the flags to be used during flattening.
- */
- void setWriteBufferFlags(uint32_t flags) { fWriteBufferFlags = flags; }
-
private:
SkBitmapHeap* fBitmapHeap;
SkRefCntSet* fTypefaceSet;
SkTypefacePlayback* fTypefacePlayback;
SkNamedFactorySet* fFactorySet;
- uint32_t fWriteBufferFlags;
+ const uint32_t fWriteBufferFlags;
typedef SkRefCnt INHERITED;
};
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];
- SkWriteBuffer buffer(storage, sizeof(storage));
+ SkWriteBuffer buffer(storage, sizeof(storage), controller->getWriteBufferFlags());
buffer.setBitmapHeap(controller->getBitmapHeap());
buffer.setTypefaceRecorder(controller->getTypefaceSet());
buffer.setNamedFactoryRecorder(controller->getNamedFactorySet());
- buffer.setFlags(controller->getWriteBufferFlags());
Traits::flatten(buffer, obj);
size_t size = buffer.bytesWritten();
public:
explicit SkFlatDictionary(SkFlatController* controller)
: fController(SkRef(controller))
+ , fScratch(controller->getWriteBufferFlags())
, fReady(false) {
this->reset();
}
fScratch.setBitmapHeap(fController->getBitmapHeap());
fScratch.setTypefaceRecorder(fController->getTypefaceSet());
fScratch.setNamedFactoryRecorder(fController->getNamedFactorySet());
- fScratch.setFlags(fController->getWriteBufferFlags());
fReady = true;
}
SkRefCntSet typefaceSet;
SkFactorySet factSet;
- SkWriteBuffer buffer;
- buffer.setFlags(SkWriteBuffer::kCrossProcess_Flag);
+ SkWriteBuffer buffer(SkWriteBuffer::kCrossProcess_Flag);
buffer.setTypefaceRecorder(&typefaceSet);
buffer.setFactoryRecorder(&factSet);
buffer.setBitmapEncoder(encoder);
#include "SkStream.h"
#include "SkTypeface.h"
-SkWriteBuffer::SkWriteBuffer()
- : fFlags(0)
+SkWriteBuffer::SkWriteBuffer(uint32_t flags)
+ : fFlags(flags)
, fFactorySet(NULL)
, fNamedFactorySet(NULL)
, fBitmapHeap(NULL)
, fBitmapEncoder(NULL) {
}
-SkWriteBuffer::SkWriteBuffer(void* storage, size_t storageSize)
- : fFlags(0)
+SkWriteBuffer::SkWriteBuffer(void* storage, size_t storageSize, uint32_t flags)
+ : fFlags(flags)
, fFactorySet(NULL)
, fNamedFactorySet(NULL)
, fWriter(storage, storageSize)
class FlattenableHeap : public SkFlatController {
public:
FlattenableHeap(int numFlatsToKeep, SkNamedFactorySet* fset, bool isCrossProcess)
- : fNumFlatsToKeep(numFlatsToKeep) {
+ : INHERITED(isCrossProcess ? SkWriteBuffer::kCrossProcess_Flag : 0)
+ , fNumFlatsToKeep(numFlatsToKeep) {
SkASSERT((isCrossProcess && fset != NULL) || (!isCrossProcess && NULL == fset));
if (isCrossProcess) {
this->setNamedFactorySet(fset);
- this->setWriteBufferFlags(SkWriteBuffer::kCrossProcess_Flag);
}
}
SkTDArray<int> fFlatsThatMustBeKept;
SkTDArray<void*> fPointers;
const int fNumFlatsToKeep;
+
+ typedef SkFlatController INHERITED;
};
void FlattenableHeap::unalloc(void* ptr) {
template<typename T>
static void TestObjectSerialization(T* testObj, skiatest::Reporter* reporter) {
- SkWriteBuffer writer;
- writer.setFlags(SkWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
SerializationUtils<T>::Write(writer, testObj);
size_t bytesWritten = writer.bytesWritten();
REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
template<typename T>
static T* TestFlattenableSerialization(T* testObj, bool shouldSucceed,
skiatest::Reporter* reporter) {
- SkWriteBuffer writer;
- writer.setFlags(SkWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
SerializationUtils<T>::Write(writer, testObj);
size_t bytesWritten = writer.bytesWritten();
REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
template<typename T>
static void TestArraySerialization(T* data, skiatest::Reporter* reporter) {
- SkWriteBuffer writer;
- writer.setFlags(SkWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
SerializationUtils<T>::Write(writer, data, kArraySize);
size_t bytesWritten = writer.bytesWritten();
// This should write the length (in 4 bytes) and the array