#ifndef SkData_DEFINED
#define SkData_DEFINED
-#include "SkRefCnt.h"
+#include "SkFlattenable.h"
/**
* SkData holds an immutable data buffer. Not only is the data immutable,
* but the actual ptr that is returned (by data() or bytes()) is guaranteed
* to always be the same for the life of this instance.
*/
-class SK_API SkData : public SkRefCnt {
+class SK_API SkData : public SkFlattenable {
public:
SK_DECLARE_INST_COUNT(SkData)
*/
static SkData* NewEmpty();
+ SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkData)
+
+protected:
+ SkData(SkFlattenableReadBuffer&);
+ virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+
private:
ReleaseProc fReleaseProc;
void* fReleaseProcContext;
// access to the destructor.
friend class SkAutoTUnref<SkData>::BlockRef<SkData>;
- typedef SkRefCnt INHERITED;
+ typedef SkFlattenable INHERITED;
};
/**
#ifndef SkDataSet_DEFINED
#define SkDataSet_DEFINED
-#include "SkRefCnt.h"
#include "SkData.h"
+#include "SkFlattenable.h"
class SkStream;
class SkWStream;
-class SkFlattenableReadBuffer;
-class SkFlattenableWriteBuffer;
-class SkDataSet : public SkRefCnt {
+class SkDataSet : public SkFlattenable {
public:
/**
* Returns a new empty dataset. Note: since SkDataSet is immutable, this
* "new" set may be the same one that was returned before, but each
- * returned object must have its reference-count balanced regardles.
+ * returned object must have its reference-count balanced regardless.
*
* SkDataSet* empty = SkDataSet::NewEmpty();
* ...
explicit SkDataSet(SkStream*);
void writeToStream(SkWStream*) const;
- explicit SkDataSet(SkFlattenableReadBuffer&);
- void flatten(SkFlattenableWriteBuffer&) const;
+ SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDataSet)
+
+protected:
+ SkDataSet(SkFlattenableReadBuffer&);
+ virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
private:
int32_t fCount;
uint32_t fKeySize;
Pair* fPairs;
+
+ typedef SkFlattenable INHERITED;
};
#endif
SkAnnotation::SkAnnotation(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
fFlags = buffer.readU32();
- fDataSet = SkNEW_ARGS(SkDataSet, (buffer));
+ fDataSet = (SkDataSet*)buffer.readFlattenable();
}
void SkAnnotation::flatten(SkFlattenableWriteBuffer& buffer) const {
buffer.write32(fFlags);
- fDataSet->flatten(buffer);
+ buffer.writeFlattenable(fDataSet);
}
SK_DEFINE_FLATTENABLE_REGISTRAR(SkAnnotation)
}
///////////////////////////////////////////////////////////////////////////////
+
+void SkData::flatten(SkFlattenableWriteBuffer& buffer) const {
+ buffer.write32(fSize);
+ buffer.writePad(fPtr, fSize);
+}
+
+SkData::SkData(SkFlattenableReadBuffer& buffer) {
+ fSize = buffer.readU32();
+ fReleaseProcContext = NULL;
+
+ if (0 == fSize) {
+ fPtr = NULL;
+ fReleaseProc = NULL;
+ } else {
+ // buffer.read expects a 4-byte aligned size
+ size_t size4 = SkAlign4(fSize);
+ void* data = sk_malloc_throw(size4);
+ buffer.read(data, size4);
+ fPtr = data;
+ fReleaseProc = sk_free_releaseproc;
+ }
+}
+
+SK_DEFINE_FLATTENABLE_REGISTRAR(SkData)
+
+///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#include "SkDataSet.h"
return data;
}
-static SkData* read_data(SkFlattenableReadBuffer& buffer) {
- size_t size = buffer.readU32();
- if (0 == size) {
- return SkData::NewEmpty();
- } else {
- // buffer.read expects a 4-byte aligned size
- size_t size4 = SkAlign4(size);
- void* block = sk_malloc_throw(size4);
- buffer.read(block, size4);
- // we pass the "real" size to NewFromMalloc, since its needs to report
- // the same size that was written.
- return SkData::NewFromMalloc(block, size);
- }
-}
-
-static void write_data(SkFlattenableWriteBuffer& buffer, SkData* data) {
- buffer.write32(data->size());
- buffer.writePad(data->data(), data->size());
-}
-
static SkData* findValue(const char key[], const SkDataSet::Pair array[], int n) {
for (int i = 0; i < n; ++i) {
if (!strcmp(key, array[i].fKey)) {
// our first key points to all the key storage
buffer.writePad(fPairs[0].fKey, fKeySize);
for (int i = 0; i < fCount; ++i) {
- write_data(buffer, fPairs[i].fValue);
+ buffer.writeFlattenable(fPairs[i].fValue);
}
}
}
for (int i = 0; i < fCount; ++i) {
fPairs[i].fKey = keyStorage;
keyStorage += strlen(keyStorage) + 1;
- fPairs[i].fValue = read_data(buffer);
+ fPairs[i].fValue = (SkData*)buffer.readFlattenable();
}
} else {
fKeySize = 0;
return gEmptySet;
}
+SK_DEFINE_FLATTENABLE_REGISTRAR(SkDataSet)