Refactor read and write buffers.
Eliminates SkFlattenable{Read,Write}Buffer, promoting SkOrdered{Read,Write}Buffer
a step each in the hierarchy.
What used to be this:
SkFlattenableWriteBuffer -> SkOrderedWriteBuffer
SkFlattenableReadBuffer -> SkOrderedReadBuffer
SkFlattenableReadBuffer -> SkValidatingReadBuffer
is now
SkWriteBuffer
SkReadBuffer -> SkValidatingReadBuffer
Benefits:
- code is simpler, names are less wordy
- the generic SkFlattenableFooBuffer code in SkPaint was incorrect; removed
- write buffers are completely devirtualized, important for record speed
This refactoring was mostly mechanical. You aren't going to find anything
interesting in files with less than 10 lines changed.
BUG=skia:
R=reed@google.com, scroggo@google.com, djsollen@google.com, mtklein@google.com
Author: mtklein@chromium.org
Review URL: https://codereview.chromium.org/134163010
git-svn-id: http://skia.googlecode.com/svn/trunk@13245 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index 528dd19..109be6a 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -27,7 +27,7 @@
return false;
}
- FailImageFilter(SkFlattenableReadBuffer& buffer)
+ FailImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {}
private:
@@ -51,7 +51,7 @@
return true;
}
- IdentityImageFilter(SkFlattenableReadBuffer& buffer)
+ IdentityImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {}
private:
diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp
index f5eaa28..40b673c 100644
--- a/gm/imagefiltersgraph.cpp
+++ b/gm/imagefiltersgraph.cpp
@@ -13,7 +13,8 @@
#include "SkColorFilter.h"
#include "SkColorFilterImageFilter.h"
#include "SkColorMatrixFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMergeImageFilter.h"
#include "SkMorphologyImageFilter.h"
#include "SkOnce.h"
@@ -57,13 +58,13 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SimpleOffsetFilter);
protected:
- explicit SimpleOffsetFilter(SkFlattenableReadBuffer& buffer)
+ explicit SimpleOffsetFilter(SkReadBuffer& buffer)
: SkImageFilter(1, buffer) {
fDX = buffer.readScalar();
fDY = buffer.readScalar();
}
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
this->SkImageFilter::flatten(buffer);
buffer.writeScalar(fDX);
buffer.writeScalar(fDY);
diff --git a/gm/texteffects.cpp b/gm/texteffects.cpp
index 7964de9..094fe7b 100644
--- a/gm/texteffects.cpp
+++ b/gm/texteffects.cpp
@@ -8,7 +8,8 @@
#include "gm.h"
#include "SkBlurMask.h"
#include "SkBlurMaskFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkLayerRasterizer.h"
static void r0(SkLayerRasterizer* rast, SkPaint& p) {
diff --git a/gyp/core.gypi b/gyp/core.gypi
index 55447fe..fcd5e39 100644
--- a/gyp/core.gypi
+++ b/gyp/core.gypi
@@ -84,7 +84,6 @@
'<(skia_src_path)/core/SkFilterProc.h',
'<(skia_src_path)/core/SkFilterShader.cpp',
'<(skia_src_path)/core/SkFlattenable.cpp',
- '<(skia_src_path)/core/SkFlattenableBuffers.cpp',
'<(skia_src_path)/core/SkFlattenableSerialization.cpp',
'<(skia_src_path)/core/SkFloat.cpp',
'<(skia_src_path)/core/SkFloat.h',
@@ -114,8 +113,8 @@
'<(skia_src_path)/core/SkMessageBus.h',
'<(skia_src_path)/core/SkMetaData.cpp',
'<(skia_src_path)/core/SkMipMap.cpp',
- '<(skia_src_path)/core/SkOrderedReadBuffer.cpp',
- '<(skia_src_path)/core/SkOrderedWriteBuffer.cpp',
+ '<(skia_src_path)/core/SkReadBuffer.cpp',
+ '<(skia_src_path)/core/SkWriteBuffer.cpp',
'<(skia_src_path)/core/SkPackBits.cpp',
'<(skia_src_path)/core/SkPaint.cpp',
'<(skia_src_path)/core/SkPaintOptionsAndroid.cpp',
diff --git a/include/core/SkAnnotation.h b/include/core/SkAnnotation.h
index 4d17b79..872bb94 100644
--- a/include/core/SkAnnotation.h
+++ b/include/core/SkAnnotation.h
@@ -12,8 +12,8 @@
#include "SkString.h"
class SkData;
-class SkFlattenableReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkReadBuffer;
+class SkWriteBuffer;
class SkStream;
class SkWStream;
struct SkPoint;
@@ -32,8 +32,8 @@
*/
SkData* find(const char key[]) const;
- SkAnnotation(SkFlattenableReadBuffer&);
- void writeToBuffer(SkFlattenableWriteBuffer&) const;
+ SkAnnotation(SkReadBuffer&);
+ void writeToBuffer(SkWriteBuffer&) const;
private:
SkString fKey;
diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index 2cdac27..4951cf1 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -658,8 +658,8 @@
buffers as they can optimize the recording process and avoid recording
duplicate bitmaps and pixelRefs.
*/
- void flatten(SkFlattenableWriteBuffer&) const;
- void unflatten(SkFlattenableReadBuffer&);
+ void flatten(SkWriteBuffer&) const;
+ void unflatten(SkReadBuffer&);
SkDEBUGCODE(void validate() const;)
diff --git a/include/core/SkColorFilter.h b/include/core/SkColorFilter.h
index 106e5bb..a5ffca8 100644
--- a/include/core/SkColorFilter.h
+++ b/include/core/SkColorFilter.h
@@ -135,7 +135,7 @@
protected:
SkColorFilter() {}
- SkColorFilter(SkFlattenableReadBuffer& rb) : INHERITED(rb) {}
+ SkColorFilter(SkReadBuffer& rb) : INHERITED(rb) {}
private:
typedef SkFlattenable INHERITED;
diff --git a/include/core/SkColorShader.h b/include/core/SkColorShader.h
index c379068..5b8a86d 100644
--- a/include/core/SkColorShader.h
+++ b/include/core/SkColorShader.h
@@ -52,8 +52,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorShader)
protected:
- SkColorShader(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkColorShader(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
diff --git a/include/core/SkColorTable.h b/include/core/SkColorTable.h
index 52300fc..e4c8c86 100644
--- a/include/core/SkColorTable.h
+++ b/include/core/SkColorTable.h
@@ -75,8 +75,8 @@
SkDEBUGCODE(f16BitCacheLockCount -= 1);
}
- explicit SkColorTable(SkFlattenableReadBuffer&);
- void writeToBuffer(SkFlattenableWriteBuffer&) const;
+ explicit SkColorTable(SkReadBuffer&);
+ void writeToBuffer(SkWriteBuffer&) const;
private:
SkPMColor* fColors;
diff --git a/include/core/SkComposeShader.h b/include/core/SkComposeShader.h
index 524161b..1fefd13 100644
--- a/include/core/SkComposeShader.h
+++ b/include/core/SkComposeShader.h
@@ -43,8 +43,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposeShader)
protected:
- SkComposeShader(SkFlattenableReadBuffer& );
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkComposeShader(SkReadBuffer& );
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
diff --git a/include/core/SkDrawLooper.h b/include/core/SkDrawLooper.h
index d6028ff..4609c1d 100644
--- a/include/core/SkDrawLooper.h
+++ b/include/core/SkDrawLooper.h
@@ -68,7 +68,7 @@
protected:
SkDrawLooper() {}
- SkDrawLooper(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkDrawLooper(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
typedef SkFlattenable INHERITED;
diff --git a/include/core/SkEmptyShader.h b/include/core/SkEmptyShader.h
index 08c131d..3f7dae4 100644
--- a/include/core/SkEmptyShader.h
+++ b/include/core/SkEmptyShader.h
@@ -34,7 +34,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmptyShader)
protected:
- SkEmptyShader(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkEmptyShader(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
typedef SkShader INHERITED;
diff --git a/include/core/SkFlattenable.h b/include/core/SkFlattenable.h
index 5a6e2ae..ee7a433 100644
--- a/include/core/SkFlattenable.h
+++ b/include/core/SkFlattenable.h
@@ -12,8 +12,8 @@
#include "SkRefCnt.h"
-class SkFlattenableReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkReadBuffer;
+class SkWriteBuffer;
#define SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(flattenable) \
SkFlattenable::Registrar(#flattenable, flattenable::CreateProc, \
@@ -32,7 +32,7 @@
#define SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(flattenable) \
virtual Factory getFactory() const SK_OVERRIDE { return CreateProc; } \
- static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { \
+ static SkFlattenable* CreateProc(SkReadBuffer& buffer) { \
return SkNEW_ARGS(flattenable, (buffer)); \
}
@@ -67,7 +67,7 @@
SK_DECLARE_INST_COUNT(SkFlattenable)
- typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
+ typedef SkFlattenable* (*Factory)(SkReadBuffer&);
SkFlattenable() {}
@@ -94,19 +94,19 @@
}
};
-protected:
- SkFlattenable(SkFlattenableReadBuffer&) {}
/** Override this to write data specific to your subclass into the buffer,
being sure to call your super-class' version first. This data will later
be passed to your Factory function, returned by getFactory().
*/
- virtual void flatten(SkFlattenableWriteBuffer&) const;
+ virtual void flatten(SkWriteBuffer&) const;
+
+protected:
+ SkFlattenable(SkReadBuffer&) {}
private:
static void InitializeFlattenablesIfNeeded();
friend class SkGraphics;
- friend class SkFlattenableWriteBuffer;
typedef SkRefCnt INHERITED;
};
diff --git a/include/core/SkFlattenableBuffers.h b/include/core/SkFlattenableBuffers.h
index aa61f21..3e5d5b9 100644
--- a/include/core/SkFlattenableBuffers.h
+++ b/include/core/SkFlattenableBuffers.h
@@ -1,260 +1,10 @@
-
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
+// Temporary shim to keep a couple dependencies working in Chromium.
#ifndef SkFlattenableBuffers_DEFINED
#define SkFlattenableBuffers_DEFINED
-#include "SkColor.h"
-#include "SkData.h"
-#include "SkPaint.h"
-#include "SkPoint.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
-class SkBitmap;
-class SkDrawLooper;
-class SkFlattenable;
-struct SkIRect;
-class SkMatrix;
-class SkOrderedReadBuffer;
-class SkOrderedWriteBuffer;
-class SkPath;
-class SkPixelRef;
-struct SkRect;
-class SkRegion;
-class SkStream;
-class SkString;
-class SkTypeface;
-class SkUnitMapper;
-class SkWStream;
+typedef SkReadBuffer SkFlattenableReadBuffer;
-class SkFlattenableReadBuffer {
-public:
- SkFlattenableReadBuffer();
- virtual ~SkFlattenableReadBuffer();
-
- bool isOrderedBinaryBuffer() { return NULL != getOrderedBinaryBuffer(); }
- virtual SkOrderedReadBuffer* getOrderedBinaryBuffer() { return NULL; }
-
- enum Flags {
- kCrossProcess_Flag = 1 << 0,
- kScalarIsFloat_Flag = 1 << 1,
- kPtrIs64Bit_Flag = 1 << 2,
- /** The kValidation_Flag is used to force stream validations (by making
- * sure that no operation reads past the end of the stream, for example)
- * and error handling if any reading operation yields an invalid value.
- */
- kValidation_Flag = 1 << 3,
- };
-
- void setFlags(uint32_t flags) { fFlags = flags; }
- uint32_t getFlags() const { return fFlags; }
-
- bool isCrossProcess() const { return SkToBool(fFlags & (kCrossProcess_Flag | kValidation_Flag)); }
- bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); }
- bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); }
- bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
-
- // primitives
- virtual bool readBool() = 0;
- virtual SkColor readColor() = 0;
- virtual SkFixed readFixed() = 0;
- virtual int32_t readInt() = 0;
- virtual SkScalar readScalar() = 0;
- virtual uint32_t readUInt() = 0;
- virtual int32_t read32() = 0;
-
- // strings -- the caller is responsible for freeing the string contents
- virtual void readString(SkString* string) = 0;
- virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding) = 0;
-
- /**
- @param type This parameter is only used when using SkValidatingReadBuffer. It will verify
- that the object about to be deserialized is of the given type or early return
- NULL otherwise. The type provided here is the type of the base class of the
- object to deserialize.
- */
- virtual SkFlattenable* readFlattenable(SkFlattenable::Type type) = 0;
-
- SkColorFilter* readColorFilter();
- SkDrawLooper* readDrawLooper();
- SkImageFilter* readImageFilter();
- SkMaskFilter* readMaskFilter();
- SkPathEffect* readPathEffect();
- SkPixelRef* readPixelRef();
- SkRasterizer* readRasterizer();
- SkShader* readShader();
- SkUnitMapper* readUnitMapper();
- SkXfermode* readXfermode();
-
- // common data structures
- virtual void readPoint(SkPoint* point) = 0;
- virtual void readMatrix(SkMatrix* matrix) = 0;
- virtual void readIRect(SkIRect* rect) = 0;
- virtual void readRect(SkRect* rect) = 0;
- virtual void readRegion(SkRegion* region) = 0;
- virtual void readPath(SkPath* path) = 0;
-
- // binary data and arrays
-
- /**
- * In the following read.*Array(...) functions, the size parameter specifies the allocation
- * size in number of elements (or in bytes, for void*) of the pointer parameter. If the
- * pointer parameter's size does not match the size to be read, the pointer parameter's memory
- * will then stay uninitialized, the cursor will be moved to the end of the stream and, in the
- * case where isValidating() is true, an error flag will be set internally (see
- * SkValidatingReadBuffer).
- * If the sizes match, then "size" amount of memory will be read.
- *
- * @param size amount of memory expected to be read
- * @return true if the size parameter matches the size to be read, false otherwise
- */
- virtual bool readByteArray(void* value, size_t size) = 0;
- virtual bool readColorArray(SkColor* colors, size_t size) = 0;
- virtual bool readIntArray(int32_t* values, size_t size) = 0;
- virtual bool readPointArray(SkPoint* points, size_t size) = 0;
- virtual bool readScalarArray(SkScalar* values, size_t size) = 0;
-
- /** This helper peeks into the buffer and reports back the length of the next array in
- * the buffer but does not change the state of the buffer.
- */
- virtual uint32_t getArrayCount() = 0;
-
- // helper functions
- virtual void* readFunctionPtr();
- virtual void readPaint(SkPaint* paint);
-
- virtual void readBitmap(SkBitmap* bitmap) = 0;
- virtual SkTypeface* readTypeface() = 0;
-
- // helper function for classes with const SkPoint members
- SkPoint readPoint() {
- SkPoint point;
- this->readPoint(&point);
- return point;
- }
-
- SkData* readByteArrayAsData() {
- size_t len = this->getArrayCount();
- void* buffer = NULL;
- if (this->validateAvailable(len)) {
- buffer = sk_malloc_throw(len);
- (void)this->readByteArray(buffer, len);
- } else {
- len = 0;
- }
- return SkData::NewFromMalloc(buffer, len);
- }
-
- /** This function validates that the isValid input parameter is true
- * If isValidating() is false, then true is always returned
- * If isValidating() is true, then true is returned until validate() is called with isValid
- * set to false. When isValid is false, an error flag will be set internally and, from that
- * point on, validate() will return false. The error flag cannot be unset.
- *
- * @param isValid result of a test that is expected to be true
- */
- virtual bool validate(bool isValid);
-
- /** This function returns true by default
- * If isValidating() is true, it will return false if the internal error flag is set.
- * Otherwise, it will return true.
- */
- virtual bool isValid() const { return true; }
-
- /** This function returns true by default
- * If isValidating() is true, it will return whether there's
- * at least "size" memory left to read in the stream.
- *
- * @param size amount of memory that should still be available
- */
- virtual bool validateAvailable(size_t size) { return true; }
-
-private:
- template <typename T> T* readFlattenableT();
- uint32_t fFlags;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-class SkFlattenableWriteBuffer {
-public:
- SkFlattenableWriteBuffer();
- virtual ~SkFlattenableWriteBuffer();
-
- virtual bool isOrderedBinaryBuffer() { return false; }
- virtual SkOrderedWriteBuffer* getOrderedBinaryBuffer() { sk_throw(); return NULL; }
-
- // primitives
- virtual void writeByteArray(const void* data, size_t size) = 0;
- virtual void writeBool(bool value) = 0;
- virtual void writeFixed(SkFixed value) = 0;
- virtual void writeScalar(SkScalar value) = 0;
- virtual void writeScalarArray(const SkScalar* value, uint32_t count) = 0;
- virtual void writeInt(int32_t value) = 0;
- virtual void writeIntArray(const int32_t* value, uint32_t count) = 0;
- virtual void writeUInt(uint32_t value) = 0;
- virtual void write32(int32_t value) = 0; // printf in hex
- virtual void writeString(const char* value) = 0;
- virtual void writeEncodedString(const void* value, size_t byteLength,
- SkPaint::TextEncoding encoding) = 0;
-
- // common data structures
- virtual void writeFlattenable(const SkFlattenable* flattenable) = 0;
- virtual void writeColor(const SkColor& color) = 0;
- virtual void writeColorArray(const SkColor* color, uint32_t count) = 0;
- virtual void writePoint(const SkPoint& point) = 0;
- virtual void writePointArray(const SkPoint* points, uint32_t count) = 0;
- virtual void writeMatrix(const SkMatrix& matrix) = 0;
- virtual void writeIRect(const SkIRect& rect) = 0;
- virtual void writeRect(const SkRect& rect) = 0;
- virtual void writeRegion(const SkRegion& region) = 0;
- virtual void writePath(const SkPath& path) = 0;
- virtual size_t writeStream(SkStream* stream, size_t length) = 0;
-
- // helper functions
- virtual void writeFunctionPtr(void* ptr);
- virtual void writePaint(const SkPaint& paint);
-
- virtual void writeBitmap(const SkBitmap& bitmap) = 0;
- virtual void writeTypeface(SkTypeface* typeface) = 0;
-
- virtual bool writeToStream(SkWStream*) = 0;
-
- enum Flags {
- kCrossProcess_Flag = 0x01,
- /** The kValidation_Flag is used here to make sure the write operation
- * is symmetric with the read operation using the equivalent flag
- * SkFlattenableReadBuffer::kValidation_Flag.
- */
- kValidation_Flag = 0x02,
- };
-
- uint32_t getFlags() const { return fFlags; }
- void setFlags(uint32_t flags) { fFlags = flags; }
-
- bool isCrossProcess() const {
- return SkToBool(fFlags & (kCrossProcess_Flag | kValidation_Flag));
- }
-
- bool isValidating() const {
- return SkToBool(fFlags & kValidation_Flag);
- }
-
- bool persistTypeface() const { return (fFlags & kCrossProcess_Flag) != 0; }
-
- void writeDataAsByteArray(SkData* data) {
- this->writeByteArray(data->data(), data->size());
- }
-
-protected:
- // A helper function so that each subclass does not have to be a friend of SkFlattenable
- void flattenObject(const SkFlattenable* obj, SkFlattenableWriteBuffer& buffer);
-
- uint32_t fFlags;
-};
-
-#endif
+#endif//SkFlattenableBuffers_DEFINED
diff --git a/include/core/SkImageFilter.h b/include/core/SkImageFilter.h
index 25d3bac..37993c0 100644
--- a/include/core/SkImageFilter.h
+++ b/include/core/SkImageFilter.h
@@ -160,15 +160,15 @@
virtual ~SkImageFilter();
/**
- * Constructs a new SkImageFilter read from an SkFlattenableReadBuffer object.
+ * Constructs a new SkImageFilter read from an SkReadBuffer object.
*
* @param inputCount The exact number of inputs expected for this SkImageFilter object.
* -1 can be used if the filter accepts any number of inputs.
- * @param rb SkFlattenableReadBuffer object from which the SkImageFilter is read.
+ * @param rb SkReadBuffer object from which the SkImageFilter is read.
*/
- explicit SkImageFilter(int inputCount, SkFlattenableReadBuffer& rb);
+ explicit SkImageFilter(int inputCount, SkReadBuffer& rb);
- virtual void flatten(SkFlattenableWriteBuffer& wb) const SK_OVERRIDE;
+ virtual void flatten(SkWriteBuffer& wb) const SK_OVERRIDE;
/**
* This is the virtual which should be overridden by the derived class
diff --git a/include/core/SkImageInfo.h b/include/core/SkImageInfo.h
index d389d5e..722ff27 100644
--- a/include/core/SkImageInfo.h
+++ b/include/core/SkImageInfo.h
@@ -11,8 +11,8 @@
#include "SkTypes.h"
#include "SkSize.h"
-class SkFlattenableWriteBuffer;
-class SkFlattenableReadBuffer;
+class SkWriteBuffer;
+class SkReadBuffer;
/**
* Describes how to interpret the alpha compoent of a pixel.
@@ -178,8 +178,8 @@
return 0 != memcmp(this, &other, sizeof(other));
}
- void unflatten(SkFlattenableReadBuffer&);
- void flatten(SkFlattenableWriteBuffer&) const;
+ void unflatten(SkReadBuffer&);
+ void flatten(SkWriteBuffer&) const;
size_t getSafeSize(size_t rowBytes) const {
if (0 == fHeight) {
diff --git a/include/core/SkMallocPixelRef.h b/include/core/SkMallocPixelRef.h
index 4607fa2..f6a57b3 100644
--- a/include/core/SkMallocPixelRef.h
+++ b/include/core/SkMallocPixelRef.h
@@ -91,12 +91,12 @@
// The ownPixels version of this constructor is deprecated.
SkMallocPixelRef(const SkImageInfo&, void* addr, size_t rb, SkColorTable*,
bool ownPixels);
- SkMallocPixelRef(SkFlattenableReadBuffer& buffer);
+ SkMallocPixelRef(SkReadBuffer& buffer);
virtual ~SkMallocPixelRef();
virtual bool onNewLockPixels(LockRec*) SK_OVERRIDE;
virtual void onUnlockPixels() SK_OVERRIDE;
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual size_t getAllocatedSizeInBytes() const SK_OVERRIDE;
private:
diff --git a/include/core/SkMaskFilter.h b/include/core/SkMaskFilter.h
index 20dc379..b47e034 100644
--- a/include/core/SkMaskFilter.h
+++ b/include/core/SkMaskFilter.h
@@ -137,7 +137,7 @@
protected:
// empty for now, but lets get our subclass to remember to init us for the future
- SkMaskFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkMaskFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
enum FilterReturn {
kFalse_FilterReturn,
diff --git a/include/core/SkPaint.h b/include/core/SkPaint.h
index 00ec29e..abb8599 100644
--- a/include/core/SkPaint.h
+++ b/include/core/SkPaint.h
@@ -24,8 +24,8 @@
class SkColorFilter;
class SkDescriptor;
struct SkDeviceProperties;
-class SkFlattenableReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkReadBuffer;
+class SkWriteBuffer;
struct SkGlyph;
struct SkRect;
class SkGlyphCache;
@@ -72,8 +72,8 @@
return !(a == b);
}
- void flatten(SkFlattenableWriteBuffer&) const;
- void unflatten(SkFlattenableReadBuffer&);
+ void flatten(SkWriteBuffer&) const;
+ void unflatten(SkReadBuffer&);
/** Restores the paint to its initial settings.
*/
diff --git a/include/core/SkPaintOptionsAndroid.h b/include/core/SkPaintOptionsAndroid.h
index f49345f..ab84ec0 100644
--- a/include/core/SkPaintOptionsAndroid.h
+++ b/include/core/SkPaintOptionsAndroid.h
@@ -13,8 +13,8 @@
#include "SkTypes.h"
#include "SkString.h"
-class SkFlattenableReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkReadBuffer;
+class SkWriteBuffer;
/** \class SkLanguage
@@ -80,8 +80,8 @@
fUseFontFallbacks != b.fUseFontFallbacks;
}
- void flatten(SkFlattenableWriteBuffer&) const;
- void unflatten(SkFlattenableReadBuffer&);
+ void flatten(SkWriteBuffer&) const;
+ void unflatten(SkReadBuffer&);
/** Return the paint's language value used for drawing text.
@return the paint's language value used for drawing text.
diff --git a/include/core/SkPathEffect.h b/include/core/SkPathEffect.h
index ed6d93b..3f38f3a 100644
--- a/include/core/SkPathEffect.h
+++ b/include/core/SkPathEffect.h
@@ -109,7 +109,7 @@
SK_DEFINE_FLATTENABLE_TYPE(SkPathEffect)
protected:
- SkPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
// illegal
@@ -131,8 +131,8 @@
virtual ~SkPairPathEffect();
protected:
- SkPairPathEffect(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkPairPathEffect(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// these are visible to our subclasses
SkPathEffect* fPE0, *fPE1;
@@ -162,7 +162,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposePathEffect)
protected:
- SkComposePathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkComposePathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
// illegal
@@ -193,7 +193,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSumPathEffect)
protected:
- SkSumPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkSumPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
// illegal
diff --git a/include/core/SkPicture.h b/include/core/SkPicture.h
index d63b66b..82d6835 100644
--- a/include/core/SkPicture.h
+++ b/include/core/SkPicture.h
@@ -169,8 +169,8 @@
/**
* Function to encode an SkBitmap to an SkData. A function with this
- * signature can be passed to serialize() and SkOrderedWriteBuffer.
- * Returning NULL will tell the SkOrderedWriteBuffer to use
+ * signature can be passed to serialize() and SkWriteBuffer.
+ * Returning NULL will tell the SkWriteBuffer to use
* SkBitmap::flatten() to store the bitmap.
*
* @param pixelRefOffset DEPRECATED -- caller assumes it will return 0.
diff --git a/include/core/SkPixelRef.h b/include/core/SkPixelRef.h
index 5a9a5a0..439a4ca 100644
--- a/include/core/SkPixelRef.h
+++ b/include/core/SkPixelRef.h
@@ -328,8 +328,8 @@
SkBaseMutex* mutex() const { return fMutex; }
// serialization
- SkPixelRef(SkFlattenableReadBuffer&, SkBaseMutex*);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkPixelRef(SkReadBuffer&, SkBaseMutex*);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// only call from constructor. Flags this to always be locked, removing
// the need to grab the mutex and call onLockPixels/onUnlockPixels.
diff --git a/include/core/SkRasterizer.h b/include/core/SkRasterizer.h
index 6e6224e..d916b23 100644
--- a/include/core/SkRasterizer.h
+++ b/include/core/SkRasterizer.h
@@ -33,7 +33,7 @@
SK_DEFINE_FLATTENABLE_TYPE(SkRasterizer)
protected:
- SkRasterizer(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkRasterizer(SkReadBuffer& buffer) : INHERITED(buffer) {}
virtual bool onRasterize(const SkPath& path, const SkMatrix& matrix,
const SkIRect* clipBounds,
diff --git a/include/core/SkReadBuffer.h b/include/core/SkReadBuffer.h
new file mode 100644
index 0000000..75cc64b
--- /dev/null
+++ b/include/core/SkReadBuffer.h
@@ -0,0 +1,205 @@
+
+/*
+ * 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 SkReadBuffer_DEFINED
+#define SkReadBuffer_DEFINED
+
+#include "SkBitmapHeap.h"
+#include "SkColorFilter.h"
+#include "SkData.h"
+#include "SkDrawLooper.h"
+#include "SkImageFilter.h"
+#include "SkMaskFilter.h"
+#include "SkPath.h"
+#include "SkPathEffect.h"
+#include "SkPicture.h"
+#include "SkPixelRef.h"
+#include "SkRasterizer.h"
+#include "SkReadBuffer.h"
+#include "SkReader32.h"
+#include "SkRefCnt.h"
+#include "SkShader.h"
+#include "SkUnitMapper.h"
+#include "SkWriteBuffer.h"
+#include "SkXfermode.h"
+
+class SkBitmap;
+
+#if defined(SK_DEBUG) && defined(SK_BUILD_FOR_MAC)
+ #define DEBUG_NON_DETERMINISTIC_ASSERT
+#endif
+
+class SkReadBuffer {
+public:
+ SkReadBuffer();
+ SkReadBuffer(const void* data, size_t size);
+ SkReadBuffer(SkStream* stream);
+ virtual ~SkReadBuffer();
+
+ enum Flags {
+ kCrossProcess_Flag = 1 << 0,
+ kScalarIsFloat_Flag = 1 << 1,
+ kPtrIs64Bit_Flag = 1 << 2,
+ kValidation_Flag = 1 << 3,
+ };
+
+ void setFlags(uint32_t flags) { fFlags = flags; }
+ uint32_t getFlags() const { return fFlags; }
+
+ bool isCrossProcess() const {
+ return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
+ }
+ bool isScalarFloat() const { return SkToBool(fFlags & kScalarIsFloat_Flag); }
+ bool isPtr64Bit() const { return SkToBool(fFlags & kPtrIs64Bit_Flag); }
+ bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
+
+ SkReader32* getReader32() { return &fReader; }
+
+ uint32_t size() { return fReader.size(); }
+ uint32_t offset() { return fReader.offset(); }
+ bool eof() { return fReader.eof(); }
+ const void* skip(size_t size) { return fReader.skip(size); }
+
+ // primitives
+ virtual bool readBool();
+ virtual SkColor readColor();
+ virtual SkFixed readFixed();
+ virtual int32_t readInt();
+ virtual SkScalar readScalar();
+ virtual uint32_t readUInt();
+ virtual int32_t read32();
+
+ void* readFunctionPtr() {
+ void* ptr;
+ this->readByteArray(&ptr, sizeof(ptr));
+ return ptr;
+ }
+
+ // strings -- the caller is responsible for freeing the string contents
+ virtual void readString(SkString* string);
+ virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding);
+
+ // common data structures
+ virtual void readPoint(SkPoint* point);
+ SkPoint readPoint() { SkPoint p; this->readPoint(&p); return p; }
+ virtual void readMatrix(SkMatrix* matrix);
+ virtual void readIRect(SkIRect* rect);
+ virtual void readRect(SkRect* rect);
+ virtual void readRegion(SkRegion* region);
+ virtual void readPath(SkPath* path);
+ void readPaint(SkPaint* paint) { paint->unflatten(*this); }
+
+ virtual SkFlattenable* readFlattenable(SkFlattenable::Type);
+ template <typename T> T* readFlattenable() {
+ return (T*) this->readFlattenable(T::GetFlattenableType());
+ }
+ SkColorFilter* readColorFilter() { return this->readFlattenable<SkColorFilter>(); }
+ SkDrawLooper* readDrawLooper() { return this->readFlattenable<SkDrawLooper>(); }
+ SkImageFilter* readImageFilter() { return this->readFlattenable<SkImageFilter>(); }
+ SkMaskFilter* readMaskFilter() { return this->readFlattenable<SkMaskFilter>(); }
+ SkPathEffect* readPathEffect() { return this->readFlattenable<SkPathEffect>(); }
+ SkPixelRef* readPixelRef() { return this->readFlattenable<SkPixelRef>(); }
+ SkRasterizer* readRasterizer() { return this->readFlattenable<SkRasterizer>(); }
+ SkShader* readShader() { return this->readFlattenable<SkShader>(); }
+ SkUnitMapper* readUnitMapper() { return this->readFlattenable<SkUnitMapper>(); }
+ SkXfermode* readXfermode() { return this->readFlattenable<SkXfermode>(); }
+
+
+ // binary data and arrays
+ virtual bool readByteArray(void* value, size_t size);
+ virtual bool readColorArray(SkColor* colors, size_t size);
+ virtual bool readIntArray(int32_t* values, size_t size);
+ virtual bool readPointArray(SkPoint* points, size_t size);
+ virtual bool readScalarArray(SkScalar* values, size_t size);
+
+ SkData* readByteArrayAsData() {
+ size_t len = this->getArrayCount();
+ if (!this->validateAvailable(len)) {
+ return SkData::NewEmpty();
+ }
+ void* buffer = sk_malloc_throw(len);
+ this->readByteArray(buffer, len);
+ return SkData::NewFromMalloc(buffer, len);
+ }
+
+ // helpers to get info about arrays and binary data
+ virtual uint32_t getArrayCount();
+
+ virtual void readBitmap(SkBitmap* bitmap);
+ virtual SkTypeface* readTypeface();
+
+ void setBitmapStorage(SkBitmapHeapReader* bitmapStorage) {
+ SkRefCnt_SafeAssign(fBitmapStorage, bitmapStorage);
+ }
+
+ void setTypefaceArray(SkTypeface* array[], int count) {
+ fTFArray = array;
+ fTFCount = count;
+ }
+
+ /**
+ * Call this with a pre-loaded array of Factories, in the same order as
+ * were created/written by the writer. SkPicture uses this.
+ */
+ void setFactoryPlayback(SkFlattenable::Factory array[], int count) {
+ fFactoryTDArray = NULL;
+ fFactoryArray = array;
+ fFactoryCount = count;
+ }
+
+ /**
+ * Call this with an initially empty array, so the reader can cache each
+ * factory it sees by name. Used by the pipe code in conjunction with
+ * SkWriteBuffer::setNamedFactoryRecorder.
+ */
+ void setFactoryArray(SkTDArray<SkFlattenable::Factory>* array) {
+ fFactoryTDArray = array;
+ fFactoryArray = NULL;
+ fFactoryCount = 0;
+ }
+
+ /**
+ * Provide a function to decode an SkBitmap from encoded data. Only used if the writer
+ * encoded the SkBitmap. If the proper decoder cannot be used, a red bitmap with the
+ * appropriate size will be used.
+ */
+ void setBitmapDecoder(SkPicture::InstallPixelRefProc bitmapDecoder) {
+ fBitmapDecoder = bitmapDecoder;
+ }
+
+ // Default impelementations don't check anything.
+ virtual bool validate(bool isValid) { return true; }
+ virtual bool isValid() const { return true; }
+ virtual bool validateAvailable(size_t size) { return true; }
+
+private:
+ bool readArray(void* value, size_t size, size_t elementSize);
+
+ uint32_t fFlags;
+
+ SkReader32 fReader;
+ void* fMemoryPtr;
+
+ SkBitmapHeapReader* fBitmapStorage;
+ SkTypeface** fTFArray;
+ int fTFCount;
+
+ SkTDArray<SkFlattenable::Factory>* fFactoryTDArray;
+ SkFlattenable::Factory* fFactoryArray;
+ int fFactoryCount;
+
+ SkPicture::InstallPixelRefProc fBitmapDecoder;
+
+#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
+ // Debugging counter to keep track of how many bitmaps we
+ // have decoded.
+ int fDecodedBitmapIndex;
+#endif // DEBUG_NON_DETERMINISTIC_ASSERT
+};
+
+#endif // SkReadBuffer_DEFINED
diff --git a/include/core/SkShader.h b/include/core/SkShader.h
index cdb7a2f..108c6b0 100644
--- a/include/core/SkShader.h
+++ b/include/core/SkShader.h
@@ -363,8 +363,8 @@
const SkMatrix& getTotalInverse() const { return fTotalInverse; }
MatrixClass getInverseClass() const { return (MatrixClass)fTotalInverseClass; }
- SkShader(SkFlattenableReadBuffer& );
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkShader(SkReadBuffer& );
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkMatrix fLocalMatrix;
SkMatrix fTotalInverse;
diff --git a/include/core/SkUnitMapper.h b/include/core/SkUnitMapper.h
index 57a8b83..46f6edd 100644
--- a/include/core/SkUnitMapper.h
+++ b/include/core/SkUnitMapper.h
@@ -28,7 +28,7 @@
SK_DEFINE_FLATTENABLE_TYPE(SkUnitMapper)
protected:
- SkUnitMapper(SkFlattenableReadBuffer& rb) : SkFlattenable(rb) {}
+ SkUnitMapper(SkReadBuffer& rb) : SkFlattenable(rb) {}
private:
typedef SkFlattenable INHERITED;
diff --git a/include/core/SkWriteBuffer.h b/include/core/SkWriteBuffer.h
new file mode 100644
index 0000000..ab56f9d
--- /dev/null
+++ b/include/core/SkWriteBuffer.h
@@ -0,0 +1,121 @@
+
+/*
+ * 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 SkWriteBuffer_DEFINED
+#define SkWriteBuffer_DEFINED
+
+#include "SkBitmapHeap.h"
+#include "SkData.h"
+#include "SkPath.h"
+#include "SkPicture.h"
+#include "SkRefCnt.h"
+#include "SkWriter32.h"
+
+class SkBitmap;
+class SkFactorySet;
+class SkFlattenable;
+class SkNamedFactorySet;
+class SkRefCntSet;
+
+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); }
+ bool isCrossProcess() const {
+ return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
+ }
+
+ SkWriter32* getWriter32() { return &fWriter; }
+ void reset(void* storage = NULL, size_t storageSize = 0) {
+ fWriter.reset(storage, storageSize);
+ }
+
+ uint32_t* reserve(size_t size) { return fWriter.reserve(size); }
+
+ size_t bytesWritten() const { return fWriter.bytesWritten(); }
+
+ void writeByteArray(const void* data, size_t size);
+ void writeDataAsByteArray(SkData* data) { this->writeByteArray(data->data(), data->size()); }
+ void writeBool(bool value);
+ void writeFixed(SkFixed value);
+ void writeScalar(SkScalar value);
+ void writeScalarArray(const SkScalar* value, uint32_t count);
+ void writeInt(int32_t value);
+ void writeIntArray(const int32_t* value, uint32_t count);
+ void writeUInt(uint32_t value);
+ void write32(int32_t value);
+ void writeString(const char* value);
+ void writeEncodedString(const void* value, size_t byteLength, SkPaint::TextEncoding encoding);
+ void writeFunctionPtr(void* ptr) { this->writeByteArray(&ptr, sizeof(ptr)); }
+
+ void writeFlattenable(const SkFlattenable* flattenable);
+ void writeColor(const SkColor& color);
+ void writeColorArray(const SkColor* color, uint32_t count);
+ void writePoint(const SkPoint& point);
+ void writePointArray(const SkPoint* point, uint32_t count);
+ void writeMatrix(const SkMatrix& matrix);
+ void writeIRect(const SkIRect& rect);
+ void writeRect(const SkRect& rect);
+ void writeRegion(const SkRegion& region);
+ void writePath(const SkPath& path);
+ size_t writeStream(SkStream* stream, size_t length);
+ void writeBitmap(const SkBitmap& bitmap);
+ void writeTypeface(SkTypeface* typeface);
+ void writePaint(const SkPaint& paint) { paint.flatten(*this); }
+
+ bool writeToStream(SkWStream*);
+ void writeToMemory(void* dst) { fWriter.flatten(dst); }
+
+ SkFactorySet* setFactoryRecorder(SkFactorySet*);
+ SkNamedFactorySet* setNamedFactoryRecorder(SkNamedFactorySet*);
+
+ SkRefCntSet* getTypefaceRecorder() const { return fTFSet; }
+ SkRefCntSet* setTypefaceRecorder(SkRefCntSet*);
+
+ /**
+ * Set an SkBitmapHeap to store bitmaps rather than flattening.
+ *
+ * Incompatible with an EncodeBitmap function. If an EncodeBitmap function is set, setting an
+ * SkBitmapHeap will set the function to NULL in release mode and crash in debug.
+ */
+ void setBitmapHeap(SkBitmapHeap*);
+
+ /**
+ * Provide a function to encode an SkBitmap to an SkData. writeBitmap will attempt to use
+ * bitmapEncoder to store the SkBitmap. If the reader does not provide a function to decode, it
+ * will not be able to restore SkBitmaps, but will still be able to read the rest of the stream.
+ * bitmapEncoder will never be called with a NULL pixelRefOffset.
+ *
+ * Incompatible with the SkBitmapHeap. If an encoder is set fBitmapHeap will be set to NULL in
+ * release and crash in debug.
+ */
+ void setBitmapEncoder(SkPicture::EncodeBitmap bitmapEncoder);
+
+private:
+ uint32_t fFlags;
+ SkFactorySet* fFactorySet;
+ SkNamedFactorySet* fNamedFactorySet;
+ SkWriter32 fWriter;
+
+ SkBitmapHeap* fBitmapHeap;
+ SkRefCntSet* fTFSet;
+
+ SkPicture::EncodeBitmap fBitmapEncoder;
+};
+
+#endif // SkWriteBuffer_DEFINED
diff --git a/include/core/SkXfermode.h b/include/core/SkXfermode.h
index 3ef2241..31b8081 100644
--- a/include/core/SkXfermode.h
+++ b/include/core/SkXfermode.h
@@ -218,7 +218,7 @@
SK_DEFINE_FLATTENABLE_TYPE(SkXfermode)
protected:
- SkXfermode(SkFlattenableReadBuffer& rb) : SkFlattenable(rb) {}
+ SkXfermode(SkReadBuffer& rb) : SkFlattenable(rb) {}
/** The default implementation of xfer32/xfer16/xferA8 in turn call this
method, 1 color at a time (upscaled to a SkPMColor). The default
@@ -264,8 +264,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkProcXfermode)
protected:
- SkProcXfermode(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkProcXfermode(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// allow subclasses to update this after we unflatten
void setProc(SkXfermodeProc proc) {
diff --git a/include/effects/Sk1DPathEffect.h b/include/effects/Sk1DPathEffect.h
index 4599276..4ac8f73 100644
--- a/include/effects/Sk1DPathEffect.h
+++ b/include/effects/Sk1DPathEffect.h
@@ -60,8 +60,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPath1DPathEffect)
protected:
- SkPath1DPathEffect(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkPath1DPathEffect(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// overrides from Sk1DPathEffect
virtual SkScalar begin(SkScalar contourLength) const SK_OVERRIDE;
diff --git a/include/effects/Sk2DPathEffect.h b/include/effects/Sk2DPathEffect.h
index ed7f674..859b5cd 100644
--- a/include/effects/Sk2DPathEffect.h
+++ b/include/effects/Sk2DPathEffect.h
@@ -41,8 +41,8 @@
const SkMatrix& getMatrix() const { return fMatrix; }
// protected so that subclasses can call this during unflattening
- Sk2DPathEffect(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ Sk2DPathEffect(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkMatrix fMatrix, fInverse;
@@ -69,9 +69,9 @@
protected:
virtual void nextSpan(int u, int v, int ucount, SkPath*) const SK_OVERRIDE;
- SkLine2DPathEffect(SkFlattenableReadBuffer&);
+ SkLine2DPathEffect(SkReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkScalar fWidth;
@@ -90,8 +90,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPath2DPathEffect)
protected:
- SkPath2DPathEffect(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkPath2DPathEffect(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual void next(const SkPoint&, int u, int v, SkPath*) const SK_OVERRIDE;
diff --git a/include/effects/SkAvoidXfermode.h b/include/effects/SkAvoidXfermode.h
index 4950b64..afc3fc9 100644
--- a/include/effects/SkAvoidXfermode.h
+++ b/include/effects/SkAvoidXfermode.h
@@ -51,8 +51,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAvoidXfermode)
protected:
- SkAvoidXfermode(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkAvoidXfermode(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkColor fOpColor;
diff --git a/include/effects/SkBicubicImageFilter.h b/include/effects/SkBicubicImageFilter.h
index bd918eb..d321169 100644
--- a/include/effects/SkBicubicImageFilter.h
+++ b/include/effects/SkBicubicImageFilter.h
@@ -35,8 +35,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBicubicImageFilter)
protected:
- SkBicubicImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkBicubicImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkBitmapSource.h b/include/effects/SkBitmapSource.h
index ec779ea..e0e241b 100644
--- a/include/effects/SkBitmapSource.h
+++ b/include/effects/SkBitmapSource.h
@@ -20,8 +20,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapSource)
protected:
- explicit SkBitmapSource(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkBitmapSource(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
diff --git a/include/effects/SkBlurDrawLooper.h b/include/effects/SkBlurDrawLooper.h
index 013e807..46b154d 100644
--- a/include/effects/SkBlurDrawLooper.h
+++ b/include/effects/SkBlurDrawLooper.h
@@ -51,8 +51,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurDrawLooper)
protected:
- SkBlurDrawLooper(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkBlurDrawLooper(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkMaskFilter* fBlur;
diff --git a/include/effects/SkBlurImageFilter.h b/include/effects/SkBlurImageFilter.h
index d0d2446..1d51f9a 100644
--- a/include/effects/SkBlurImageFilter.h
+++ b/include/effects/SkBlurImageFilter.h
@@ -22,8 +22,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurImageFilter)
protected:
- explicit SkBlurImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkBlurImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
diff --git a/include/effects/SkColorFilterImageFilter.h b/include/effects/SkColorFilterImageFilter.h
index c4ac6b2..c04e418 100755
--- a/include/effects/SkColorFilterImageFilter.h
+++ b/include/effects/SkColorFilterImageFilter.h
@@ -22,8 +22,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorFilterImageFilter)
protected:
- SkColorFilterImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkColorFilterImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkColorMatrixFilter.h b/include/effects/SkColorMatrixFilter.h
index ca7c086..a4144e1 100644
--- a/include/effects/SkColorMatrixFilter.h
+++ b/include/effects/SkColorMatrixFilter.h
@@ -35,8 +35,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorMatrixFilter)
protected:
- SkColorMatrixFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkColorMatrixFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkColorMatrix fMatrix;
diff --git a/include/effects/SkComposeImageFilter.h b/include/effects/SkComposeImageFilter.h
index 45f530b..744647d 100644
--- a/include/effects/SkComposeImageFilter.h
+++ b/include/effects/SkComposeImageFilter.h
@@ -18,7 +18,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposeImageFilter)
protected:
- explicit SkComposeImageFilter(SkFlattenableReadBuffer& buffer);
+ explicit SkComposeImageFilter(SkReadBuffer& buffer);
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkCornerPathEffect.h b/include/effects/SkCornerPathEffect.h
index 704b7fb..dcb7c9f 100644
--- a/include/effects/SkCornerPathEffect.h
+++ b/include/effects/SkCornerPathEffect.h
@@ -29,8 +29,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkCornerPathEffect)
protected:
- SkCornerPathEffect(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkCornerPathEffect(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkScalar fRadius;
diff --git a/include/effects/SkDashPathEffect.h b/include/effects/SkDashPathEffect.h
index 4e83f45..818e073 100644
--- a/include/effects/SkDashPathEffect.h
+++ b/include/effects/SkDashPathEffect.h
@@ -49,11 +49,11 @@
virtual Factory getFactory() const SK_OVERRIDE;
- static SkFlattenable* CreateProc(SkFlattenableReadBuffer&);
+ static SkFlattenable* CreateProc(SkReadBuffer&);
protected:
- SkDashPathEffect(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkDashPathEffect(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkScalar* fIntervals;
diff --git a/include/effects/SkDiscretePathEffect.h b/include/effects/SkDiscretePathEffect.h
index 999ea04..60eb852 100644
--- a/include/effects/SkDiscretePathEffect.h
+++ b/include/effects/SkDiscretePathEffect.h
@@ -28,8 +28,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiscretePathEffect)
protected:
- SkDiscretePathEffect(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkDiscretePathEffect(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkScalar fSegLength, fPerterb;
diff --git a/include/effects/SkDisplacementMapEffect.h b/include/effects/SkDisplacementMapEffect.h
index d82a40a..ba7e259 100644
--- a/include/effects/SkDisplacementMapEffect.h
+++ b/include/effects/SkDisplacementMapEffect.h
@@ -46,8 +46,8 @@
#endif
protected:
- explicit SkDisplacementMapEffect(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkDisplacementMapEffect(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
ChannelSelectorType fXChannelSelector;
diff --git a/include/effects/SkDropShadowImageFilter.h b/include/effects/SkDropShadowImageFilter.h
index 0c66272..14a7893 100644
--- a/include/effects/SkDropShadowImageFilter.h
+++ b/include/effects/SkDropShadowImageFilter.h
@@ -17,8 +17,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDropShadowImageFilter)
protected:
- explicit SkDropShadowImageFilter(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkDropShadowImageFilter(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& source, const SkMatrix&, SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
private:
diff --git a/include/effects/SkEmbossMaskFilter.h b/include/effects/SkEmbossMaskFilter.h
index 7210b78..263c5e0 100644
--- a/include/effects/SkEmbossMaskFilter.h
+++ b/include/effects/SkEmbossMaskFilter.h
@@ -39,8 +39,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmbossMaskFilter)
protected:
- SkEmbossMaskFilter(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkEmbossMaskFilter(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
Light fLight;
diff --git a/include/effects/SkKernel33MaskFilter.h b/include/effects/SkKernel33MaskFilter.h
index 3404b73..bcd9b26 100644
--- a/include/effects/SkKernel33MaskFilter.h
+++ b/include/effects/SkKernel33MaskFilter.h
@@ -24,8 +24,8 @@
SkDEVCODE(virtual void toString(SkString* str) const SK_OVERRIDE;)
protected:
- SkKernel33ProcMaskFilter(SkFlattenableReadBuffer& rb);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkKernel33ProcMaskFilter(SkReadBuffer& rb);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
int fPercent256;
@@ -53,8 +53,8 @@
int fKernel[3][3];
int fShift;
- SkKernel33MaskFilter(SkFlattenableReadBuffer& rb);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkKernel33MaskFilter(SkReadBuffer& rb);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
typedef SkKernel33ProcMaskFilter INHERITED;
};
diff --git a/include/effects/SkLayerDrawLooper.h b/include/effects/SkLayerDrawLooper.h
index adf07a9..6955192 100644
--- a/include/effects/SkLayerDrawLooper.h
+++ b/include/effects/SkLayerDrawLooper.h
@@ -110,8 +110,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLayerDrawLooper)
protected:
- SkLayerDrawLooper(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkLayerDrawLooper(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
struct Rec {
diff --git a/include/effects/SkLayerRasterizer.h b/include/effects/SkLayerRasterizer.h
index 65d1be0..be81a2b 100644
--- a/include/effects/SkLayerRasterizer.h
+++ b/include/effects/SkLayerRasterizer.h
@@ -35,8 +35,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLayerRasterizer)
protected:
- SkLayerRasterizer(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkLayerRasterizer(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// override from SkRasterizer
virtual bool onRasterize(const SkPath& path, const SkMatrix& matrix,
diff --git a/include/effects/SkLerpXfermode.h b/include/effects/SkLerpXfermode.h
index 6151f3d..b6cc93f 100644
--- a/include/effects/SkLerpXfermode.h
+++ b/include/effects/SkLerpXfermode.h
@@ -32,8 +32,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLerpXfermode)
protected:
- SkLerpXfermode(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkLerpXfermode(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkLerpXfermode(unsigned scale256);
diff --git a/include/effects/SkLightingImageFilter.h b/include/effects/SkLightingImageFilter.h
index b3fb7d0..4a76a9c 100644
--- a/include/effects/SkLightingImageFilter.h
+++ b/include/effects/SkLightingImageFilter.h
@@ -74,8 +74,8 @@
SkScalar surfaceScale,
SkImageFilter* input,
const CropRect* cropRect = NULL);
- explicit SkLightingImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkLightingImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
const SkLight* light() const { return fLight; }
SkScalar surfaceScale() const { return fSurfaceScale; }
diff --git a/include/effects/SkLumaColorFilter.h b/include/effects/SkLumaColorFilter.h
index a0c08bb..6c57f7c 100644
--- a/include/effects/SkLumaColorFilter.h
+++ b/include/effects/SkLumaColorFilter.h
@@ -35,8 +35,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLumaColorFilter)
protected:
- SkLumaColorFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkLumaColorFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkLumaColorFilter();
diff --git a/include/effects/SkMagnifierImageFilter.h b/include/effects/SkMagnifierImageFilter.h
index b5a79fa..222abd1 100644
--- a/include/effects/SkMagnifierImageFilter.h
+++ b/include/effects/SkMagnifierImageFilter.h
@@ -19,8 +19,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMagnifierImageFilter)
protected:
- explicit SkMagnifierImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkMagnifierImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
diff --git a/include/effects/SkMatrixConvolutionImageFilter.h b/include/effects/SkMatrixConvolutionImageFilter.h
index d3cf8e3..8da556e 100644
--- a/include/effects/SkMatrixConvolutionImageFilter.h
+++ b/include/effects/SkMatrixConvolutionImageFilter.h
@@ -64,8 +64,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMatrixConvolutionImageFilter)
protected:
- SkMatrixConvolutionImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkMatrixConvolutionImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkMergeImageFilter.h b/include/effects/SkMergeImageFilter.h
index ad464d3..bd9ab6c 100755
--- a/include/effects/SkMergeImageFilter.h
+++ b/include/effects/SkMergeImageFilter.h
@@ -25,8 +25,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMergeImageFilter)
protected:
- SkMergeImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkMergeImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkMorphologyImageFilter.h b/include/effects/SkMorphologyImageFilter.h
index d44d0e2..0335908 100644
--- a/include/effects/SkMorphologyImageFilter.h
+++ b/include/effects/SkMorphologyImageFilter.h
@@ -32,8 +32,8 @@
bool filterImageGeneric(Proc procX, Proc procY,
Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset);
- SkMorphologyImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkMorphologyImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
#if SK_SUPPORT_GPU
virtual bool canFilterImageGPU() const SK_OVERRIDE { return true; }
bool filterImageGPUGeneric(bool dilate, Proxy* proxy, const SkBitmap& src,
@@ -65,7 +65,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDilateImageFilter)
protected:
- SkDilateImageFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkDilateImageFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
typedef SkMorphologyImageFilter INHERITED;
@@ -88,7 +88,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkErodeImageFilter)
protected:
- SkErodeImageFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkErodeImageFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
typedef SkMorphologyImageFilter INHERITED;
diff --git a/include/effects/SkOffsetImageFilter.h b/include/effects/SkOffsetImageFilter.h
index f156415..9237111 100644
--- a/include/effects/SkOffsetImageFilter.h
+++ b/include/effects/SkOffsetImageFilter.h
@@ -21,8 +21,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkOffsetImageFilter)
protected:
- SkOffsetImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkOffsetImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkPerlinNoiseShader.h b/include/effects/SkPerlinNoiseShader.h
index 22cb892..dd89c70 100644
--- a/include/effects/SkPerlinNoiseShader.h
+++ b/include/effects/SkPerlinNoiseShader.h
@@ -73,8 +73,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPerlinNoiseShader)
protected:
- SkPerlinNoiseShader(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkPerlinNoiseShader(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkPerlinNoiseShader(SkPerlinNoiseShader::Type type, SkScalar baseFrequencyX,
diff --git a/include/effects/SkPictureImageFilter.h b/include/effects/SkPictureImageFilter.h
index 98d72d9..ccda85d 100644
--- a/include/effects/SkPictureImageFilter.h
+++ b/include/effects/SkPictureImageFilter.h
@@ -28,8 +28,8 @@
protected:
virtual ~SkPictureImageFilter();
- explicit SkPictureImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkPictureImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
diff --git a/include/effects/SkPixelXorXfermode.h b/include/effects/SkPixelXorXfermode.h
index 5411b12..9472d94 100644
--- a/include/effects/SkPixelXorXfermode.h
+++ b/include/effects/SkPixelXorXfermode.h
@@ -23,8 +23,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPixelXorXfermode)
protected:
- SkPixelXorXfermode(SkFlattenableReadBuffer& rb);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkPixelXorXfermode(SkReadBuffer& rb);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// override from SkXfermode
virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const;
diff --git a/include/effects/SkRectShaderImageFilter.h b/include/effects/SkRectShaderImageFilter.h
index ea97478..28d98cc 100644
--- a/include/effects/SkRectShaderImageFilter.h
+++ b/include/effects/SkRectShaderImageFilter.h
@@ -34,8 +34,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRectShaderImageFilter)
protected:
- SkRectShaderImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkRectShaderImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkResizeImageFilter.h b/include/effects/SkResizeImageFilter.h
index d638555..e2747e7 100644
--- a/include/effects/SkResizeImageFilter.h
+++ b/include/effects/SkResizeImageFilter.h
@@ -36,8 +36,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkResizeImageFilter)
protected:
- SkResizeImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkResizeImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkStippleMaskFilter.h b/include/effects/SkStippleMaskFilter.h
index 8f6d20d..ee32ae1 100644
--- a/include/effects/SkStippleMaskFilter.h
+++ b/include/effects/SkStippleMaskFilter.h
@@ -31,7 +31,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkStippleMaskFilter);
protected:
- SkStippleMaskFilter(SkFlattenableReadBuffer& buffer)
+ SkStippleMaskFilter(SkReadBuffer& buffer)
: SkMaskFilter(buffer) {
}
diff --git a/include/effects/SkTableMaskFilter.h b/include/effects/SkTableMaskFilter.h
index ac33266..1c2bbd7 100644
--- a/include/effects/SkTableMaskFilter.h
+++ b/include/effects/SkTableMaskFilter.h
@@ -51,8 +51,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTableMaskFilter)
protected:
- SkTableMaskFilter(SkFlattenableReadBuffer& rb);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkTableMaskFilter(SkReadBuffer& rb);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
uint8_t fTable[256];
diff --git a/include/effects/SkTestImageFilters.h b/include/effects/SkTestImageFilters.h
index e848ff1..66ef5b1 100755
--- a/include/effects/SkTestImageFilters.h
+++ b/include/effects/SkTestImageFilters.h
@@ -12,8 +12,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDownSampleImageFilter)
protected:
- SkDownSampleImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkDownSampleImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
diff --git a/include/effects/SkTileImageFilter.h b/include/effects/SkTileImageFilter.h
index bee8a68..095b976 100644
--- a/include/effects/SkTileImageFilter.h
+++ b/include/effects/SkTileImageFilter.h
@@ -28,9 +28,9 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTileImageFilter)
protected:
- explicit SkTileImageFilter(SkFlattenableReadBuffer& buffer);
+ explicit SkTileImageFilter(SkReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
private:
SkRect fSrcRect;
diff --git a/include/effects/SkTransparentShader.h b/include/effects/SkTransparentShader.h
index bee9a02..2b3f998 100644
--- a/include/effects/SkTransparentShader.h
+++ b/include/effects/SkTransparentShader.h
@@ -29,7 +29,7 @@
const SkBitmap* fDevice;
uint8_t fAlpha;
- SkTransparentShader(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkTransparentShader(SkReadBuffer& buffer) : INHERITED(buffer) {}
typedef SkShader INHERITED;
};
diff --git a/include/effects/SkXfermodeImageFilter.h b/include/effects/SkXfermodeImageFilter.h
index 6343c4b..e2724c3 100644
--- a/include/effects/SkXfermodeImageFilter.h
+++ b/include/effects/SkXfermodeImageFilter.h
@@ -40,8 +40,8 @@
#endif
protected:
- explicit SkXfermodeImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkXfermodeImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkXfermode* fMode;
diff --git a/include/images/SkImageRef.h b/include/images/SkImageRef.h
index 36f95e6..ec14456 100644
--- a/include/images/SkImageRef.h
+++ b/include/images/SkImageRef.h
@@ -76,8 +76,8 @@
// override this in your subclass to clean up when we're unlocking pixels
virtual void onUnlockPixels() SK_OVERRIDE {}
- SkImageRef(SkFlattenableReadBuffer&, SkBaseMutex* mutex = NULL);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkImageRef(SkReadBuffer&, SkBaseMutex* mutex = NULL);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
SkBitmap fBitmap;
diff --git a/include/images/SkImageRef_GlobalPool.h b/include/images/SkImageRef_GlobalPool.h
index caaf248..7b99a6e 100644
--- a/include/images/SkImageRef_GlobalPool.h
+++ b/include/images/SkImageRef_GlobalPool.h
@@ -53,7 +53,7 @@
virtual void onUnlockPixels();
- SkImageRef_GlobalPool(SkFlattenableReadBuffer&);
+ SkImageRef_GlobalPool(SkReadBuffer&);
private:
typedef SkImageRef INHERITED;
diff --git a/include/utils/SkUnitMappers.h b/include/utils/SkUnitMappers.h
index 509e2d6..3833e69 100644
--- a/include/utils/SkUnitMappers.h
+++ b/include/utils/SkUnitMappers.h
@@ -23,8 +23,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiscreteMapper)
protected:
- SkDiscreteMapper(SkFlattenableReadBuffer& );
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkDiscreteMapper(SkReadBuffer& );
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
int fSegments;
@@ -45,7 +45,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkCosineMapper)
protected:
- SkCosineMapper(SkFlattenableReadBuffer&);
+ SkCosineMapper(SkReadBuffer&);
private:
diff --git a/samplecode/ClockFaceView.cpp b/samplecode/ClockFaceView.cpp
index 32c8161..ed0bce9 100644
--- a/samplecode/ClockFaceView.cpp
+++ b/samplecode/ClockFaceView.cpp
@@ -8,7 +8,8 @@
#include "SampleCode.h"
#include "SkView.h"
#include "SkCanvas.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkGradientShader.h"
#include "SkPath.h"
#include "SkRegion.h"
@@ -89,12 +90,12 @@
dst->addCircle(loc.fX, loc.fY, fRadius);
}
- Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ Dot2DPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
fRadius = buffer.readScalar();
fPts = NULL;
}
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fRadius);
}
@@ -118,7 +119,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(InverseFillPE)
protected:
- InverseFillPE(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ InverseFillPE(SkReadBuffer& buffer) : INHERITED(buffer) {}
private:
typedef SkPathEffect INHERITED;
diff --git a/samplecode/SampleAll.cpp b/samplecode/SampleAll.cpp
index 6b742b8..6410670 100644
--- a/samplecode/SampleAll.cpp
+++ b/samplecode/SampleAll.cpp
@@ -19,7 +19,8 @@
#include "SkDashPathEffect.h"
#include "SkDiscretePathEffect.h"
#include "SkEmbossMaskFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkGradientShader.h"
#include "SkImageDecoder.h"
#include "SkLayerRasterizer.h"
@@ -171,10 +172,10 @@
dst->addCircle(loc.fX, loc.fY, fRadius);
}
- Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ Dot2DPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
fRadius = buffer.readScalar();
}
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fRadius);
}
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
index 68651f3..4f68032 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -10,7 +10,8 @@
#include "SkBlurMaskFilter.h"
#include "SkCanvas.h"
#include "SkDevice.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkGradientShader.h"
#include "SkLayerRasterizer.h"
#include "SkPaint.h"
diff --git a/samplecode/SampleText.cpp b/samplecode/SampleText.cpp
index 9aefd2c..7e98171 100644
--- a/samplecode/SampleText.cpp
+++ b/samplecode/SampleText.cpp
@@ -8,7 +8,8 @@
#include "SampleCode.h"
#include "SkView.h"
#include "SkCanvas.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkGradientShader.h"
#include "SkGraphics.h"
#include "SkImageDecoder.h"
@@ -59,7 +60,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(ReduceNoise)
private:
- ReduceNoise(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
+ ReduceNoise(SkReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
typedef SkKernel33ProcMaskFilter INHERITED;
};
@@ -91,7 +92,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Darken)
private:
- Darken(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
+ Darken(SkReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
typedef SkKernel33ProcMaskFilter INHERITED;
};
@@ -143,7 +144,7 @@
virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
const SkAlpha aa[]) const SK_OVERRIDE;
- typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
+ typedef SkFlattenable* (*Factory)(SkReadBuffer&);
SK_DEVELOPER_TO_STRING()
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPowerMode)
@@ -153,11 +154,11 @@
uint8_t fTable[256]; // cache
void init(SkScalar exponent);
- SkPowerMode(SkFlattenableReadBuffer& b) : INHERITED(b) {
+ SkPowerMode(SkReadBuffer& b) : INHERITED(b) {
// read the exponent
this->init(SkFixedToScalar(b.readFixed()));
}
- virtual void flatten(SkFlattenableWriteBuffer& b) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& b) const SK_OVERRIDE {
this->INHERITED::flatten(b);
b.writeFixed(SkScalarToFixed(fExp));
}
diff --git a/src/core/SkAnnotation.cpp b/src/core/SkAnnotation.cpp
index 837cb62..6ba645f 100644
--- a/src/core/SkAnnotation.cpp
+++ b/src/core/SkAnnotation.cpp
@@ -7,7 +7,8 @@
#include "SkAnnotation.h"
#include "SkData.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPoint.h"
#include "SkStream.h"
@@ -28,12 +29,12 @@
return fKey.equals(key) ? fData : NULL;
}
-SkAnnotation::SkAnnotation(SkFlattenableReadBuffer& buffer) {
+SkAnnotation::SkAnnotation(SkReadBuffer& buffer) {
buffer.readString(&fKey);
fData = buffer.readByteArrayAsData();
}
-void SkAnnotation::writeToBuffer(SkFlattenableWriteBuffer& buffer) const {
+void SkAnnotation::writeToBuffer(SkWriteBuffer& buffer) const {
buffer.writeString(fKey.c_str());
buffer.writeDataAsByteArray(fData);
}
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index e12840a..3b33820 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -14,8 +14,8 @@
#include "SkImagePriv.h"
#include "SkMallocPixelRef.h"
#include "SkMask.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPixelRef.h"
#include "SkThread.h"
#include "SkUnPreMultiply.h"
@@ -1583,7 +1583,7 @@
SERIALIZE_PIXELTYPE_REF_DATA
};
-void SkBitmap::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBitmap::flatten(SkWriteBuffer& buffer) const {
buffer.writeInt(fWidth);
buffer.writeInt(fHeight);
buffer.writeInt(fRowBytes);
@@ -1605,7 +1605,7 @@
}
}
-void SkBitmap::unflatten(SkFlattenableReadBuffer& buffer) {
+void SkBitmap::unflatten(SkReadBuffer& buffer) {
this->reset();
int width = buffer.readInt();
diff --git a/src/core/SkBitmapHeap.cpp b/src/core/SkBitmapHeap.cpp
index 7904492..da62893 100644
--- a/src/core/SkBitmapHeap.cpp
+++ b/src/core/SkBitmapHeap.cpp
@@ -9,7 +9,8 @@
#include "SkBitmapHeap.h"
#include "SkBitmap.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkTSearch.h"
SkBitmapHeapEntry::SkBitmapHeapEntry()
diff --git a/src/core/SkBitmapProcShader.cpp b/src/core/SkBitmapProcShader.cpp
index 9a94676..d7c7269 100644
--- a/src/core/SkBitmapProcShader.cpp
+++ b/src/core/SkBitmapProcShader.cpp
@@ -6,7 +6,8 @@
* found in the LICENSE file.
*/
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPixelRef.h"
#include "SkErrorInternals.h"
#include "SkBitmapProcShader.h"
@@ -38,7 +39,7 @@
fFlags = 0; // computed in setContext
}
-SkBitmapProcShader::SkBitmapProcShader(SkFlattenableReadBuffer& buffer)
+SkBitmapProcShader::SkBitmapProcShader(SkReadBuffer& buffer)
: INHERITED(buffer) {
buffer.readBitmap(&fRawBitmap);
fRawBitmap.setImmutable();
@@ -63,7 +64,7 @@
return kDefault_BitmapType;
}
-void SkBitmapProcShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeBitmap(fRawBitmap);
diff --git a/src/core/SkBitmapProcShader.h b/src/core/SkBitmapProcShader.h
index 5a599c3..b7e60f1 100644
--- a/src/core/SkBitmapProcShader.h
+++ b/src/core/SkBitmapProcShader.h
@@ -37,8 +37,8 @@
#endif
protected:
- SkBitmapProcShader(SkFlattenableReadBuffer& );
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkBitmapProcShader(SkReadBuffer& );
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
SkBitmap fRawBitmap; // experimental for RLE encoding
SkBitmapProcState fState;
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index 9682d55..31a3ede 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -12,7 +12,8 @@
#include "SkColor.h"
#include "SkColorFilter.h"
#include "SkFilterShader.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMask.h"
#include "SkMaskFilter.h"
#include "SkTemplatesPriv.h"
@@ -682,13 +683,13 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Sk3DShader)
protected:
- Sk3DShader(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ Sk3DShader(SkReadBuffer& buffer) : INHERITED(buffer) {
fProxy = buffer.readShader();
fPMColor = buffer.readColor();
fMask = NULL;
}
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fProxy);
buffer.writeColor(fPMColor);
diff --git a/src/core/SkColorFilter.cpp b/src/core/SkColorFilter.cpp
index ef0bda7..8cf9fc0 100644
--- a/src/core/SkColorFilter.cpp
+++ b/src/core/SkColorFilter.cpp
@@ -7,7 +7,8 @@
#include "SkColorFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkShader.h"
#include "SkUnPreMultiply.h"
#include "SkString.h"
diff --git a/src/core/SkColorTable.cpp b/src/core/SkColorTable.cpp
index 12ec43e..b8e7b05 100644
--- a/src/core/SkColorTable.cpp
+++ b/src/core/SkColorTable.cpp
@@ -8,7 +8,8 @@
#include "SkColorTable.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkStream.h"
#include "SkTemplates.h"
@@ -83,7 +84,7 @@
///////////////////////////////////////////////////////////////////////////////
-SkColorTable::SkColorTable(SkFlattenableReadBuffer& buffer) {
+SkColorTable::SkColorTable(SkReadBuffer& buffer) {
f16BitCache = NULL;
SkDEBUGCODE(fColorLockCount = 0;)
SkDEBUGCODE(f16BitCacheLockCount = 0;)
@@ -105,7 +106,7 @@
#endif
}
-void SkColorTable::writeToBuffer(SkFlattenableWriteBuffer& buffer) const {
+void SkColorTable::writeToBuffer(SkWriteBuffer& buffer) const {
buffer.writeUInt(fAlphaType);
buffer.writeColorArray(fColors, fCount);
}
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index 0d2d687..b5ea63c 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -11,7 +11,8 @@
#include "SkColorFilter.h"
#include "SkColorPriv.h"
#include "SkColorShader.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkXfermode.h"
#include "SkString.h"
@@ -25,7 +26,7 @@
SkSafeRef(mode);
}
-SkComposeShader::SkComposeShader(SkFlattenableReadBuffer& buffer) :
+SkComposeShader::SkComposeShader(SkReadBuffer& buffer) :
INHERITED(buffer) {
fShaderA = buffer.readShader();
if (NULL == fShaderA) {
@@ -61,7 +62,7 @@
};
#define SkAutoAlphaRestore(...) SK_REQUIRE_LOCAL_VAR(SkAutoAlphaRestore)
-void SkComposeShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkComposeShader::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fShaderA);
buffer.writeFlattenable(fShaderB);
diff --git a/src/core/SkData.cpp b/src/core/SkData.cpp
index 176e93c..2f07914 100644
--- a/src/core/SkData.cpp
+++ b/src/core/SkData.cpp
@@ -6,7 +6,8 @@
*/
#include "SkData.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkOSFile.h"
#include "SkOnce.h"
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 013b73d..5f81073 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -2382,7 +2382,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTriColorShader)
protected:
- SkTriColorShader(SkFlattenableReadBuffer& buffer) : SkShader(buffer) {}
+ SkTriColorShader(SkReadBuffer& buffer) : SkShader(buffer) {}
private:
SkMatrix fDstToUnit;
diff --git a/src/core/SkFilterShader.cpp b/src/core/SkFilterShader.cpp
index 1e590cb..feea75b 100644
--- a/src/core/SkFilterShader.cpp
+++ b/src/core/SkFilterShader.cpp
@@ -8,7 +8,8 @@
#include "SkFilterShader.h"
#include "SkColorFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkShader.h"
#include "SkString.h"
@@ -20,7 +21,7 @@
filter->ref();
}
-SkFilterShader::SkFilterShader(SkFlattenableReadBuffer& buffer)
+SkFilterShader::SkFilterShader(SkReadBuffer& buffer)
: INHERITED(buffer) {
fShader = buffer.readShader();
fFilter = buffer.readColorFilter();
@@ -31,7 +32,7 @@
fShader->unref();
}
-void SkFilterShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkFilterShader::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fShader);
buffer.writeFlattenable(fFilter);
diff --git a/src/core/SkFilterShader.h b/src/core/SkFilterShader.h
index be19640..abb5165 100644
--- a/src/core/SkFilterShader.h
+++ b/src/core/SkFilterShader.h
@@ -28,8 +28,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkFilterShader)
protected:
- SkFilterShader(SkFlattenableReadBuffer& );
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkFilterShader(SkReadBuffer& );
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
SkShader* fShader;
diff --git a/src/core/SkFlattenable.cpp b/src/core/SkFlattenable.cpp
index 877fa0a..410fe0d 100644
--- a/src/core/SkFlattenable.cpp
+++ b/src/core/SkFlattenable.cpp
@@ -10,7 +10,7 @@
///////////////////////////////////////////////////////////////////////////////
-void SkFlattenable::flatten(SkFlattenableWriteBuffer&) const
+void SkFlattenable::flatten(SkWriteBuffer&) const
{
/* we don't write anything at the moment, but this allows our subclasses
to not know that, since we want them to always call INHERITED::flatten()
diff --git a/src/core/SkFlattenableBuffers.cpp b/src/core/SkFlattenableBuffers.cpp
deleted file mode 100644
index fc38529..0000000
--- a/src/core/SkFlattenableBuffers.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-
-/*
- * 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 "SkFlattenableBuffers.h"
-#include "SkPaint.h"
-#include "SkTypeface.h"
-
-#include "SkColorFilter.h"
-#include "SkDrawLooper.h"
-#include "SkImageFilter.h"
-#include "SkMaskFilter.h"
-#include "SkPathEffect.h"
-#include "SkPixelRef.h"
-#include "SkRasterizer.h"
-#include "SkShader.h"
-#include "SkUnitMapper.h"
-#include "SkXfermode.h"
-
-SkFlattenableReadBuffer::SkFlattenableReadBuffer() {
- // Set default values. These should be explicitly set by our client
- // via setFlags() if the buffer came from serialization.
- fFlags = 0;
- // TODO: remove this flag, since we're always floats (now)
- fFlags |= kScalarIsFloat_Flag;
- if (8 == sizeof(void*)) {
- fFlags |= kPtrIs64Bit_Flag;
- }
-}
-
-SkFlattenableReadBuffer::~SkFlattenableReadBuffer() { }
-
-void* SkFlattenableReadBuffer::readFunctionPtr() {
- void* proc;
- SkASSERT(sizeof(void*) == this->getArrayCount());
- this->readByteArray(&proc, sizeof(void*));
- return proc;
-}
-
-void SkFlattenableReadBuffer::readPaint(SkPaint* paint) {
- paint->unflatten(*this);
-}
-
-template <typename T> T* SkFlattenableReadBuffer::readFlattenableT() {
- return static_cast<T*>(this->readFlattenable(T::GetFlattenableType()));
-}
-
-SkColorFilter* SkFlattenableReadBuffer::readColorFilter() {
- return this->readFlattenableT<SkColorFilter>();
-}
-
-SkDrawLooper* SkFlattenableReadBuffer::readDrawLooper() {
- return this->readFlattenableT<SkDrawLooper>();
-}
-
-SkImageFilter* SkFlattenableReadBuffer::readImageFilter() {
- return this->readFlattenableT<SkImageFilter>();
-}
-
-SkMaskFilter* SkFlattenableReadBuffer::readMaskFilter() {
- return this->readFlattenableT<SkMaskFilter>();
-}
-
-SkPathEffect* SkFlattenableReadBuffer::readPathEffect() {
- return this->readFlattenableT<SkPathEffect>();
-}
-
-SkPixelRef* SkFlattenableReadBuffer::readPixelRef() {
- return this->readFlattenableT<SkPixelRef>();
-}
-
-SkRasterizer* SkFlattenableReadBuffer::readRasterizer() {
- return this->readFlattenableT<SkRasterizer>();
-}
-
-SkShader* SkFlattenableReadBuffer::readShader() {
- return this->readFlattenableT<SkShader>();
-}
-
-SkUnitMapper* SkFlattenableReadBuffer::readUnitMapper() {
- return this->readFlattenableT<SkUnitMapper>();
-}
-
-SkXfermode* SkFlattenableReadBuffer::readXfermode() {
- return this->readFlattenableT<SkXfermode>();
-}
-
-bool SkFlattenableReadBuffer::validate(bool isValid) {
- return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkFlattenableWriteBuffer::SkFlattenableWriteBuffer() {
- fFlags = (Flags)0;
-}
-
-SkFlattenableWriteBuffer::~SkFlattenableWriteBuffer() { }
-
-void SkFlattenableWriteBuffer::writeFunctionPtr(void* ptr) {
- void* ptrStorage[] = { ptr };
- this->writeByteArray(ptrStorage, sizeof(void*));
-}
-
-void SkFlattenableWriteBuffer::writePaint(const SkPaint& paint) {
- paint.flatten(*this);
-}
-
-void SkFlattenableWriteBuffer::flattenObject(const SkFlattenable* obj,
- SkFlattenableWriteBuffer& buffer) {
- obj->flatten(buffer);
-}
diff --git a/src/core/SkFlattenableSerialization.cpp b/src/core/SkFlattenableSerialization.cpp
index 5c83101..13fbe6e 100644
--- a/src/core/SkFlattenableSerialization.cpp
+++ b/src/core/SkFlattenableSerialization.cpp
@@ -9,11 +9,11 @@
#include "SkData.h"
#include "SkValidatingReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
SkData* SkValidatingSerializeFlattenable(SkFlattenable* flattenable) {
- SkOrderedWriteBuffer writer;
- writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer;
+ writer.setFlags(SkWriteBuffer::kValidation_Flag);
writer.writeFlattenable(flattenable);
uint32_t size = writer.bytesWritten();
void* data = sk_malloc_throw(size);
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index cb1d9fb..43e96bb 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkImageFilter.h"
#include "SkBitmap.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkRect.h"
#include "SkValidationUtils.h"
#if SK_SUPPORT_GPU
@@ -51,7 +52,7 @@
delete[] fInputs;
}
-SkImageFilter::SkImageFilter(int inputCount, SkFlattenableReadBuffer& buffer) {
+SkImageFilter::SkImageFilter(int inputCount, SkReadBuffer& buffer) {
fInputCount = buffer.readInt();
if (buffer.validate((fInputCount >= 0) && ((inputCount < 0) || (fInputCount == inputCount)))) {
fInputs = new SkImageFilter*[fInputCount];
@@ -78,7 +79,7 @@
}
}
-void SkImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkImageFilter::flatten(SkWriteBuffer& buffer) const {
buffer.writeInt(fInputCount);
for (int i = 0; i < fInputCount; i++) {
SkImageFilter* input = getInput(i);
diff --git a/src/core/SkImageInfo.cpp b/src/core/SkImageInfo.cpp
index 967b4f6..27c4573 100644
--- a/src/core/SkImageInfo.cpp
+++ b/src/core/SkImageInfo.cpp
@@ -6,7 +6,8 @@
*/
#include "SkImageInfo.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
static bool alpha_type_is_valid(SkAlphaType alphaType) {
return (alphaType >= 0) && (alphaType <= kLastEnum_SkAlphaType);
@@ -16,7 +17,7 @@
return (colorType >= 0) && (colorType <= kLastEnum_SkColorType);
}
-void SkImageInfo::unflatten(SkFlattenableReadBuffer& buffer) {
+void SkImageInfo::unflatten(SkReadBuffer& buffer) {
fWidth = buffer.read32();
fHeight = buffer.read32();
@@ -28,7 +29,7 @@
color_type_is_valid(fColorType));
}
-void SkImageInfo::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkImageInfo::flatten(SkWriteBuffer& buffer) const {
buffer.write32(fWidth);
buffer.write32(fHeight);
diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index 9adcd34..aa7c4f7 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -7,7 +7,8 @@
#include "SkMallocPixelRef.h"
#include "SkBitmap.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
// assumes ptr was allocated via sk_malloc
static void sk_free_releaseproc(void* ptr, void*) {
@@ -201,7 +202,7 @@
return this->info().getSafeSize(fRB);
}
-void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkMallocPixelRef::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.write32(SkToU32(fRB));
@@ -216,7 +217,7 @@
}
}
-SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer)
+SkMallocPixelRef::SkMallocPixelRef(SkReadBuffer& buffer)
: INHERITED(buffer, NULL)
, fReleaseProc(sk_free_releaseproc)
, fReleaseProcContext(NULL)
diff --git a/src/core/SkOrderedReadBuffer.h b/src/core/SkOrderedReadBuffer.h
deleted file mode 100644
index 2c4f480..0000000
--- a/src/core/SkOrderedReadBuffer.h
+++ /dev/null
@@ -1,140 +0,0 @@
-
-/*
- * 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 SkOrderedReadBuffer_DEFINED
-#define SkOrderedReadBuffer_DEFINED
-
-#include "SkRefCnt.h"
-#include "SkBitmapHeap.h"
-#include "SkFlattenableBuffers.h"
-#include "SkPath.h"
-#include "SkPicture.h"
-#include "SkReader32.h"
-
-class SkBitmap;
-
-#if defined(SK_DEBUG) && defined(SK_BUILD_FOR_MAC)
- #define DEBUG_NON_DETERMINISTIC_ASSERT
-#endif
-
-class SkOrderedReadBuffer : public SkFlattenableReadBuffer {
-public:
- SkOrderedReadBuffer();
- SkOrderedReadBuffer(const void* data, size_t size);
- SkOrderedReadBuffer(SkStream* stream);
- virtual ~SkOrderedReadBuffer();
-
- virtual SkOrderedReadBuffer* getOrderedBinaryBuffer() SK_OVERRIDE { return this; }
-
- SkReader32* getReader32() { return &fReader; }
-
- uint32_t size() { return fReader.size(); }
- uint32_t offset() { return fReader.offset(); }
- bool eof() { return fReader.eof(); }
- const void* skip(size_t size) { return fReader.skip(size); }
-
- // primitives
- virtual bool readBool() SK_OVERRIDE;
- virtual SkColor readColor() SK_OVERRIDE;
- virtual SkFixed readFixed() SK_OVERRIDE;
- virtual int32_t readInt() SK_OVERRIDE;
- virtual SkScalar readScalar() SK_OVERRIDE;
- virtual uint32_t readUInt() SK_OVERRIDE;
- virtual int32_t read32() SK_OVERRIDE;
-
- // strings -- the caller is responsible for freeing the string contents
- virtual void readString(SkString* string) SK_OVERRIDE;
- virtual void* readEncodedString(size_t* length, SkPaint::TextEncoding encoding) SK_OVERRIDE;
-
- // common data structures
- virtual SkFlattenable* readFlattenable(SkFlattenable::Type) SK_OVERRIDE;
- virtual void readPoint(SkPoint* point) SK_OVERRIDE;
- virtual void readMatrix(SkMatrix* matrix) SK_OVERRIDE;
- virtual void readIRect(SkIRect* rect) SK_OVERRIDE;
- virtual void readRect(SkRect* rect) SK_OVERRIDE;
- virtual void readRegion(SkRegion* region) SK_OVERRIDE;
- virtual void readPath(SkPath* path) SK_OVERRIDE;
-
- // binary data and arrays
- virtual bool readByteArray(void* value, size_t size) SK_OVERRIDE;
- virtual bool readColorArray(SkColor* colors, size_t size) SK_OVERRIDE;
- virtual bool readIntArray(int32_t* values, size_t size) SK_OVERRIDE;
- virtual bool readPointArray(SkPoint* points, size_t size) SK_OVERRIDE;
- virtual bool readScalarArray(SkScalar* values, size_t size) SK_OVERRIDE;
-
- // helpers to get info about arrays and binary data
- virtual uint32_t getArrayCount() SK_OVERRIDE;
-
- virtual void readBitmap(SkBitmap* bitmap) SK_OVERRIDE;
- virtual SkTypeface* readTypeface() SK_OVERRIDE;
-
- void setBitmapStorage(SkBitmapHeapReader* bitmapStorage) {
- SkRefCnt_SafeAssign(fBitmapStorage, bitmapStorage);
- }
-
- void setTypefaceArray(SkTypeface* array[], int count) {
- fTFArray = array;
- fTFCount = count;
- }
-
- /**
- * Call this with a pre-loaded array of Factories, in the same order as
- * were created/written by the writer. SkPicture uses this.
- */
- void setFactoryPlayback(SkFlattenable::Factory array[], int count) {
- fFactoryTDArray = NULL;
- fFactoryArray = array;
- fFactoryCount = count;
- }
-
- /**
- * Call this with an initially empty array, so the reader can cache each
- * factory it sees by name. Used by the pipe code in conjunction with
- * SkOrderedWriteBuffer::setNamedFactoryRecorder.
- */
- void setFactoryArray(SkTDArray<SkFlattenable::Factory>* array) {
- fFactoryTDArray = array;
- fFactoryArray = NULL;
- fFactoryCount = 0;
- }
-
- /**
- * Provide a function to decode an SkBitmap from encoded data. Only used if the writer
- * encoded the SkBitmap. If the proper decoder cannot be used, a red bitmap with the
- * appropriate size will be used.
- */
- void setBitmapDecoder(SkPicture::InstallPixelRefProc bitmapDecoder) {
- fBitmapDecoder = bitmapDecoder;
- }
-
-private:
- bool readArray(void* value, size_t size, size_t elementSize);
-
- SkReader32 fReader;
- void* fMemoryPtr;
-
- SkBitmapHeapReader* fBitmapStorage;
- SkTypeface** fTFArray;
- int fTFCount;
-
- SkTDArray<SkFlattenable::Factory>* fFactoryTDArray;
- SkFlattenable::Factory* fFactoryArray;
- int fFactoryCount;
-
- SkPicture::InstallPixelRefProc fBitmapDecoder;
-
-#ifdef DEBUG_NON_DETERMINISTIC_ASSERT
- // Debugging counter to keep track of how many bitmaps we
- // have decoded.
- int fDecodedBitmapIndex;
-#endif // DEBUG_NON_DETERMINISTIC_ASSERT
-
- typedef SkFlattenableReadBuffer INHERITED;
-};
-
-#endif // SkOrderedReadBuffer_DEFINED
diff --git a/src/core/SkOrderedWriteBuffer.h b/src/core/SkOrderedWriteBuffer.h
deleted file mode 100644
index 1f10152..0000000
--- a/src/core/SkOrderedWriteBuffer.h
+++ /dev/null
@@ -1,115 +0,0 @@
-
-/*
- * 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 SkOrderedWriteBuffer_DEFINED
-#define SkOrderedWriteBuffer_DEFINED
-
-#include "SkFlattenableBuffers.h"
-
-#include "SkRefCnt.h"
-#include "SkBitmapHeap.h"
-#include "SkPath.h"
-#include "SkPicture.h"
-#include "SkWriter32.h"
-
-class SkBitmap;
-class SkFlattenable;
-class SkFactorySet;
-class SkNamedFactorySet;
-class SkRefCntSet;
-
-class SkOrderedWriteBuffer : public SkFlattenableWriteBuffer {
-public:
- SkOrderedWriteBuffer();
- SkOrderedWriteBuffer(void* initialStorage, size_t storageSize);
- virtual ~SkOrderedWriteBuffer();
-
- virtual bool isOrderedBinaryBuffer() SK_OVERRIDE { return true; }
- virtual SkOrderedWriteBuffer* getOrderedBinaryBuffer() SK_OVERRIDE { return this; }
-
- SkWriter32* getWriter32() { return &fWriter; }
- void reset(void* storage = NULL, size_t storageSize = 0) {
- fWriter.reset(storage, storageSize);
- }
-
- void writeToMemory(void* dst) { fWriter.flatten(dst); }
- uint32_t* reserve(size_t size) { return fWriter.reserve(size); }
-
- size_t bytesWritten() const { return fWriter.bytesWritten(); }
- // Deprecated. Please call bytesWritten instead. TODO(mtklein): clean up
- size_t size() const { return this->bytesWritten(); }
-
- virtual void writeByteArray(const void* data, size_t size) SK_OVERRIDE;
- virtual void writeBool(bool value) SK_OVERRIDE;
- virtual void writeFixed(SkFixed value) SK_OVERRIDE;
- virtual void writeScalar(SkScalar value) SK_OVERRIDE;
- virtual void writeScalarArray(const SkScalar* value, uint32_t count) SK_OVERRIDE;
- virtual void writeInt(int32_t value) SK_OVERRIDE;
- virtual void writeIntArray(const int32_t* value, uint32_t count) SK_OVERRIDE;
- virtual void writeUInt(uint32_t value) SK_OVERRIDE;
- virtual void write32(int32_t value) SK_OVERRIDE;
- virtual void writeString(const char* value) SK_OVERRIDE;
- virtual void writeEncodedString(const void* value, size_t byteLength,
- SkPaint::TextEncoding encoding) SK_OVERRIDE;
-
- virtual void writeFlattenable(const SkFlattenable* flattenable) SK_OVERRIDE;
- virtual void writeColor(const SkColor& color) SK_OVERRIDE;
- virtual void writeColorArray(const SkColor* color, uint32_t count) SK_OVERRIDE;
- virtual void writePoint(const SkPoint& point) SK_OVERRIDE;
- virtual void writePointArray(const SkPoint* point, uint32_t count) SK_OVERRIDE;
- virtual void writeMatrix(const SkMatrix& matrix) SK_OVERRIDE;
- virtual void writeIRect(const SkIRect& rect)SK_OVERRIDE;
- virtual void writeRect(const SkRect& rect) SK_OVERRIDE;
- virtual void writeRegion(const SkRegion& region) SK_OVERRIDE;
- virtual void writePath(const SkPath& path) SK_OVERRIDE;
- virtual size_t writeStream(SkStream* stream, size_t length) SK_OVERRIDE;
-
- virtual void writeBitmap(const SkBitmap& bitmap) SK_OVERRIDE;
- virtual void writeTypeface(SkTypeface* typeface) SK_OVERRIDE;
-
- virtual bool writeToStream(SkWStream*) SK_OVERRIDE;
-
- SkFactorySet* setFactoryRecorder(SkFactorySet*);
- SkNamedFactorySet* setNamedFactoryRecorder(SkNamedFactorySet*);
-
- SkRefCntSet* getTypefaceRecorder() const { return fTFSet; }
- SkRefCntSet* setTypefaceRecorder(SkRefCntSet*);
-
- /**
- * Set an SkBitmapHeap to store bitmaps rather than flattening.
- *
- * Incompatible with an EncodeBitmap function. If an EncodeBitmap function is set, setting an
- * SkBitmapHeap will set the function to NULL in release mode and crash in debug.
- */
- void setBitmapHeap(SkBitmapHeap*);
-
- /**
- * Provide a function to encode an SkBitmap to an SkData. writeBitmap will attempt to use
- * bitmapEncoder to store the SkBitmap. If the reader does not provide a function to decode, it
- * will not be able to restore SkBitmaps, but will still be able to read the rest of the stream.
- * bitmapEncoder will never be called with a NULL pixelRefOffset.
- *
- * Incompatible with the SkBitmapHeap. If an encoder is set fBitmapHeap will be set to NULL in
- * release and crash in debug.
- */
- void setBitmapEncoder(SkPicture::EncodeBitmap bitmapEncoder);
-
-private:
- SkFactorySet* fFactorySet;
- SkNamedFactorySet* fNamedFactorySet;
- SkWriter32 fWriter;
-
- SkBitmapHeap* fBitmapHeap;
- SkRefCntSet* fTFSet;
-
- SkPicture::EncodeBitmap fBitmapEncoder;
-
- typedef SkFlattenableWriteBuffer INHERITED;
-};
-
-#endif // SkOrderedWriteBuffer_DEFINED
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index cc6d7ba..c3f217c 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -18,8 +18,8 @@
#include "SkImageFilter.h"
#include "SkMaskFilter.h"
#include "SkMaskGamma.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPaintDefaults.h"
#include "SkPaintOptionsAndroid.h"
#include "SkPathEffect.h"
@@ -1474,8 +1474,8 @@
}
static void add_flattenable(SkDescriptor* desc, uint32_t tag,
- SkOrderedWriteBuffer* buffer) {
- buffer->writeToMemory(desc->addEntry(tag, buffer->size(), NULL));
+ SkWriteBuffer* buffer) {
+ buffer->writeToMemory(desc->addEntry(tag, buffer->bytesWritten(), NULL));
}
// SkFontHost can override this choice in FilterRec()
@@ -1815,18 +1815,18 @@
SkMaskFilter* mf = this->getMaskFilter();
SkRasterizer* ra = this->getRasterizer();
- SkOrderedWriteBuffer peBuffer, mfBuffer, raBuffer;
+ SkWriteBuffer peBuffer, mfBuffer, raBuffer;
if (pe) {
peBuffer.writeFlattenable(pe);
- descSize += peBuffer.size();
+ descSize += peBuffer.bytesWritten();
entryCount += 1;
rec.fMaskFormat = SkMask::kA8_Format; // force antialiasing when we do the scan conversion
// seems like we could support kLCD as well at this point...
}
if (mf) {
mfBuffer.writeFlattenable(mf);
- descSize += mfBuffer.size();
+ descSize += mfBuffer.bytesWritten();
entryCount += 1;
rec.fMaskFormat = SkMask::kA8_Format; // force antialiasing with maskfilters
/* Pre-blend is not currently applied to filtered text.
@@ -1837,15 +1837,15 @@
}
if (ra) {
raBuffer.writeFlattenable(ra);
- descSize += raBuffer.size();
+ descSize += raBuffer.bytesWritten();
entryCount += 1;
rec.fMaskFormat = SkMask::kA8_Format; // force antialiasing when we do the scan conversion
}
#ifdef SK_BUILD_FOR_ANDROID
- SkOrderedWriteBuffer androidBuffer;
+ SkWriteBuffer androidBuffer;
fPaintOptionsAndroid.flatten(androidBuffer);
- descSize += androidBuffer.size();
+ descSize += androidBuffer.bytesWritten();
entryCount += 1;
#endif
@@ -1999,7 +1999,7 @@
/* To save space/time, we analyze the paint, and write a truncated version of
it if there are not tricky elements like shaders, etc.
*/
-void SkPaint::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPaint::flatten(SkWriteBuffer& buffer) const {
uint8_t flatFlags = 0;
if (this->getTypeface()) {
flatFlags |= kHasTypeface_FlatFlag;
@@ -2021,42 +2021,24 @@
}
#endif
- if (buffer.isOrderedBinaryBuffer()) {
- SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
- uint32_t* ptr = buffer.getOrderedBinaryBuffer()->reserve(kPODPaintSize);
+ SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
+ uint32_t* ptr = buffer.reserve(kPODPaintSize);
- ptr = write_scalar(ptr, this->getTextSize());
- ptr = write_scalar(ptr, this->getTextScaleX());
- ptr = write_scalar(ptr, this->getTextSkewX());
- ptr = write_scalar(ptr, this->getStrokeWidth());
- ptr = write_scalar(ptr, this->getStrokeMiter());
- *ptr++ = this->getColor();
- // previously flags:16, textAlign:8, flatFlags:8
- // now flags:16, hinting:4, textAlign:4, flatFlags:8
- *ptr++ = (this->getFlags() << 16) |
- // hinting added later. 0 in this nibble means use the default.
- ((this->getHinting()+1) << 12) |
- (this->getTextAlign() << 8) |
- flatFlags;
- *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
- this->getStyle(), this->getTextEncoding());
- } else {
- buffer.writeScalar(fTextSize);
- buffer.writeScalar(fTextScaleX);
- buffer.writeScalar(fTextSkewX);
- buffer.writeScalar(fWidth);
- buffer.writeScalar(fMiterLimit);
- buffer.writeColor(fColor);
- buffer.writeUInt(fFlags);
- buffer.writeUInt(fHinting);
- buffer.writeUInt(fTextAlign);
- buffer.writeUInt(flatFlags);
-
- buffer.writeUInt(fCapType);
- buffer.writeUInt(fJoinType);
- buffer.writeUInt(fStyle);
- buffer.writeUInt(fTextEncoding);
- }
+ ptr = write_scalar(ptr, this->getTextSize());
+ ptr = write_scalar(ptr, this->getTextScaleX());
+ ptr = write_scalar(ptr, this->getTextSkewX());
+ ptr = write_scalar(ptr, this->getStrokeWidth());
+ ptr = write_scalar(ptr, this->getStrokeMiter());
+ *ptr++ = this->getColor();
+ // previously flags:16, textAlign:8, flatFlags:8
+ // now flags:16, hinting:4, textAlign:4, flatFlags:8
+ *ptr++ = (this->getFlags() << 16) |
+ // hinting added later. 0 in this nibble means use the default.
+ ((this->getHinting()+1) << 12) |
+ (this->getTextAlign() << 8) |
+ flatFlags;
+ *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
+ this->getStyle(), this->getTextEncoding());
// now we're done with ptr and the (pre)reserved space. If we need to write
// additional fields, use the buffer directly
@@ -2087,58 +2069,38 @@
#endif
}
-void SkPaint::unflatten(SkFlattenableReadBuffer& buffer) {
+void SkPaint::unflatten(SkReadBuffer& buffer) {
uint8_t flatFlags = 0;
- if (buffer.isOrderedBinaryBuffer()) {
- SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
- const void* podData = buffer.getOrderedBinaryBuffer()->skip(kPODPaintSize);
- const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
+ SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
+ const void* podData = buffer.skip(kPODPaintSize);
+ const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
- // the order we read must match the order we wrote in flatten()
- this->setTextSize(read_scalar(pod));
- this->setTextScaleX(read_scalar(pod));
- this->setTextSkewX(read_scalar(pod));
- this->setStrokeWidth(read_scalar(pod));
- this->setStrokeMiter(read_scalar(pod));
- this->setColor(*pod++);
+ // the order we read must match the order we wrote in flatten()
+ this->setTextSize(read_scalar(pod));
+ this->setTextScaleX(read_scalar(pod));
+ this->setTextSkewX(read_scalar(pod));
+ this->setStrokeWidth(read_scalar(pod));
+ this->setStrokeMiter(read_scalar(pod));
+ this->setColor(*pod++);
- // previously flags:16, textAlign:8, flatFlags:8
- // now flags:16, hinting:4, textAlign:4, flatFlags:8
- uint32_t tmp = *pod++;
- this->setFlags(tmp >> 16);
+ // previously flags:16, textAlign:8, flatFlags:8
+ // now flags:16, hinting:4, textAlign:4, flatFlags:8
+ uint32_t tmp = *pod++;
+ this->setFlags(tmp >> 16);
- // hinting added later. 0 in this nibble means use the default.
- uint32_t hinting = (tmp >> 12) & 0xF;
- this->setHinting(0 == hinting ? kNormal_Hinting : static_cast<Hinting>(hinting-1));
+ // hinting added later. 0 in this nibble means use the default.
+ uint32_t hinting = (tmp >> 12) & 0xF;
+ this->setHinting(0 == hinting ? kNormal_Hinting : static_cast<Hinting>(hinting-1));
- this->setTextAlign(static_cast<Align>((tmp >> 8) & 0xF));
+ this->setTextAlign(static_cast<Align>((tmp >> 8) & 0xF));
- flatFlags = tmp & 0xFF;
+ flatFlags = tmp & 0xFF;
- tmp = *pod++;
- this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
- this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
- this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
- this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 0xFF));
- } else {
- this->setTextSize(buffer.readScalar());
- this->setTextScaleX(buffer.readScalar());
- this->setTextSkewX(buffer.readScalar());
- // Skip the hinting scalar factor, which is not supported.
- buffer.readScalar();
- this->setStrokeWidth(buffer.readScalar());
- this->setStrokeMiter(buffer.readScalar());
- this->setColor(buffer.readColor());
- this->setFlags(buffer.readUInt());
- this->setHinting(static_cast<SkPaint::Hinting>(buffer.readUInt()));
- this->setTextAlign(static_cast<SkPaint::Align>(buffer.readUInt()));
- flatFlags = buffer.readUInt();
-
- this->setStrokeCap(static_cast<SkPaint::Cap>(buffer.readUInt()));
- this->setStrokeJoin(static_cast<SkPaint::Join>(buffer.readUInt()));
- this->setStyle(static_cast<SkPaint::Style>(buffer.readUInt()));
- this->setTextEncoding(static_cast<SkPaint::TextEncoding>(buffer.readUInt()));
- }
+ tmp = *pod++;
+ this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
+ this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
+ this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
+ this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 0xFF));
if (flatFlags & kHasTypeface_FlatFlag) {
this->setTypeface(buffer.readTypeface());
diff --git a/src/core/SkPaintOptionsAndroid.cpp b/src/core/SkPaintOptionsAndroid.cpp
index f8a65e9..56f1bd1 100644
--- a/src/core/SkPaintOptionsAndroid.cpp
+++ b/src/core/SkPaintOptionsAndroid.cpp
@@ -7,7 +7,8 @@
*/
#include "SkPaintOptionsAndroid.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkTDict.h"
#include "SkThread.h"
#include <cstring>
@@ -25,13 +26,13 @@
return SkLanguage(tag, parentTagLen);
}
-void SkPaintOptionsAndroid::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPaintOptionsAndroid::flatten(SkWriteBuffer& buffer) const {
buffer.writeUInt(fFontVariant);
buffer.writeString(fLanguage.getTag().c_str());
buffer.writeBool(fUseFontFallbacks);
}
-void SkPaintOptionsAndroid::unflatten(SkFlattenableReadBuffer& buffer) {
+void SkPaintOptionsAndroid::unflatten(SkReadBuffer& buffer) {
fFontVariant = (FontVariant)buffer.readUInt();
SkString tag;
buffer.readString(&tag);
diff --git a/src/core/SkPathEffect.cpp b/src/core/SkPathEffect.cpp
index 59ba3ec..e181320 100644
--- a/src/core/SkPathEffect.cpp
+++ b/src/core/SkPathEffect.cpp
@@ -8,7 +8,8 @@
#include "SkPathEffect.h"
#include "SkPath.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
///////////////////////////////////////////////////////////////////////////////
@@ -39,13 +40,13 @@
/*
Format: [oe0-factory][pe1-factory][pe0-size][pe0-data][pe1-data]
*/
-void SkPairPathEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPairPathEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fPE0);
buffer.writeFlattenable(fPE1);
}
-SkPairPathEffect::SkPairPathEffect(SkFlattenableReadBuffer& buffer) {
+SkPairPathEffect::SkPairPathEffect(SkReadBuffer& buffer) {
fPE0 = buffer.readPathEffect();
fPE1 = buffer.readPathEffect();
// either of these may fail, so we have to check for nulls later on
diff --git a/src/core/SkPathHeap.cpp b/src/core/SkPathHeap.cpp
index c6e2129..a8271e1 100644
--- a/src/core/SkPathHeap.cpp
+++ b/src/core/SkPathHeap.cpp
@@ -8,7 +8,8 @@
#include "SkPathHeap.h"
#include "SkPath.h"
#include "SkStream.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include <new>
#define kPathCount 64
@@ -16,7 +17,7 @@
SkPathHeap::SkPathHeap() : fHeap(kPathCount * sizeof(SkPath)) {
}
-SkPathHeap::SkPathHeap(SkFlattenableReadBuffer& buffer)
+SkPathHeap::SkPathHeap(SkReadBuffer& buffer)
: fHeap(kPathCount * sizeof(SkPath)) {
const int count = buffer.readInt();
@@ -48,7 +49,7 @@
return fPaths.count();
}
-void SkPathHeap::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPathHeap::flatten(SkWriteBuffer& buffer) const {
int count = fPaths.count();
buffer.writeInt(count);
diff --git a/src/core/SkPathHeap.h b/src/core/SkPathHeap.h
index 095e84a..e3b0f7a 100644
--- a/src/core/SkPathHeap.h
+++ b/src/core/SkPathHeap.h
@@ -13,15 +13,15 @@
#include "SkTDArray.h"
class SkPath;
-class SkFlattenableReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkReadBuffer;
+class SkWriteBuffer;
class SkPathHeap : public SkRefCnt {
public:
SK_DECLARE_INST_COUNT(SkPathHeap)
SkPathHeap();
- SkPathHeap(SkFlattenableReadBuffer&);
+ SkPathHeap(SkReadBuffer&);
virtual ~SkPathHeap();
/** Copy the path into the heap, and return the new total number of paths.
@@ -36,7 +36,7 @@
return *fPaths[index];
}
- void flatten(SkFlattenableWriteBuffer&) const;
+ void flatten(SkWriteBuffer&) const;
private:
// we store the paths in the heap (placement new)
diff --git a/src/core/SkPictureFlat.h b/src/core/SkPictureFlat.h
index d92e4c4..431fa96 100644
--- a/src/core/SkPictureFlat.h
+++ b/src/core/SkPictureFlat.h
@@ -13,8 +13,8 @@
#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"
@@ -107,7 +107,7 @@
void setCount(int count);
SkRefCnt* set(int index, SkRefCnt*);
- void setupBuffer(SkOrderedReadBuffer& buffer) const {
+ void setupBuffer(SkReadBuffer& buffer) const {
buffer.setTypefaceArray((SkTypeface**)fArray, fCount);
}
@@ -128,7 +128,7 @@
SkFlattenable::Factory* base() const { return fArray; }
- void setupBuffer(SkOrderedReadBuffer& buffer) const {
+ void setupBuffer(SkReadBuffer& buffer) const {
buffer.setFactoryPlayback(fArray, fCount);
}
@@ -264,7 +264,7 @@
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());
@@ -272,7 +272,7 @@
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.
@@ -291,7 +291,7 @@
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);
@@ -556,7 +556,7 @@
// 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!
@@ -568,10 +568,10 @@
};
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);
}
};
diff --git a/src/core/SkPicturePlayback.cpp b/src/core/SkPicturePlayback.cpp
index 38f7deb..02d8828 100644
--- a/src/core/SkPicturePlayback.cpp
+++ b/src/core/SkPicturePlayback.cpp
@@ -8,8 +8,8 @@
#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"
@@ -322,7 +322,7 @@
#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);
@@ -370,7 +370,7 @@
}
}
-void SkPicturePlayback::flattenToBuffer(SkOrderedWriteBuffer& buffer) const {
+void SkPicturePlayback::flattenToBuffer(SkWriteBuffer& buffer) const {
int i, n;
if ((n = SafeCount(fBitmaps)) > 0) {
@@ -411,8 +411,8 @@
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);
@@ -425,7 +425,7 @@
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);
}
@@ -435,7 +435,7 @@
///////////////////////////////////////////////////////////////////////////////
/**
- * 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) {
@@ -443,9 +443,9 @@
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;
@@ -534,7 +534,7 @@
return false;
}
- SkOrderedReadBuffer buffer(storage.get(), size);
+ SkReadBuffer buffer(storage.get(), size);
buffer.setFlags(pictInfoFlagsToReadBufferFlags(info.fFlags));
fFactoryPlayback->setupBuffer(buffer);
@@ -554,7 +554,7 @@
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: {
diff --git a/src/core/SkPicturePlayback.h b/src/core/SkPicturePlayback.h
index 1cff0f9..efa6722 100644
--- a/src/core/SkPicturePlayback.h
+++ b/src/core/SkPicturePlayback.h
@@ -14,7 +14,7 @@
#include "SkBitmap.h"
#include "SkData.h"
#include "SkMatrix.h"
-#include "SkOrderedReadBuffer.h"
+#include "SkReadBuffer.h"
#include "SkPaint.h"
#include "SkPath.h"
#include "SkPathHeap.h"
@@ -192,8 +192,8 @@
private: // these help us with reading/writing
bool parseStreamTag(SkStream*, const SkPictInfo&, uint32_t tag, size_t size,
SkPicture::InstallPixelRefProc);
- bool parseBufferTag(SkOrderedReadBuffer&, uint32_t tag, size_t size);
- void flattenToBuffer(SkOrderedWriteBuffer&) const;
+ bool parseBufferTag(SkReadBuffer&, uint32_t tag, size_t size);
+ void flattenToBuffer(SkWriteBuffer&) const;
private:
// Only used by getBitmap() if the passed in index is SkBitmapHeap::INVALID_SLOT. This empty
diff --git a/src/core/SkPixelRef.cpp b/src/core/SkPixelRef.cpp
index d08796b..30b405f 100644
--- a/src/core/SkPixelRef.cpp
+++ b/src/core/SkPixelRef.cpp
@@ -6,7 +6,8 @@
* found in the LICENSE file.
*/
#include "SkPixelRef.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkThread.h"
#ifdef SK_USE_POSIX_THREADS
@@ -101,13 +102,13 @@
fPreLocked = false;
}
-static SkImageInfo read_info(SkFlattenableReadBuffer& buffer) {
+static SkImageInfo read_info(SkReadBuffer& buffer) {
SkImageInfo info;
info.unflatten(buffer);
return info;
}
-SkPixelRef::SkPixelRef(SkFlattenableReadBuffer& buffer, SkBaseMutex* mutex)
+SkPixelRef::SkPixelRef(SkReadBuffer& buffer, SkBaseMutex* mutex)
: INHERITED(buffer)
, fInfo(read_info(buffer))
{
@@ -148,7 +149,7 @@
#endif
}
-void SkPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPixelRef::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
fInfo.flatten(buffer);
buffer.writeBool(fIsImmutable);
diff --git a/src/core/SkOrderedReadBuffer.cpp b/src/core/SkReadBuffer.cpp
similarity index 80%
rename from src/core/SkOrderedReadBuffer.cpp
rename to src/core/SkReadBuffer.cpp
index 1ebaac4..6a590ed 100644
--- a/src/core/SkOrderedReadBuffer.cpp
+++ b/src/core/SkReadBuffer.cpp
@@ -8,11 +8,23 @@
#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;
@@ -28,7 +40,8 @@
#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;
@@ -45,7 +58,8 @@
#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);
@@ -64,46 +78,46 @@
#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();
@@ -112,32 +126,32 @@
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
@@ -150,31 +164,31 @@
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
@@ -183,7 +197,7 @@
// 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);
@@ -191,9 +205,9 @@
} 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 {
@@ -212,7 +226,7 @@
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",
@@ -256,7 +270,7 @@
bitmap->eraseColor(SK_ColorRED);
}
-SkTypeface* SkOrderedReadBuffer::readTypeface() {
+SkTypeface* SkReadBuffer::readTypeface() {
uint32_t index = fReader.readU32();
if (0 == index || index > (unsigned)fTFCount) {
@@ -270,7 +284,7 @@
}
}
-SkFlattenable* SkOrderedReadBuffer::readFlattenable(SkFlattenable::Type ft) {
+SkFlattenable* SkReadBuffer::readFlattenable(SkFlattenable::Type ft) {
//
// TODO: confirm that ft matches the factory we decide to use
//
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 2a4e9d3..8a33348 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -15,8 +15,8 @@
#include "SkGlyph.h"
#include "SkMaskFilter.h"
#include "SkMaskGamma.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPathEffect.h"
#include "SkRasterizer.h"
#include "SkRasterClip.h"
@@ -73,7 +73,7 @@
const void* data = desc->findEntry(tag, &len);
if (data) {
- SkOrderedReadBuffer buffer(data, len);
+ SkReadBuffer buffer(data, len);
obj = buffer.readFlattenable(ft);
SkASSERT(buffer.offset() == buffer.size());
}
@@ -118,7 +118,7 @@
uint32_t len;
const void* data = desc->findEntry(kAndroidOpts_SkDescriptorTag, &len);
if (data) {
- SkOrderedReadBuffer buffer(data, len);
+ SkReadBuffer buffer(data, len);
fPaintOptionsAndroid.unflatten(buffer);
SkASSERT(buffer.offset() == buffer.size());
}
@@ -147,10 +147,11 @@
SkAutoTUnref<SkTypeface> aur(newFace);
uint32_t newFontID = newFace->uniqueID();
- SkOrderedWriteBuffer androidBuffer;
+ SkWriteBuffer androidBuffer;
fPaintOptionsAndroid.flatten(androidBuffer);
- SkAutoDescriptor ad(sizeof(fRec) + androidBuffer.size() + SkDescriptor::ComputeOverhead(2));
+ SkAutoDescriptor ad(sizeof(fRec) + androidBuffer.bytesWritten()
+ + SkDescriptor::ComputeOverhead(2));
SkDescriptor* desc = ad.getDesc();
desc->init();
@@ -158,7 +159,7 @@
(SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag,
sizeof(fRec), &fRec);
androidBuffer.writeToMemory(desc->addEntry(kAndroidOpts_SkDescriptorTag,
- androidBuffer.size(), NULL));
+ androidBuffer.bytesWritten(), NULL));
newRec->fFontID = newFontID;
desc->computeChecksum();
diff --git a/src/core/SkShader.cpp b/src/core/SkShader.cpp
index 33fddb1..bebfc59 100644
--- a/src/core/SkShader.cpp
+++ b/src/core/SkShader.cpp
@@ -8,7 +8,8 @@
#include "SkScalar.h"
#include "SkShader.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPaint.h"
#include "SkMallocPixelRef.h"
@@ -17,7 +18,7 @@
SkDEBUGCODE(fInSetContext = false;)
}
-SkShader::SkShader(SkFlattenableReadBuffer& buffer)
+SkShader::SkShader(SkReadBuffer& buffer)
: INHERITED(buffer) {
if (buffer.readBool()) {
buffer.readMatrix(&fLocalMatrix);
@@ -32,7 +33,7 @@
SkASSERT(!fInSetContext);
}
-void SkShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkShader::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
bool hasLocalM = this->hasLocalMatrix();
buffer.writeBool(hasLocalM);
@@ -213,7 +214,7 @@
return SkColorGetA(fColor) == 255;
}
-SkColorShader::SkColorShader(SkFlattenableReadBuffer& b) : INHERITED(b) {
+SkColorShader::SkColorShader(SkReadBuffer& b) : INHERITED(b) {
fFlags = 0; // computed in setContext
fInheritColor = b.readBool();
@@ -223,7 +224,7 @@
fColor = b.readColor();
}
-void SkColorShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkColorShader::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeBool(fInheritColor);
if (fInheritColor) {
diff --git a/src/core/SkValidatingReadBuffer.cpp b/src/core/SkValidatingReadBuffer.cpp
index ab6a04a..ae7a836 100644
--- a/src/core/SkValidatingReadBuffer.cpp
+++ b/src/core/SkValidatingReadBuffer.cpp
@@ -14,7 +14,7 @@
SkValidatingReadBuffer::SkValidatingReadBuffer(const void* data, size_t size) :
fError(false) {
this->setMemory(data, size);
- this->setFlags(SkFlattenableReadBuffer::kValidation_Flag);
+ this->setFlags(SkReadBuffer::kValidation_Flag);
}
SkValidatingReadBuffer::~SkValidatingReadBuffer() {
diff --git a/src/core/SkValidatingReadBuffer.h b/src/core/SkValidatingReadBuffer.h
index 627c2c4..59b5c1a 100644
--- a/src/core/SkValidatingReadBuffer.h
+++ b/src/core/SkValidatingReadBuffer.h
@@ -10,14 +10,15 @@
#include "SkRefCnt.h"
#include "SkBitmapHeap.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPath.h"
#include "SkPicture.h"
#include "SkReader32.h"
class SkBitmap;
-class SkValidatingReadBuffer : public SkFlattenableReadBuffer {
+class SkValidatingReadBuffer : public SkReadBuffer {
public:
SkValidatingReadBuffer(const void* data, size_t size);
virtual ~SkValidatingReadBuffer();
@@ -77,7 +78,7 @@
SkReader32 fReader;
bool fError;
- typedef SkFlattenableReadBuffer INHERITED;
+ typedef SkReadBuffer INHERITED;
};
#endif // SkValidatingReadBuffer_DEFINED
diff --git a/src/core/SkOrderedWriteBuffer.cpp b/src/core/SkWriteBuffer.cpp
similarity index 77%
rename from src/core/SkOrderedWriteBuffer.cpp
rename to src/core/SkWriteBuffer.cpp
index 9107ecd..cbbb4c9 100644
--- a/src/core/SkOrderedWriteBuffer.cpp
+++ b/src/core/SkWriteBuffer.cpp
@@ -6,7 +6,7 @@
* found in the LICENSE file.
*/
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkBitmap.h"
#include "SkData.h"
#include "SkPixelRef.h"
@@ -14,8 +14,8 @@
#include "SkStream.h"
#include "SkTypeface.h"
-SkOrderedWriteBuffer::SkOrderedWriteBuffer()
- : INHERITED()
+SkWriteBuffer::SkWriteBuffer()
+ : fFlags(0)
, fFactorySet(NULL)
, fNamedFactorySet(NULL)
, fBitmapHeap(NULL)
@@ -23,8 +23,8 @@
, fBitmapEncoder(NULL) {
}
-SkOrderedWriteBuffer::SkOrderedWriteBuffer(void* storage, size_t storageSize)
- : INHERITED()
+SkWriteBuffer::SkWriteBuffer(void* storage, size_t storageSize)
+ : fFlags(0)
, fFactorySet(NULL)
, fNamedFactorySet(NULL)
, fWriter(storage, storageSize)
@@ -33,57 +33,57 @@
, fBitmapEncoder(NULL) {
}
-SkOrderedWriteBuffer::~SkOrderedWriteBuffer() {
+SkWriteBuffer::~SkWriteBuffer() {
SkSafeUnref(fFactorySet);
SkSafeUnref(fNamedFactorySet);
SkSafeUnref(fBitmapHeap);
SkSafeUnref(fTFSet);
}
-void SkOrderedWriteBuffer::writeByteArray(const void* data, size_t size) {
+void SkWriteBuffer::writeByteArray(const void* data, size_t size) {
fWriter.write32(size);
fWriter.writePad(data, size);
}
-void SkOrderedWriteBuffer::writeBool(bool value) {
+void SkWriteBuffer::writeBool(bool value) {
fWriter.writeBool(value);
}
-void SkOrderedWriteBuffer::writeFixed(SkFixed value) {
+void SkWriteBuffer::writeFixed(SkFixed value) {
fWriter.write32(value);
}
-void SkOrderedWriteBuffer::writeScalar(SkScalar value) {
+void SkWriteBuffer::writeScalar(SkScalar value) {
fWriter.writeScalar(value);
}
-void SkOrderedWriteBuffer::writeScalarArray(const SkScalar* value, uint32_t count) {
+void SkWriteBuffer::writeScalarArray(const SkScalar* value, uint32_t count) {
fWriter.write32(count);
fWriter.write(value, count * sizeof(SkScalar));
}
-void SkOrderedWriteBuffer::writeInt(int32_t value) {
+void SkWriteBuffer::writeInt(int32_t value) {
fWriter.write32(value);
}
-void SkOrderedWriteBuffer::writeIntArray(const int32_t* value, uint32_t count) {
+void SkWriteBuffer::writeIntArray(const int32_t* value, uint32_t count) {
fWriter.write32(count);
fWriter.write(value, count * sizeof(int32_t));
}
-void SkOrderedWriteBuffer::writeUInt(uint32_t value) {
+void SkWriteBuffer::writeUInt(uint32_t value) {
fWriter.write32(value);
}
-void SkOrderedWriteBuffer::write32(int32_t value) {
+void SkWriteBuffer::write32(int32_t value) {
fWriter.write32(value);
}
-void SkOrderedWriteBuffer::writeString(const char* value) {
+void SkWriteBuffer::writeString(const char* value) {
fWriter.writeString(value);
}
-void SkOrderedWriteBuffer::writeEncodedString(const void* value, size_t byteLength,
+void SkWriteBuffer::writeEncodedString(const void* value, size_t byteLength,
SkPaint::TextEncoding encoding) {
fWriter.writeInt(encoding);
fWriter.writeInt(byteLength);
@@ -91,46 +91,46 @@
}
-void SkOrderedWriteBuffer::writeColor(const SkColor& color) {
+void SkWriteBuffer::writeColor(const SkColor& color) {
fWriter.write32(color);
}
-void SkOrderedWriteBuffer::writeColorArray(const SkColor* color, uint32_t count) {
+void SkWriteBuffer::writeColorArray(const SkColor* color, uint32_t count) {
fWriter.write32(count);
fWriter.write(color, count * sizeof(SkColor));
}
-void SkOrderedWriteBuffer::writePoint(const SkPoint& point) {
+void SkWriteBuffer::writePoint(const SkPoint& point) {
fWriter.writeScalar(point.fX);
fWriter.writeScalar(point.fY);
}
-void SkOrderedWriteBuffer::writePointArray(const SkPoint* point, uint32_t count) {
+void SkWriteBuffer::writePointArray(const SkPoint* point, uint32_t count) {
fWriter.write32(count);
fWriter.write(point, count * sizeof(SkPoint));
}
-void SkOrderedWriteBuffer::writeMatrix(const SkMatrix& matrix) {
+void SkWriteBuffer::writeMatrix(const SkMatrix& matrix) {
fWriter.writeMatrix(matrix);
}
-void SkOrderedWriteBuffer::writeIRect(const SkIRect& rect) {
+void SkWriteBuffer::writeIRect(const SkIRect& rect) {
fWriter.write(&rect, sizeof(SkIRect));
}
-void SkOrderedWriteBuffer::writeRect(const SkRect& rect) {
+void SkWriteBuffer::writeRect(const SkRect& rect) {
fWriter.writeRect(rect);
}
-void SkOrderedWriteBuffer::writeRegion(const SkRegion& region) {
+void SkWriteBuffer::writeRegion(const SkRegion& region) {
fWriter.writeRegion(region);
}
-void SkOrderedWriteBuffer::writePath(const SkPath& path) {
+void SkWriteBuffer::writePath(const SkPath& path) {
fWriter.writePath(path);
}
-size_t SkOrderedWriteBuffer::writeStream(SkStream* stream, size_t length) {
+size_t SkWriteBuffer::writeStream(SkStream* stream, size_t length) {
fWriter.write32(length);
size_t bytesWritten = fWriter.readFromStream(stream, length);
if (bytesWritten < length) {
@@ -139,11 +139,11 @@
return bytesWritten;
}
-bool SkOrderedWriteBuffer::writeToStream(SkWStream* stream) {
+bool SkWriteBuffer::writeToStream(SkWStream* stream) {
return fWriter.writeToStream(stream);
}
-static void write_encoded_bitmap(SkOrderedWriteBuffer* buffer, SkData* data,
+static void write_encoded_bitmap(SkWriteBuffer* buffer, SkData* data,
const SkIPoint& origin) {
buffer->writeUInt(SkToU32(data->size()));
buffer->getWriter32()->writePad(data->data(), data->size());
@@ -151,7 +151,7 @@
buffer->write32(origin.fY);
}
-void SkOrderedWriteBuffer::writeBitmap(const SkBitmap& bitmap) {
+void SkWriteBuffer::writeBitmap(const SkBitmap& bitmap) {
// Record the width and height. This way if readBitmap fails a dummy bitmap can be drawn at the
// right size.
this->writeInt(bitmap.width());
@@ -211,7 +211,7 @@
bitmap.flatten(*this);
}
-void SkOrderedWriteBuffer::writeTypeface(SkTypeface* obj) {
+void SkWriteBuffer::writeTypeface(SkTypeface* obj) {
if (NULL == obj || NULL == fTFSet) {
fWriter.write32(0);
} else {
@@ -219,7 +219,7 @@
}
}
-SkFactorySet* SkOrderedWriteBuffer::setFactoryRecorder(SkFactorySet* rec) {
+SkFactorySet* SkWriteBuffer::setFactoryRecorder(SkFactorySet* rec) {
SkRefCnt_SafeAssign(fFactorySet, rec);
if (fNamedFactorySet != NULL) {
fNamedFactorySet->unref();
@@ -228,7 +228,7 @@
return rec;
}
-SkNamedFactorySet* SkOrderedWriteBuffer::setNamedFactoryRecorder(SkNamedFactorySet* rec) {
+SkNamedFactorySet* SkWriteBuffer::setNamedFactoryRecorder(SkNamedFactorySet* rec) {
SkRefCnt_SafeAssign(fNamedFactorySet, rec);
if (fFactorySet != NULL) {
fFactorySet->unref();
@@ -237,12 +237,12 @@
return rec;
}
-SkRefCntSet* SkOrderedWriteBuffer::setTypefaceRecorder(SkRefCntSet* rec) {
+SkRefCntSet* SkWriteBuffer::setTypefaceRecorder(SkRefCntSet* rec) {
SkRefCnt_SafeAssign(fTFSet, rec);
return rec;
}
-void SkOrderedWriteBuffer::setBitmapHeap(SkBitmapHeap* bitmapHeap) {
+void SkWriteBuffer::setBitmapHeap(SkBitmapHeap* bitmapHeap) {
SkRefCnt_SafeAssign(fBitmapHeap, bitmapHeap);
if (bitmapHeap != NULL) {
SkASSERT(NULL == fBitmapEncoder);
@@ -250,7 +250,7 @@
}
}
-void SkOrderedWriteBuffer::setBitmapEncoder(SkPicture::EncodeBitmap bitmapEncoder) {
+void SkWriteBuffer::setBitmapEncoder(SkPicture::EncodeBitmap bitmapEncoder) {
fBitmapEncoder = bitmapEncoder;
if (bitmapEncoder != NULL) {
SkASSERT(NULL == fBitmapHeap);
@@ -259,7 +259,7 @@
}
}
-void SkOrderedWriteBuffer::writeFlattenable(const SkFlattenable* flattenable) {
+void SkWriteBuffer::writeFlattenable(const SkFlattenable* flattenable) {
/*
* If we have a factoryset, then the first 32bits tell us...
* 0: failure to write the flattenable
@@ -318,7 +318,7 @@
// record the current size, so we can subtract after the object writes.
uint32_t offset = fWriter.bytesWritten();
// now flatten the object
- flattenObject(flattenable, *this);
+ flattenable->flatten(*this);
uint32_t objSize = fWriter.bytesWritten() - offset;
// record the obj's size
*fWriter.peek32(offset - sizeof(uint32_t)) = objSize;
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 176bcb5..66e0dea 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -10,7 +10,8 @@
#include "SkXfermode.h"
#include "SkXfermode_proccoeff.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMathPriv.h"
#include "SkString.h"
#include "SkUtilsArm.h"
@@ -860,7 +861,7 @@
}
}
-SkProcXfermode::SkProcXfermode(SkFlattenableReadBuffer& buffer)
+SkProcXfermode::SkProcXfermode(SkReadBuffer& buffer)
: SkXfermode(buffer) {
fProc = NULL;
if (!buffer.isCrossProcess()) {
@@ -868,7 +869,7 @@
}
}
-void SkProcXfermode::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkProcXfermode::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
if (!buffer.isCrossProcess()) {
buffer.writeFunctionPtr((void*)fProc);
@@ -1343,7 +1344,7 @@
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-SkProcCoeffXfermode::SkProcCoeffXfermode(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+SkProcCoeffXfermode::SkProcCoeffXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {
uint32_t mode32 = buffer.read32() % SK_ARRAY_COUNT(gProcCoeffs);
if (mode32 >= SK_ARRAY_COUNT(gProcCoeffs)) {
// out of range, just set to something harmless
@@ -1394,7 +1395,7 @@
}
#endif
-void SkProcCoeffXfermode::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkProcCoeffXfermode::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.write32(fMode);
}
@@ -1452,7 +1453,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkClearXfermode)
private:
- SkClearXfermode(SkFlattenableReadBuffer& buffer)
+ SkClearXfermode(SkReadBuffer& buffer)
: SkProcCoeffXfermode(buffer) {}
typedef SkProcCoeffXfermode INHERITED;
@@ -1514,7 +1515,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSrcXfermode)
private:
- SkSrcXfermode(SkFlattenableReadBuffer& buffer)
+ SkSrcXfermode(SkReadBuffer& buffer)
: SkProcCoeffXfermode(buffer) {}
typedef SkProcCoeffXfermode INHERITED;
@@ -1580,7 +1581,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDstInXfermode)
private:
- SkDstInXfermode(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+ SkDstInXfermode(SkReadBuffer& buffer) : INHERITED(buffer) {}
typedef SkProcCoeffXfermode INHERITED;
};
@@ -1623,7 +1624,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDstOutXfermode)
private:
- SkDstOutXfermode(SkFlattenableReadBuffer& buffer)
+ SkDstOutXfermode(SkReadBuffer& buffer)
: INHERITED(buffer) {}
typedef SkProcCoeffXfermode INHERITED;
diff --git a/src/core/SkXfermode_proccoeff.h b/src/core/SkXfermode_proccoeff.h
index 205edf2..1a2f7fc 100644
--- a/src/core/SkXfermode_proccoeff.h
+++ b/src/core/SkXfermode_proccoeff.h
@@ -2,7 +2,8 @@
#define SkXfermode_proccoeff_DEFINED
#include "SkXfermode.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
struct ProcCoeff {
SkXfermodeProc fProc;
@@ -35,9 +36,9 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkProcCoeffXfermode)
protected:
- SkProcCoeffXfermode(SkFlattenableReadBuffer& buffer);
+ SkProcCoeffXfermode(SkReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
Mode getMode() const {
return fMode;
diff --git a/src/effects/Sk1DPathEffect.cpp b/src/effects/Sk1DPathEffect.cpp
index 10a68b9..7354cda 100644
--- a/src/effects/Sk1DPathEffect.cpp
+++ b/src/effects/Sk1DPathEffect.cpp
@@ -8,7 +8,8 @@
#include "Sk1DPathEffect.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPathMeasure.h"
bool Sk1DPathEffect::filterPath(SkPath* dst, const SkPath& src,
@@ -146,7 +147,7 @@
}
}
-SkPath1DPathEffect::SkPath1DPathEffect(SkFlattenableReadBuffer& buffer) {
+SkPath1DPathEffect::SkPath1DPathEffect(SkReadBuffer& buffer) {
fAdvance = buffer.readScalar();
if (fAdvance > 0) {
buffer.readPath(&fPath);
@@ -164,7 +165,7 @@
return fInitialOffset;
}
-void SkPath1DPathEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPath1DPathEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fAdvance);
if (fAdvance > 0) {
diff --git a/src/effects/Sk2DPathEffect.cpp b/src/effects/Sk2DPathEffect.cpp
index dc15f07..252866c 100644
--- a/src/effects/Sk2DPathEffect.cpp
+++ b/src/effects/Sk2DPathEffect.cpp
@@ -8,7 +8,8 @@
#include "Sk2DPathEffect.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPath.h"
#include "SkRegion.h"
@@ -67,12 +68,12 @@
///////////////////////////////////////////////////////////////////////////////
-void Sk2DPathEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void Sk2DPathEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeMatrix(fMatrix);
}
-Sk2DPathEffect::Sk2DPathEffect(SkFlattenableReadBuffer& buffer) {
+Sk2DPathEffect::Sk2DPathEffect(SkReadBuffer& buffer) {
buffer.readMatrix(&fMatrix);
fMatrixIsInvertible = fMatrix.invert(&fInverse);
}
@@ -101,11 +102,11 @@
}
}
-SkLine2DPathEffect::SkLine2DPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+SkLine2DPathEffect::SkLine2DPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
fWidth = buffer.readScalar();
}
-void SkLine2DPathEffect::flatten(SkFlattenableWriteBuffer &buffer) const {
+void SkLine2DPathEffect::flatten(SkWriteBuffer &buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fWidth);
}
@@ -116,12 +117,12 @@
: INHERITED(m), fPath(p) {
}
-SkPath2DPathEffect::SkPath2DPathEffect(SkFlattenableReadBuffer& buffer)
+SkPath2DPathEffect::SkPath2DPathEffect(SkReadBuffer& buffer)
: INHERITED(buffer) {
buffer.readPath(&fPath);
}
-void SkPath2DPathEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPath2DPathEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePath(fPath);
}
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index 4bcb320..d3d9093 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -7,7 +7,8 @@
#include "SkAlphaThresholdFilter.h"
#include "SkBitmap.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkRegion.h"
class SK_API SkAlphaThresholdFilterImpl : public SkImageFilter {
@@ -17,8 +18,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAlphaThresholdFilterImpl)
protected:
- explicit SkAlphaThresholdFilterImpl(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ explicit SkAlphaThresholdFilterImpl(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
@@ -230,7 +231,7 @@
#endif
-SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(SkFlattenableReadBuffer& buffer)
+SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fInnerThreshold = buffer.readScalar();
fOuterThreshold = buffer.readScalar();
@@ -295,7 +296,7 @@
}
#endif
-void SkAlphaThresholdFilterImpl::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkAlphaThresholdFilterImpl::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fInnerThreshold);
buffer.writeScalar(fOuterThreshold);
diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp
index 93d708a..052b065 100644
--- a/src/effects/SkArithmeticMode.cpp
+++ b/src/effects/SkArithmeticMode.cpp
@@ -7,7 +7,8 @@
#include "SkArithmeticMode.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkString.h"
#include "SkUnPreMultiply.h"
#if SK_SUPPORT_GPU
@@ -40,14 +41,14 @@
#endif
private:
- SkArithmeticMode_scalar(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ SkArithmeticMode_scalar(SkReadBuffer& buffer) : INHERITED(buffer) {
fK[0] = buffer.readScalar();
fK[1] = buffer.readScalar();
fK[2] = buffer.readScalar();
fK[3] = buffer.readScalar();
}
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
INHERITED::flatten(buffer);
buffer.writeScalar(fK[0]);
buffer.writeScalar(fK[1]);
diff --git a/src/effects/SkAvoidXfermode.cpp b/src/effects/SkAvoidXfermode.cpp
index d76efb8..a333492 100644
--- a/src/effects/SkAvoidXfermode.cpp
+++ b/src/effects/SkAvoidXfermode.cpp
@@ -7,7 +7,8 @@
#include "SkAvoidXfermode.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkString.h"
SkAvoidXfermode::SkAvoidXfermode(SkColor opColor, U8CPU tolerance, Mode mode) {
@@ -20,14 +21,14 @@
fMode = mode;
}
-SkAvoidXfermode::SkAvoidXfermode(SkFlattenableReadBuffer& buffer)
+SkAvoidXfermode::SkAvoidXfermode(SkReadBuffer& buffer)
: INHERITED(buffer) {
fOpColor = buffer.readColor();
fDistMul = buffer.readUInt();
fMode = (Mode)buffer.readUInt();
}
-void SkAvoidXfermode::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkAvoidXfermode::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeColor(fOpColor);
diff --git a/src/effects/SkBicubicImageFilter.cpp b/src/effects/SkBicubicImageFilter.cpp
index 8b89a34..e44b717 100644
--- a/src/effects/SkBicubicImageFilter.cpp
+++ b/src/effects/SkBicubicImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkBicubicImageFilter.h"
#include "SkBitmap.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMatrix.h"
#include "SkRect.h"
#include "SkUnPreMultiply.h"
@@ -40,7 +41,7 @@
return SkNEW_ARGS(SkBicubicImageFilter, (scale, gMitchellCoefficients, input));
}
-SkBicubicImageFilter::SkBicubicImageFilter(SkFlattenableReadBuffer& buffer)
+SkBicubicImageFilter::SkBicubicImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
SkDEBUGCODE(bool success =) buffer.readScalarArray(fCoefficients, 16);
SkASSERT(success);
@@ -52,7 +53,7 @@
(fScale.fHeight >= 0));
}
-void SkBicubicImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBicubicImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalarArray(fCoefficients, 16);
buffer.writeScalar(fScale.fWidth);
diff --git a/src/effects/SkBitmapSource.cpp b/src/effects/SkBitmapSource.cpp
index 4aab92f..67567c5 100644
--- a/src/effects/SkBitmapSource.cpp
+++ b/src/effects/SkBitmapSource.cpp
@@ -8,7 +8,8 @@
#include "SkBitmapSource.h"
#include "SkDevice.h"
#include "SkCanvas.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkValidationUtils.h"
SkBitmapSource::SkBitmapSource(const SkBitmap& bitmap)
@@ -26,7 +27,7 @@
fDstRect(dstRect) {
}
-SkBitmapSource::SkBitmapSource(SkFlattenableReadBuffer& buffer)
+SkBitmapSource::SkBitmapSource(SkReadBuffer& buffer)
: INHERITED(0, buffer) {
fBitmap.unflatten(buffer);
buffer.readRect(&fSrcRect);
@@ -34,7 +35,7 @@
buffer.validate(buffer.isValid() && SkIsValidRect(fSrcRect) && SkIsValidRect(fDstRect));
}
-void SkBitmapSource::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBitmapSource::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
fBitmap.flatten(buffer);
buffer.writeRect(fSrcRect);
diff --git a/src/effects/SkBlurDrawLooper.cpp b/src/effects/SkBlurDrawLooper.cpp
index 51e6ec9..3a5c697 100644
--- a/src/effects/SkBlurDrawLooper.cpp
+++ b/src/effects/SkBlurDrawLooper.cpp
@@ -10,7 +10,8 @@
#include "SkBlurMaskFilter.h"
#include "SkCanvas.h"
#include "SkColorFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMaskFilter.h"
#include "SkPaint.h"
#include "SkString.h"
@@ -63,7 +64,7 @@
}
}
-SkBlurDrawLooper::SkBlurDrawLooper(SkFlattenableReadBuffer& buffer)
+SkBlurDrawLooper::SkBlurDrawLooper(SkReadBuffer& buffer)
: INHERITED(buffer) {
fDx = buffer.readScalar();
@@ -79,7 +80,7 @@
SkSafeUnref(fColorFilter);
}
-void SkBlurDrawLooper::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBlurDrawLooper::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fDx);
buffer.writeScalar(fDy);
diff --git a/src/effects/SkBlurImageFilter.cpp b/src/effects/SkBlurImageFilter.cpp
index 5d9a077..196baf4 100644
--- a/src/effects/SkBlurImageFilter.cpp
+++ b/src/effects/SkBlurImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkBitmap.h"
#include "SkBlurImageFilter.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkGpuBlurUtils.h"
#include "SkBlurImage_opts.h"
#if SK_SUPPORT_GPU
@@ -16,7 +17,7 @@
#include "SkImageFilterUtils.h"
#endif
-SkBlurImageFilter::SkBlurImageFilter(SkFlattenableReadBuffer& buffer)
+SkBlurImageFilter::SkBlurImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fSigma.fWidth = buffer.readScalar();
fSigma.fHeight = buffer.readScalar();
@@ -34,7 +35,7 @@
SkASSERT(sigmaX >= 0 && sigmaY >= 0);
}
-void SkBlurImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBlurImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fSigma.fWidth);
buffer.writeScalar(fSigma.fHeight);
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 3325232..2fffd05 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -9,7 +9,8 @@
#include "SkBlurMaskFilter.h"
#include "SkBlurMask.h"
#include "SkGpuBlurUtils.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMaskFilter.h"
#include "SkRRect.h"
#include "SkRTConf.h"
@@ -79,8 +80,8 @@
SkBlurMaskFilter::BlurStyle fBlurStyle;
uint32_t fBlurFlags;
- SkBlurMaskFilterImpl(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkBlurMaskFilterImpl(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
SkScalar computeXformedSigma(const SkMatrix& ctm) const {
bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
@@ -490,7 +491,7 @@
src.fRight + pad, src.fBottom + pad);
}
-SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkFlattenableReadBuffer& buffer)
+SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkReadBuffer& buffer)
: SkMaskFilter(buffer) {
fSigma = buffer.readScalar();
fBlurStyle = (SkBlurMaskFilter::BlurStyle)buffer.readInt();
@@ -499,7 +500,7 @@
SkASSERT((unsigned)fBlurStyle < SkBlurMaskFilter::kBlurStyleCount);
}
-void SkBlurMaskFilterImpl::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fSigma);
buffer.writeInt(fBlurStyle);
diff --git a/src/effects/SkColorFilterImageFilter.cpp b/src/effects/SkColorFilterImageFilter.cpp
index d648b6c..da494bb 100755
--- a/src/effects/SkColorFilterImageFilter.cpp
+++ b/src/effects/SkColorFilterImageFilter.cpp
@@ -11,7 +11,8 @@
#include "SkColorMatrixFilter.h"
#include "SkDevice.h"
#include "SkColorFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
namespace {
@@ -82,12 +83,12 @@
SkSafeRef(cf);
}
-SkColorFilterImageFilter::SkColorFilterImageFilter(SkFlattenableReadBuffer& buffer)
+SkColorFilterImageFilter::SkColorFilterImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fColorFilter = buffer.readColorFilter();
}
-void SkColorFilterImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkColorFilterImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fColorFilter);
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index d482a09..f9fa1fd 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -10,7 +10,8 @@
#include "SkBlitRow.h"
#include "SkColorFilter.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkUtils.h"
#include "SkString.h"
#include "SkValidationUtils.h"
@@ -92,13 +93,13 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkModeColorFilter)
protected:
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
this->INHERITED::flatten(buffer);
buffer.writeColor(fColor);
buffer.writeUInt(fMode);
}
- SkModeColorFilter(SkFlattenableReadBuffer& buffer) {
+ SkModeColorFilter(SkReadBuffer& buffer) {
fColor = buffer.readColor();
fMode = (SkXfermode::Mode)buffer.readUInt();
if (buffer.isValid()) {
@@ -446,7 +447,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Src_SkModeColorFilter)
protected:
- Src_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
+ Src_SkModeColorFilter(SkReadBuffer& buffer)
: INHERITED(buffer) {}
private:
@@ -482,7 +483,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SrcOver_SkModeColorFilter)
protected:
- SrcOver_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
+ SrcOver_SkModeColorFilter(SkReadBuffer& buffer)
: INHERITED(buffer) {
fColor32Proc = SkBlitRow::ColorProcFactory();
}
@@ -585,13 +586,13 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter)
protected:
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
this->INHERITED::flatten(buffer);
buffer.writeColor(fMul);
buffer.writeColor(fAdd);
}
- SkLightingColorFilter(SkFlattenableReadBuffer& buffer) {
+ SkLightingColorFilter(SkReadBuffer& buffer) {
fMul = buffer.readColor();
fAdd = buffer.readColor();
}
@@ -637,7 +638,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_JustAdd)
protected:
- SkLightingColorFilter_JustAdd(SkFlattenableReadBuffer& buffer)
+ SkLightingColorFilter_JustAdd(SkReadBuffer& buffer)
: INHERITED(buffer) {}
private:
@@ -678,7 +679,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_JustMul)
protected:
- SkLightingColorFilter_JustMul(SkFlattenableReadBuffer& buffer)
+ SkLightingColorFilter_JustMul(SkReadBuffer& buffer)
: INHERITED(buffer) {}
private:
@@ -722,7 +723,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_SingleMul)
protected:
- SkLightingColorFilter_SingleMul(SkFlattenableReadBuffer& buffer)
+ SkLightingColorFilter_SingleMul(SkReadBuffer& buffer)
: INHERITED(buffer) {}
private:
@@ -770,7 +771,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_NoPin)
protected:
- SkLightingColorFilter_NoPin(SkFlattenableReadBuffer& buffer)
+ SkLightingColorFilter_NoPin(SkReadBuffer& buffer)
: INHERITED(buffer) {}
private:
@@ -781,7 +782,7 @@
class SkSimpleColorFilter : public SkColorFilter {
public:
- static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
+ static SkFlattenable* CreateProc(SkReadBuffer& buffer) {
return SkNEW(SkSimpleColorFilter);
}
@@ -799,7 +800,7 @@
}
}
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {}
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {}
virtual Factory getFactory() const {
return CreateProc;
diff --git a/src/effects/SkColorMatrix.cpp b/src/effects/SkColorMatrix.cpp
index 535d6cc..0e2ede2 100644
--- a/src/effects/SkColorMatrix.cpp
+++ b/src/effects/SkColorMatrix.cpp
@@ -6,7 +6,8 @@
* found in the LICENSE file.
*/
#include "SkColorMatrix.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#define kRScale 0
#define kGScale 6
diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index fc1b77b..6b92571 100644
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -8,7 +8,8 @@
#include "SkColorMatrixFilter.h"
#include "SkColorMatrix.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkUnPreMultiply.h"
#include "SkString.h"
@@ -299,13 +300,13 @@
///////////////////////////////////////////////////////////////////////////////
-void SkColorMatrixFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkColorMatrixFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
SkASSERT(sizeof(fMatrix.fMat)/sizeof(SkScalar) == 20);
buffer.writeScalarArray(fMatrix.fMat, 20);
}
-SkColorMatrixFilter::SkColorMatrixFilter(SkFlattenableReadBuffer& buffer)
+SkColorMatrixFilter::SkColorMatrixFilter(SkReadBuffer& buffer)
: INHERITED(buffer) {
SkASSERT(buffer.getArrayCount() == 20);
if (buffer.readScalarArray(fMatrix.fMat, 20)) {
diff --git a/src/effects/SkComposeImageFilter.cpp b/src/effects/SkComposeImageFilter.cpp
index 7445bdf..c794b0d 100644
--- a/src/effects/SkComposeImageFilter.cpp
+++ b/src/effects/SkComposeImageFilter.cpp
@@ -7,7 +7,8 @@
#include "SkBitmap.h"
#include "SkComposeImageFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
SkComposeImageFilter::~SkComposeImageFilter() {
}
@@ -52,6 +53,6 @@
outer->filterBounds(tmp, ctm, dst);
}
-SkComposeImageFilter::SkComposeImageFilter(SkFlattenableReadBuffer& buffer)
+SkComposeImageFilter::SkComposeImageFilter(SkReadBuffer& buffer)
: INHERITED(2, buffer) {
}
diff --git a/src/effects/SkCornerPathEffect.cpp b/src/effects/SkCornerPathEffect.cpp
index f4c3147..5b61e06 100644
--- a/src/effects/SkCornerPathEffect.cpp
+++ b/src/effects/SkCornerPathEffect.cpp
@@ -10,7 +10,8 @@
#include "SkCornerPathEffect.h"
#include "SkPath.h"
#include "SkPoint.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
SkCornerPathEffect::SkCornerPathEffect(SkScalar radius) : fRadius(radius) {}
SkCornerPathEffect::~SkCornerPathEffect() {}
@@ -127,11 +128,11 @@
return true;
}
-void SkCornerPathEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkCornerPathEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fRadius);
}
-SkCornerPathEffect::SkCornerPathEffect(SkFlattenableReadBuffer& buffer) {
+SkCornerPathEffect::SkCornerPathEffect(SkReadBuffer& buffer) {
fRadius = buffer.readScalar();
}
diff --git a/src/effects/SkDashPathEffect.cpp b/src/effects/SkDashPathEffect.cpp
index 52875bc..8be5f1d 100644
--- a/src/effects/SkDashPathEffect.cpp
+++ b/src/effects/SkDashPathEffect.cpp
@@ -8,7 +8,8 @@
#include "SkDashPathEffect.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPathMeasure.h"
static inline int is_even(int x) {
@@ -532,7 +533,7 @@
return fInitialDashLength < 0 ? NULL : CreateProc;
}
-void SkDashPathEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkDashPathEffect::flatten(SkWriteBuffer& buffer) const {
SkASSERT(fInitialDashLength >= 0);
this->INHERITED::flatten(buffer);
@@ -543,11 +544,11 @@
buffer.writeScalarArray(fIntervals, fCount);
}
-SkFlattenable* SkDashPathEffect::CreateProc(SkFlattenableReadBuffer& buffer) {
+SkFlattenable* SkDashPathEffect::CreateProc(SkReadBuffer& buffer) {
return SkNEW_ARGS(SkDashPathEffect, (buffer));
}
-SkDashPathEffect::SkDashPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+SkDashPathEffect::SkDashPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {
fInitialDashIndex = buffer.readInt();
fInitialDashLength = buffer.readScalar();
fIntervalLength = buffer.readScalar();
diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp
index b7ec1de..de83442 100644
--- a/src/effects/SkDiscretePathEffect.cpp
+++ b/src/effects/SkDiscretePathEffect.cpp
@@ -8,7 +8,8 @@
#include "SkDiscretePathEffect.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPathMeasure.h"
#include "SkRandom.h"
@@ -70,13 +71,13 @@
return true;
}
-void SkDiscretePathEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkDiscretePathEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fSegLength);
buffer.writeScalar(fPerterb);
}
-SkDiscretePathEffect::SkDiscretePathEffect(SkFlattenableReadBuffer& buffer) {
+SkDiscretePathEffect::SkDiscretePathEffect(SkReadBuffer& buffer) {
fSegLength = buffer.readScalar();
fPerterb = buffer.readScalar();
}
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index fc8d3dd..e56cba1 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -6,7 +6,8 @@
*/
#include "SkDisplacementMapEffect.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkUnPreMultiply.h"
#include "SkColorPriv.h"
#if SK_SUPPORT_GPU
@@ -172,7 +173,7 @@
SkDisplacementMapEffect::~SkDisplacementMapEffect() {
}
-SkDisplacementMapEffect::SkDisplacementMapEffect(SkFlattenableReadBuffer& buffer)
+SkDisplacementMapEffect::SkDisplacementMapEffect(SkReadBuffer& buffer)
: INHERITED(2, buffer)
{
fXChannelSelector = (SkDisplacementMapEffect::ChannelSelectorType) buffer.readInt();
@@ -183,7 +184,7 @@
SkScalarIsFinite(fScale));
}
-void SkDisplacementMapEffect::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkDisplacementMapEffect::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt((int) fXChannelSelector);
buffer.writeInt((int) fYChannelSelector);
diff --git a/src/effects/SkDropShadowImageFilter.cpp b/src/effects/SkDropShadowImageFilter.cpp
index be99c67..0bc7e12 100644
--- a/src/effects/SkDropShadowImageFilter.cpp
+++ b/src/effects/SkDropShadowImageFilter.cpp
@@ -12,7 +12,8 @@
#include "SkCanvas.h"
#include "SkColorMatrixFilter.h"
#include "SkDevice.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
SkDropShadowImageFilter::SkDropShadowImageFilter(SkScalar dx, SkScalar dy, SkScalar sigma, SkColor color, SkImageFilter* input)
: INHERITED(input)
@@ -34,7 +35,7 @@
{
}
-SkDropShadowImageFilter::SkDropShadowImageFilter(SkFlattenableReadBuffer& buffer)
+SkDropShadowImageFilter::SkDropShadowImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fDx = buffer.readScalar();
fDy = buffer.readScalar();
@@ -47,7 +48,7 @@
SkScalarIsFinite(fSigmaY));
}
-void SkDropShadowImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const
+void SkDropShadowImageFilter::flatten(SkWriteBuffer& buffer) const
{
this->INHERITED::flatten(buffer);
buffer.writeScalar(fDx);
diff --git a/src/effects/SkEmbossMaskFilter.cpp b/src/effects/SkEmbossMaskFilter.cpp
index 5c95eeb..6747bf5 100644
--- a/src/effects/SkEmbossMaskFilter.cpp
+++ b/src/effects/SkEmbossMaskFilter.cpp
@@ -11,7 +11,8 @@
#include "SkBlurMaskFilter.h"
#include "SkBlurMask.h"
#include "SkEmbossMask.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkString.h"
static inline int pin2byte(int n) {
@@ -129,7 +130,7 @@
return true;
}
-SkEmbossMaskFilter::SkEmbossMaskFilter(SkFlattenableReadBuffer& buffer)
+SkEmbossMaskFilter::SkEmbossMaskFilter(SkReadBuffer& buffer)
: SkMaskFilter(buffer) {
SkASSERT(buffer.getArrayCount() == sizeof(Light));
buffer.readByteArray(&fLight, sizeof(Light));
@@ -137,7 +138,7 @@
fBlurSigma = buffer.readScalar();
}
-void SkEmbossMaskFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkEmbossMaskFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
Light tmpLight = fLight;
diff --git a/src/effects/SkKernel33MaskFilter.cpp b/src/effects/SkKernel33MaskFilter.cpp
index 821eebd..353661d 100644
--- a/src/effects/SkKernel33MaskFilter.cpp
+++ b/src/effects/SkKernel33MaskFilter.cpp
@@ -7,7 +7,8 @@
*/
#include "SkKernel33MaskFilter.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkString.h"
SkMask::Format SkKernel33ProcMaskFilter::getFormat() const {
@@ -75,12 +76,12 @@
return true;
}
-void SkKernel33ProcMaskFilter::flatten(SkFlattenableWriteBuffer& wb) const {
+void SkKernel33ProcMaskFilter::flatten(SkWriteBuffer& wb) const {
this->INHERITED::flatten(wb);
wb.writeInt(fPercent256);
}
-SkKernel33ProcMaskFilter::SkKernel33ProcMaskFilter(SkFlattenableReadBuffer& rb)
+SkKernel33ProcMaskFilter::SkKernel33ProcMaskFilter(SkReadBuffer& rb)
: SkMaskFilter(rb) {
fPercent256 = rb.readInt();
}
@@ -112,13 +113,13 @@
return (uint8_t)value;
}
-void SkKernel33MaskFilter::flatten(SkFlattenableWriteBuffer& wb) const {
+void SkKernel33MaskFilter::flatten(SkWriteBuffer& wb) const {
this->INHERITED::flatten(wb);
wb.writeIntArray(&fKernel[0][0], 9);
wb.writeInt(fShift);
}
-SkKernel33MaskFilter::SkKernel33MaskFilter(SkFlattenableReadBuffer& rb)
+SkKernel33MaskFilter::SkKernel33MaskFilter(SkReadBuffer& rb)
: SkKernel33ProcMaskFilter(rb) {
SkDEBUGCODE(bool success = )rb.readIntArray(&fKernel[0][0], 9);
SkASSERT(success);
diff --git a/src/effects/SkLayerDrawLooper.cpp b/src/effects/SkLayerDrawLooper.cpp
index 65f058b..6c7c3ce 100644
--- a/src/effects/SkLayerDrawLooper.cpp
+++ b/src/effects/SkLayerDrawLooper.cpp
@@ -7,7 +7,8 @@
*/
#include "SkCanvas.h"
#include "SkColor.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkLayerDrawLooper.h"
#include "SkString.h"
#include "SkStringUtils.h"
@@ -191,7 +192,7 @@
///////////////////////////////////////////////////////////////////////////////
-void SkLayerDrawLooper::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkLayerDrawLooper::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
#ifdef SK_DEBUG
@@ -220,7 +221,7 @@
}
}
-SkLayerDrawLooper::SkLayerDrawLooper(SkFlattenableReadBuffer& buffer)
+SkLayerDrawLooper::SkLayerDrawLooper(SkReadBuffer& buffer)
: INHERITED(buffer),
fRecs(NULL),
fTopRec(NULL),
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index ea5808c..6381c4d 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -9,7 +9,8 @@
#include "SkLayerRasterizer.h"
#include "SkDraw.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMask.h"
#include "SkMaskFilter.h"
#include "SkPaint.h"
@@ -143,7 +144,7 @@
return true;
}
-SkLayerRasterizer::SkLayerRasterizer(SkFlattenableReadBuffer& buffer)
+SkLayerRasterizer::SkLayerRasterizer(SkReadBuffer& buffer)
: SkRasterizer(buffer), fLayers(sizeof(SkLayerRasterizer_Rec)) {
int count = buffer.readInt();
@@ -156,7 +157,7 @@
}
}
-void SkLayerRasterizer::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt(fLayers.count());
diff --git a/src/effects/SkLerpXfermode.cpp b/src/effects/SkLerpXfermode.cpp
index d73ecf4..505ada0 100644
--- a/src/effects/SkLerpXfermode.cpp
+++ b/src/effects/SkLerpXfermode.cpp
@@ -7,7 +7,8 @@
#include "SkLerpXfermode.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkString.h"
SkXfermode* SkLerpXfermode::Create(SkScalar scale) {
@@ -22,12 +23,12 @@
SkLerpXfermode::SkLerpXfermode(unsigned scale256) : fScale256(scale256) {}
-SkLerpXfermode::SkLerpXfermode(SkFlattenableReadBuffer& buffer)
+SkLerpXfermode::SkLerpXfermode(SkReadBuffer& buffer)
: INHERITED(buffer) {
fScale256 = buffer.readUInt();
}
-void SkLerpXfermode::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkLerpXfermode::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeUInt(fScale256);
}
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 81c62fe..d16ecb1 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -8,9 +8,10 @@
#include "SkLightingImageFilter.h"
#include "SkBitmap.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkTypes.h"
#if SK_SUPPORT_GPU
@@ -243,7 +244,7 @@
}
}
-SkPoint3 readPoint3(SkFlattenableReadBuffer& buffer) {
+SkPoint3 readPoint3(SkReadBuffer& buffer) {
SkPoint3 point;
point.fX = buffer.readScalar();
point.fY = buffer.readScalar();
@@ -254,7 +255,7 @@
return point;
};
-void writePoint3(const SkPoint3& point, SkFlattenableWriteBuffer& buffer) {
+void writePoint3(const SkPoint3& point, SkWriteBuffer& buffer) {
buffer.writeScalar(point.fX);
buffer.writeScalar(point.fY);
buffer.writeScalar(point.fZ);
@@ -268,8 +269,8 @@
SkScalar kd() const { return fKD; }
protected:
- explicit SkDiffuseLightingImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ explicit SkDiffuseLightingImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
#if SK_SUPPORT_GPU
@@ -290,8 +291,8 @@
SkScalar shininess() const { return fShininess; }
protected:
- explicit SkSpecularLightingImageFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ explicit SkSpecularLightingImageFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
#if SK_SUPPORT_GPU
@@ -527,8 +528,8 @@
virtual SkLight* transform(const SkMatrix& matrix) const = 0;
// Defined below SkLight's subclasses.
- void flattenLight(SkFlattenableWriteBuffer& buffer) const;
- static SkLight* UnflattenLight(SkFlattenableReadBuffer& buffer);
+ void flattenLight(SkWriteBuffer& buffer) const;
+ static SkLight* UnflattenLight(SkReadBuffer& buffer);
protected:
SkLight(SkColor color)
@@ -537,11 +538,11 @@
SkIntToScalar(SkColorGetB(color))) {}
SkLight(const SkPoint3& color)
: fColor(color) {}
- SkLight(SkFlattenableReadBuffer& buffer) {
+ SkLight(SkReadBuffer& buffer) {
fColor = readPoint3(buffer);
}
- virtual void onFlattenLight(SkFlattenableWriteBuffer& buffer) const = 0;
+ virtual void onFlattenLight(SkWriteBuffer& buffer) const = 0;
private:
@@ -583,7 +584,7 @@
fDirection == o.fDirection;
}
- SkDistantLight(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ SkDistantLight(SkReadBuffer& buffer) : INHERITED(buffer) {
fDirection = readPoint3(buffer);
}
@@ -594,7 +595,7 @@
virtual SkLight* transform(const SkMatrix& matrix) const {
return new SkDistantLight(direction(), color());
}
- virtual void onFlattenLight(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
writePoint3(fDirection, buffer);
}
@@ -644,14 +645,14 @@
return new SkPointLight(location, color());
}
- SkPointLight(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ SkPointLight(SkReadBuffer& buffer) : INHERITED(buffer) {
fLocation = readPoint3(buffer);
}
protected:
SkPointLight(const SkPoint3& location, const SkPoint3& color)
: INHERITED(color), fLocation(location) {}
- virtual void onFlattenLight(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
writePoint3(fLocation, buffer);
}
@@ -725,7 +726,7 @@
SkScalar coneScale() const { return fConeScale; }
const SkPoint3& s() const { return fS; }
- SkSpotLight(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+ SkSpotLight(SkReadBuffer& buffer) : INHERITED(buffer) {
fLocation = readPoint3(buffer);
fTarget = readPoint3(buffer);
fSpecularExponent = buffer.readScalar();
@@ -750,7 +751,7 @@
fS(s)
{
}
- virtual void onFlattenLight(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
+ virtual void onFlattenLight(SkWriteBuffer& buffer) const SK_OVERRIDE {
writePoint3(fLocation, buffer);
writePoint3(fTarget, buffer);
buffer.writeScalar(fSpecularExponent);
@@ -794,14 +795,14 @@
///////////////////////////////////////////////////////////////////////////////
-void SkLight::flattenLight(SkFlattenableWriteBuffer& buffer) const {
+void SkLight::flattenLight(SkWriteBuffer& buffer) const {
// Write type first, then baseclass, then subclass.
buffer.writeInt(this->type());
writePoint3(fColor, buffer);
this->onFlattenLight(buffer);
}
-/*static*/ SkLight* SkLight::UnflattenLight(SkFlattenableReadBuffer& buffer) {
+/*static*/ SkLight* SkLight::UnflattenLight(SkReadBuffer& buffer) {
// Read type first.
const SkLight::LightType type = (SkLight::LightType)buffer.readInt();
switch (type) {
@@ -885,14 +886,14 @@
SkSafeUnref(fLight);
}
-SkLightingImageFilter::SkLightingImageFilter(SkFlattenableReadBuffer& buffer)
+SkLightingImageFilter::SkLightingImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fLight = SkLight::UnflattenLight(buffer);
fSurfaceScale = buffer.readScalar();
buffer.validate(SkScalarIsFinite(fSurfaceScale));
}
-void SkLightingImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
fLight->flattenLight(buffer);
buffer.writeScalar(fSurfaceScale);
@@ -908,14 +909,14 @@
{
}
-SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkFlattenableReadBuffer& buffer)
+SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkReadBuffer& buffer)
: INHERITED(buffer)
{
fKD = buffer.readScalar();
buffer.validate(SkScalarIsFinite(fKD) && (fKD >= 0));
}
-void SkDiffuseLightingImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkDiffuseLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fKD);
}
@@ -998,7 +999,7 @@
{
}
-SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkFlattenableReadBuffer& buffer)
+SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkReadBuffer& buffer)
: INHERITED(buffer)
{
fKS = buffer.readScalar();
@@ -1007,7 +1008,7 @@
SkScalarIsFinite(fShininess));
}
-void SkSpecularLightingImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkSpecularLightingImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fKS);
buffer.writeScalar(fShininess);
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index fd4826b..669af67 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -44,11 +44,11 @@
: INHERITED() {
}
-SkLumaColorFilter::SkLumaColorFilter(SkFlattenableReadBuffer& buffer)
+SkLumaColorFilter::SkLumaColorFilter(SkReadBuffer& buffer)
: INHERITED(buffer) {
}
-void SkLumaColorFilter::flatten(SkFlattenableWriteBuffer&) const {
+void SkLumaColorFilter::flatten(SkWriteBuffer&) const {
}
#ifdef SK_DEVELOPER
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index e6f3984..a1c62b7 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkBitmap.h"
#include "SkMagnifierImageFilter.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkValidationUtils.h"
////////////////////////////////////////////////////////////////////////////////
@@ -231,7 +232,7 @@
#endif
////////////////////////////////////////////////////////////////////////////////
-SkMagnifierImageFilter::SkMagnifierImageFilter(SkFlattenableReadBuffer& buffer)
+SkMagnifierImageFilter::SkMagnifierImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
float x = buffer.readScalar();
float y = buffer.readScalar();
@@ -269,7 +270,7 @@
}
#endif
-void SkMagnifierImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkMagnifierImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fSrcRect.x());
buffer.writeScalar(fSrcRect.y());
diff --git a/src/effects/SkMatrixConvolutionImageFilter.cpp b/src/effects/SkMatrixConvolutionImageFilter.cpp
index a450040..b73f623 100644
--- a/src/effects/SkMatrixConvolutionImageFilter.cpp
+++ b/src/effects/SkMatrixConvolutionImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkMatrixConvolutionImageFilter.h"
#include "SkBitmap.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkRect.h"
#include "SkUnPreMultiply.h"
@@ -57,7 +58,7 @@
SkASSERT(target.fY >= 0 && target.fY < kernelSize.fHeight);
}
-SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(SkFlattenableReadBuffer& buffer)
+SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
// We need to be able to read at most SK_MaxS32 bytes, so divide that
// by the size of a scalar to know how many scalars we can read.
@@ -88,7 +89,7 @@
tile_mode_is_valid(fTileMode));
}
-void SkMatrixConvolutionImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkMatrixConvolutionImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt(fKernelSize.fWidth);
buffer.writeInt(fKernelSize.fHeight);
diff --git a/src/effects/SkMergeImageFilter.cpp b/src/effects/SkMergeImageFilter.cpp
index 9c0fa92..086d8e6 100755
--- a/src/effects/SkMergeImageFilter.cpp
+++ b/src/effects/SkMergeImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkMergeImageFilter.h"
#include "SkCanvas.h"
#include "SkDevice.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkValidationUtils.h"
///////////////////////////////////////////////////////////////////////////////
@@ -148,7 +149,7 @@
return true;
}
-void SkMergeImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkMergeImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeBool(fModes != NULL);
@@ -157,7 +158,7 @@
}
}
-SkMergeImageFilter::SkMergeImageFilter(SkFlattenableReadBuffer& buffer)
+SkMergeImageFilter::SkMergeImageFilter(SkReadBuffer& buffer)
: INHERITED(-1, buffer) {
bool hasModes = buffer.readBool();
if (hasModes) {
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 5008ad1..7321eb2 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkMorphologyImageFilter.h"
#include "SkBitmap.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkRect.h"
#include "SkMorphology_opts.h"
#if SK_SUPPORT_GPU
@@ -20,7 +21,7 @@
#include "SkImageFilterUtils.h"
#endif
-SkMorphologyImageFilter::SkMorphologyImageFilter(SkFlattenableReadBuffer& buffer)
+SkMorphologyImageFilter::SkMorphologyImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fRadius.fWidth = buffer.readInt();
fRadius.fHeight = buffer.readInt();
@@ -36,7 +37,7 @@
}
-void SkMorphologyImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkMorphologyImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt(fRadius.fWidth);
buffer.writeInt(fRadius.fHeight);
diff --git a/src/effects/SkOffsetImageFilter.cpp b/src/effects/SkOffsetImageFilter.cpp
index e69cf41..16ce36f 100644
--- a/src/effects/SkOffsetImageFilter.cpp
+++ b/src/effects/SkOffsetImageFilter.cpp
@@ -9,7 +9,8 @@
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkDevice.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMatrix.h"
#include "SkPaint.h"
@@ -84,7 +85,7 @@
return true;
}
-void SkOffsetImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkOffsetImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fOffset);
}
@@ -94,7 +95,7 @@
fOffset.set(dx, dy);
}
-SkOffsetImageFilter::SkOffsetImageFilter(SkFlattenableReadBuffer& buffer)
+SkOffsetImageFilter::SkOffsetImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
buffer.readPoint(&fOffset);
buffer.validate(SkScalarIsFinite(fOffset.fX) &&
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index cdf8baf..48a25f9 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -8,7 +8,8 @@
#include "SkDither.h"
#include "SkPerlinNoiseShader.h"
#include "SkColorFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkShader.h"
#include "SkUnPreMultiply.h"
#include "SkString.h"
@@ -293,7 +294,7 @@
fMatrix.reset();
}
-SkPerlinNoiseShader::SkPerlinNoiseShader(SkFlattenableReadBuffer& buffer) :
+SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer) :
INHERITED(buffer), fPaintingData(NULL) {
fType = (SkPerlinNoiseShader::Type) buffer.readInt();
fBaseFrequencyX = buffer.readScalar();
@@ -314,7 +315,7 @@
SkDELETE(fPaintingData);
}
-void SkPerlinNoiseShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPerlinNoiseShader::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt((int) fType);
buffer.writeScalar(fBaseFrequencyX);
diff --git a/src/effects/SkPictureImageFilter.cpp b/src/effects/SkPictureImageFilter.cpp
index b054ee2..ae95760 100644
--- a/src/effects/SkPictureImageFilter.cpp
+++ b/src/effects/SkPictureImageFilter.cpp
@@ -8,7 +8,8 @@
#include "SkPictureImageFilter.h"
#include "SkDevice.h"
#include "SkCanvas.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkValidationUtils.h"
SkPictureImageFilter::SkPictureImageFilter(SkPicture* picture)
@@ -30,14 +31,14 @@
SkSafeUnref(fPicture);
}
-SkPictureImageFilter::SkPictureImageFilter(SkFlattenableReadBuffer& buffer)
+SkPictureImageFilter::SkPictureImageFilter(SkReadBuffer& buffer)
: INHERITED(0, buffer),
fPicture(NULL) {
// FIXME: unflatten picture here.
buffer.readRect(&fRect);
}
-void SkPictureImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPictureImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
// FIXME: flatten picture here.
buffer.writeRect(fRect);
diff --git a/src/effects/SkPixelXorXfermode.cpp b/src/effects/SkPixelXorXfermode.cpp
index b9c96dc..eaf7757 100644
--- a/src/effects/SkPixelXorXfermode.cpp
+++ b/src/effects/SkPixelXorXfermode.cpp
@@ -9,7 +9,8 @@
#include "SkPixelXorXfermode.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkString.h"
// we always return an opaque color, 'cause I don't know what to do with
@@ -20,12 +21,12 @@
return res;
}
-void SkPixelXorXfermode::flatten(SkFlattenableWriteBuffer& wb) const {
+void SkPixelXorXfermode::flatten(SkWriteBuffer& wb) const {
this->INHERITED::flatten(wb);
wb.writeColor(fOpColor);
}
-SkPixelXorXfermode::SkPixelXorXfermode(SkFlattenableReadBuffer& rb)
+SkPixelXorXfermode::SkPixelXorXfermode(SkReadBuffer& rb)
: INHERITED(rb) {
fOpColor = rb.readColor();
}
diff --git a/src/effects/SkRectShaderImageFilter.cpp b/src/effects/SkRectShaderImageFilter.cpp
index f55df2c..272a4af 100644
--- a/src/effects/SkRectShaderImageFilter.cpp
+++ b/src/effects/SkRectShaderImageFilter.cpp
@@ -9,7 +9,8 @@
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkDevice.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkShader.h"
SkRectShaderImageFilter* SkRectShaderImageFilter::Create(SkShader* s, const SkRect& rect) {
@@ -34,12 +35,12 @@
s->ref();
}
-SkRectShaderImageFilter::SkRectShaderImageFilter(SkFlattenableReadBuffer& buffer)
+SkRectShaderImageFilter::SkRectShaderImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fShader = buffer.readShader();
}
-void SkRectShaderImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkRectShaderImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fShader);
diff --git a/src/effects/SkResizeImageFilter.cpp b/src/effects/SkResizeImageFilter.cpp
index 4d70090..983dd15 100644
--- a/src/effects/SkResizeImageFilter.cpp
+++ b/src/effects/SkResizeImageFilter.cpp
@@ -10,7 +10,8 @@
#include "SkCanvas.h"
#include "SkDevice.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMatrix.h"
#include "SkRect.h"
@@ -22,14 +23,14 @@
fFilterLevel(filterLevel) {
}
-SkResizeImageFilter::SkResizeImageFilter(SkFlattenableReadBuffer& buffer)
+SkResizeImageFilter::SkResizeImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fSx = buffer.readScalar();
fSy = buffer.readScalar();
fFilterLevel = static_cast<SkPaint::FilterLevel>(buffer.readInt());
}
-void SkResizeImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkResizeImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fSx);
buffer.writeScalar(fSy);
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 2872ed1..eb3dbc3 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -2,7 +2,8 @@
#include "SkBitmap.h"
#include "SkTableColorFilter.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkUnPreMultiply.h"
#include "SkString.h"
@@ -60,8 +61,8 @@
};
protected:
- SkTable_ColorFilter(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkTable_ColorFilter(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
private:
mutable const SkBitmap* fBitmap; // lazily allocated
@@ -166,7 +167,7 @@
#include "SkPackBits.h"
-void SkTable_ColorFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkTable_ColorFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
uint8_t storage[5*256];
@@ -180,7 +181,7 @@
buffer.writeByteArray(storage, size);
}
-SkTable_ColorFilter::SkTable_ColorFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+SkTable_ColorFilter::SkTable_ColorFilter(SkReadBuffer& buffer) : INHERITED(buffer) {
fBitmap = NULL;
uint8_t storage[5*256];
diff --git a/src/effects/SkTableMaskFilter.cpp b/src/effects/SkTableMaskFilter.cpp
index eb80abb..27280d3 100644
--- a/src/effects/SkTableMaskFilter.cpp
+++ b/src/effects/SkTableMaskFilter.cpp
@@ -8,7 +8,8 @@
#include "SkTableMaskFilter.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkString.h"
SkTableMaskFilter::SkTableMaskFilter() {
@@ -69,12 +70,12 @@
return SkMask::kA8_Format;
}
-void SkTableMaskFilter::flatten(SkFlattenableWriteBuffer& wb) const {
+void SkTableMaskFilter::flatten(SkWriteBuffer& wb) const {
this->INHERITED::flatten(wb);
wb.writeByteArray(fTable, 256);
}
-SkTableMaskFilter::SkTableMaskFilter(SkFlattenableReadBuffer& rb)
+SkTableMaskFilter::SkTableMaskFilter(SkReadBuffer& rb)
: INHERITED(rb) {
SkASSERT(256 == rb.getArrayCount());
rb.readByteArray(fTable, 256);
diff --git a/src/effects/SkTestImageFilters.cpp b/src/effects/SkTestImageFilters.cpp
index cc6d1ad..96226f5 100755
--- a/src/effects/SkTestImageFilters.cpp
+++ b/src/effects/SkTestImageFilters.cpp
@@ -2,7 +2,8 @@
#include "SkTestImageFilters.h"
#include "SkCanvas.h"
#include "SkDevice.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
// Simple helper canvas that "takes ownership" of the provided device, so that
// when this canvas goes out of scope, so will its device. Could be replaced
@@ -70,13 +71,13 @@
return true;
}
-void SkDownSampleImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkDownSampleImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeScalar(fScale);
}
-SkDownSampleImageFilter::SkDownSampleImageFilter(SkFlattenableReadBuffer& buffer)
+SkDownSampleImageFilter::SkDownSampleImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
fScale = buffer.readScalar();
buffer.validate(SkScalarIsFinite(fScale));
diff --git a/src/effects/SkTileImageFilter.cpp b/src/effects/SkTileImageFilter.cpp
index 08dfec4..f0b7fda 100644
--- a/src/effects/SkTileImageFilter.cpp
+++ b/src/effects/SkTileImageFilter.cpp
@@ -9,7 +9,8 @@
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkDevice.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMatrix.h"
#include "SkPaint.h"
#include "SkShader.h"
@@ -73,14 +74,14 @@
return true;
}
-SkTileImageFilter::SkTileImageFilter(SkFlattenableReadBuffer& buffer)
+SkTileImageFilter::SkTileImageFilter(SkReadBuffer& buffer)
: INHERITED(1, buffer) {
buffer.readRect(&fSrcRect);
buffer.readRect(&fDstRect);
buffer.validate(buffer.isValid() && SkIsValidRect(fSrcRect) && SkIsValidRect(fDstRect));
}
-void SkTileImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkTileImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeRect(fSrcRect);
buffer.writeRect(fDstRect);
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index beb1de2..b3ab9ff 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -9,7 +9,8 @@
#include "SkCanvas.h"
#include "SkDevice.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkXfermode.h"
#if SK_SUPPORT_GPU
#include "GrContext.h"
@@ -32,12 +33,12 @@
SkSafeUnref(fMode);
}
-SkXfermodeImageFilter::SkXfermodeImageFilter(SkFlattenableReadBuffer& buffer)
+SkXfermodeImageFilter::SkXfermodeImageFilter(SkReadBuffer& buffer)
: INHERITED(2, buffer) {
fMode = buffer.readXfermode();
}
-void SkXfermodeImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkXfermodeImageFilter::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fMode);
}
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index 6925ad2..1da259a 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -143,7 +143,7 @@
return packed >> 4;
}
-SkGradientShaderBase::SkGradientShaderBase(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
+SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buffer) {
fCacheAlpha = 256;
fMapper = buffer.readUnitMapper();
@@ -205,7 +205,7 @@
fColorsAreOpaque = colorAlpha == 0xFF;
}
-void SkGradientShaderBase::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeFlattenable(fMapper);
buffer.writeColorArray(fOrigColors, fColorCount);
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index f45b777..184ef8e 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -11,7 +11,8 @@
#include "SkGradientShader.h"
#include "SkClampRange.h"
#include "SkColorPriv.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkMallocPixelRef.h"
#include "SkUnitMapper.h"
#include "SkUtils.h"
@@ -129,8 +130,8 @@
protected:
- SkGradientShaderBase(SkFlattenableReadBuffer& );
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkGradientShaderBase(SkReadBuffer& );
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
SK_DEVELOPER_TO_STRING()
SkUnitMapper* fMapper;
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 7045296..bd66f7c 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -59,13 +59,13 @@
pts_to_unit_matrix(pts, &fPtsToUnit);
}
-SkLinearGradient::SkLinearGradient(SkFlattenableReadBuffer& buffer)
+SkLinearGradient::SkLinearGradient(SkReadBuffer& buffer)
: INHERITED(buffer)
, fStart(buffer.readPoint())
, fEnd(buffer.readPoint()) {
}
-void SkLinearGradient::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkLinearGradient::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fStart);
buffer.writePoint(fEnd);
diff --git a/src/effects/gradients/SkLinearGradient.h b/src/effects/gradients/SkLinearGradient.h
index 24c6cab..ed0c70b 100644
--- a/src/effects/gradients/SkLinearGradient.h
+++ b/src/effects/gradients/SkLinearGradient.h
@@ -26,8 +26,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLinearGradient)
protected:
- SkLinearGradient(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ SkLinearGradient(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
private:
typedef SkGradientShaderBase INHERITED;
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index 50e58bc..efa82f4 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -239,13 +239,13 @@
return kRadial_GradientType;
}
-SkRadialGradient::SkRadialGradient(SkFlattenableReadBuffer& buffer)
+SkRadialGradient::SkRadialGradient(SkReadBuffer& buffer)
: INHERITED(buffer),
fCenter(buffer.readPoint()),
fRadius(buffer.readScalar()) {
}
-void SkRadialGradient::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkRadialGradient::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fCenter);
buffer.writeScalar(fRadius);
diff --git a/src/effects/gradients/SkRadialGradient.h b/src/effects/gradients/SkRadialGradient.h
index fa0a969..4ff3951 100644
--- a/src/effects/gradients/SkRadialGradient.h
+++ b/src/effects/gradients/SkRadialGradient.h
@@ -28,8 +28,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRadialGradient)
protected:
- SkRadialGradient(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ SkRadialGradient(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
private:
typedef SkGradientShaderBase INHERITED;
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index d60d8b6..494569d 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -42,12 +42,12 @@
return kSweep_GradientType;
}
-SkSweepGradient::SkSweepGradient(SkFlattenableReadBuffer& buffer)
+SkSweepGradient::SkSweepGradient(SkReadBuffer& buffer)
: INHERITED(buffer),
fCenter(buffer.readPoint()) {
}
-void SkSweepGradient::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkSweepGradient::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fCenter);
}
diff --git a/src/effects/gradients/SkSweepGradient.h b/src/effects/gradients/SkSweepGradient.h
index 8b685bc..18d5ddc 100644
--- a/src/effects/gradients/SkSweepGradient.h
+++ b/src/effects/gradients/SkSweepGradient.h
@@ -29,8 +29,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSweepGradient)
protected:
- SkSweepGradient(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ SkSweepGradient(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
private:
typedef SkGradientShaderBase INHERITED;
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.cpp b/src/effects/gradients/SkTwoPointConicalGradient.cpp
index a9bd1c2..6a503d2 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient.cpp
@@ -310,7 +310,7 @@
}
SkTwoPointConicalGradient::SkTwoPointConicalGradient(
- SkFlattenableReadBuffer& buffer)
+ SkReadBuffer& buffer)
: INHERITED(buffer),
fCenter1(buffer.readPoint()),
fCenter2(buffer.readPoint()),
@@ -320,7 +320,7 @@
};
void SkTwoPointConicalGradient::flatten(
- SkFlattenableWriteBuffer& buffer) const {
+ SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fCenter1);
buffer.writePoint(fCenter2);
diff --git a/src/effects/gradients/SkTwoPointConicalGradient.h b/src/effects/gradients/SkTwoPointConicalGradient.h
index 1358f0b..20a3da8 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient.h
+++ b/src/effects/gradients/SkTwoPointConicalGradient.h
@@ -70,8 +70,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTwoPointConicalGradient)
protected:
- SkTwoPointConicalGradient(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ SkTwoPointConicalGradient(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
private:
typedef SkGradientShaderBase INHERITED;
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp
index 207f3db..103e7d4 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.cpp
+++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp
@@ -334,7 +334,7 @@
#endif
SkTwoPointRadialGradient::SkTwoPointRadialGradient(
- SkFlattenableReadBuffer& buffer)
+ SkReadBuffer& buffer)
: INHERITED(buffer),
fCenter1(buffer.readPoint()),
fCenter2(buffer.readPoint()),
@@ -344,7 +344,7 @@
};
void SkTwoPointRadialGradient::flatten(
- SkFlattenableWriteBuffer& buffer) const {
+ SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writePoint(fCenter1);
buffer.writePoint(fCenter2);
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.h b/src/effects/gradients/SkTwoPointRadialGradient.h
index 444c23d..e050804 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.h
+++ b/src/effects/gradients/SkTwoPointRadialGradient.h
@@ -37,8 +37,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTwoPointRadialGradient)
protected:
- SkTwoPointRadialGradient(SkFlattenableReadBuffer& buffer);
- virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
+ SkTwoPointRadialGradient(SkReadBuffer& buffer);
+ virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE;
private:
typedef SkGradientShaderBase INHERITED;
diff --git a/src/images/SkImageRef.cpp b/src/images/SkImageRef.cpp
index 2c1ec38..ea12964 100644
--- a/src/images/SkImageRef.cpp
+++ b/src/images/SkImageRef.cpp
@@ -7,7 +7,8 @@
*/
#include "SkImageRef.h"
#include "SkBitmap.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkImageDecoder.h"
#include "SkStream.h"
#include "SkTemplates.h"
@@ -162,7 +163,7 @@
///////////////////////////////////////////////////////////////////////////////
-SkImageRef::SkImageRef(SkFlattenableReadBuffer& buffer, SkBaseMutex* mutex)
+SkImageRef::SkImageRef(SkReadBuffer& buffer, SkBaseMutex* mutex)
: INHERITED(buffer, mutex), fErrorInDecoding(false) {
fSampleSize = buffer.readInt();
fDoDither = buffer.readBool();
@@ -179,7 +180,7 @@
fFactory = NULL;
}
-void SkImageRef::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkImageRef::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt(fSampleSize);
diff --git a/src/images/SkImageRef_GlobalPool.cpp b/src/images/SkImageRef_GlobalPool.cpp
index f91ceba..2659e8b 100644
--- a/src/images/SkImageRef_GlobalPool.cpp
+++ b/src/images/SkImageRef_GlobalPool.cpp
@@ -64,7 +64,7 @@
GetGlobalPool()->canLosePixels(this);
}
-SkImageRef_GlobalPool::SkImageRef_GlobalPool(SkFlattenableReadBuffer& buffer)
+SkImageRef_GlobalPool::SkImageRef_GlobalPool(SkReadBuffer& buffer)
: INHERITED(buffer, &gGlobalPoolMutex) {
SkASSERT(&gGlobalPoolMutex == this->mutex());
SkAutoMutexAcquire ac(gGlobalPoolMutex);
diff --git a/src/images/SkImageRef_ashmem.cpp b/src/images/SkImageRef_ashmem.cpp
index 14dedf8..3c7d5c1 100644
--- a/src/images/SkImageRef_ashmem.cpp
+++ b/src/images/SkImageRef_ashmem.cpp
@@ -7,7 +7,8 @@
#include "SkImageRef_ashmem.h"
#include "SkImageDecoder.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkThread.h"
#include "android/ashmem.h"
@@ -210,12 +211,12 @@
fBitmap.setPixels(NULL, NULL);
}
-void SkImageRef_ashmem::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkImageRef_ashmem::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeString(getURI());
}
-SkImageRef_ashmem::SkImageRef_ashmem(SkFlattenableReadBuffer& buffer)
+SkImageRef_ashmem::SkImageRef_ashmem(SkReadBuffer& buffer)
: INHERITED(buffer) {
fRec.fFD = -1;
fRec.fAddr = NULL;
diff --git a/src/images/SkImageRef_ashmem.h b/src/images/SkImageRef_ashmem.h
index fa30baf..cf6e903 100644
--- a/src/images/SkImageRef_ashmem.h
+++ b/src/images/SkImageRef_ashmem.h
@@ -25,8 +25,8 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkImageRef_ashmem)
protected:
- SkImageRef_ashmem(SkFlattenableReadBuffer&);
- virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+ SkImageRef_ashmem(SkReadBuffer&);
+ virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
virtual bool onDecode(SkImageDecoder* codec, SkStreamRewindable* stream,
SkBitmap* bitmap, SkBitmap::Config config,
diff --git a/src/lazy/SkCachingPixelRef.h b/src/lazy/SkCachingPixelRef.h
index b73a2ca..9fc71c3 100644
--- a/src/lazy/SkCachingPixelRef.h
+++ b/src/lazy/SkCachingPixelRef.h
@@ -49,9 +49,9 @@
return fImageGenerator->refEncodedData();
}
// No need to flatten this object. When flattening an SkBitmap,
- // SkOrderedWriteBuffer will check the encoded data and write that
+ // SkWriteBuffer will check the encoded data and write that
// instead.
- // Future implementations of SkFlattenableWriteBuffer will need to
+ // Future implementations of SkWriteBuffer will need to
// special case for onRefEncodedData as well.
SK_DECLARE_UNFLATTENABLE_OBJECT()
diff --git a/src/opts/SkXfermode_opts_arm_neon.cpp b/src/opts/SkXfermode_opts_arm_neon.cpp
index 6a79b73..da14e66 100644
--- a/src/opts/SkXfermode_opts_arm_neon.cpp
+++ b/src/opts/SkXfermode_opts_arm_neon.cpp
@@ -690,7 +690,7 @@
extern SkXfermodeProcSIMD gNEONXfermodeProcs[];
-SkNEONProcCoeffXfermode::SkNEONProcCoeffXfermode(SkFlattenableReadBuffer& buffer)
+SkNEONProcCoeffXfermode::SkNEONProcCoeffXfermode(SkReadBuffer& buffer)
: INHERITED(buffer) {
fProcSIMD = reinterpret_cast<void*>(gNEONXfermodeProcs[this->getMode()]);
}
diff --git a/src/opts/SkXfermode_opts_arm_neon.h b/src/opts/SkXfermode_opts_arm_neon.h
index a8d4381..d877484 100644
--- a/src/opts/SkXfermode_opts_arm_neon.h
+++ b/src/opts/SkXfermode_opts_arm_neon.h
@@ -18,7 +18,7 @@
SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkNEONProcCoeffXfermode)
private:
- SkNEONProcCoeffXfermode(SkFlattenableReadBuffer& buffer);
+ SkNEONProcCoeffXfermode(SkReadBuffer& buffer);
// void* is used to avoid pulling arm_neon.h in the core and having to build
// it with -mfpu=neon.
diff --git a/src/pipe/SkGPipeRead.cpp b/src/pipe/SkGPipeRead.cpp
index fc5ab5a..513a34d 100644
--- a/src/pipe/SkGPipeRead.cpp
+++ b/src/pipe/SkGPipeRead.cpp
@@ -20,7 +20,7 @@
#include "SkDrawLooper.h"
#include "SkImageFilter.h"
#include "SkMaskFilter.h"
-#include "SkOrderedReadBuffer.h"
+#include "SkReadBuffer.h"
#include "SkPathEffect.h"
#include "SkRasterizer.h"
#include "SkRRect.h"
@@ -105,7 +105,7 @@
return fFlags;
}
- void setReader(SkOrderedReadBuffer* reader) {
+ void setReader(SkReadBuffer* reader) {
fReader = reader;
this->updateReader();
}
@@ -156,7 +156,7 @@
}
/**
- * Override of SkBitmapHeapReader, so that SkOrderedReadBuffer can use
+ * Override of SkBitmapHeapReader, so that SkReadBuffer can use
* these SkBitmaps for bitmap shaders. Used only in cross process mode
* without a shared heap.
*/
@@ -203,7 +203,7 @@
}
bool crossProcess = SkToBool(fFlags & SkGPipeWriter::kCrossProcess_Flag);
fReader->setFlags(SkSetClearMask(fReader->getFlags(), crossProcess,
- SkFlattenableReadBuffer::kCrossProcess_Flag));
+ SkReadBuffer::kCrossProcess_Flag));
if (crossProcess) {
fReader->setFactoryArray(&fFactoryArray);
} else {
@@ -216,7 +216,7 @@
fReader->setBitmapStorage(fSharedHeap);
}
}
- SkOrderedReadBuffer* fReader;
+ SkReadBuffer* fReader;
SkPaint fPaint;
SkTDArray<SkFlattenable*> fFlatArray;
SkTDArray<SkTypeface*> fTypefaces;
@@ -696,7 +696,7 @@
const size_t size = DrawOp_unpackData(op32);
if (size > 0) {
- SkOrderedReadBuffer buffer(reader->skip(size), size);
+ SkReadBuffer buffer(reader->skip(size), size);
p->setAnnotation(SkNEW_ARGS(SkAnnotation, (buffer)))->unref();
SkASSERT(buffer.offset() == size);
} else {
@@ -857,7 +857,7 @@
SkASSERT(SK_ARRAY_COUNT(gReadTable) == (kDone_DrawOp + 1));
const ReadProc* table = gReadTable;
- SkOrderedReadBuffer reader(data, length);
+ SkReadBuffer reader(data, length);
reader.setBitmapDecoder(fProc);
SkCanvas* canvas = fCanvas;
Status status = kEOF_Status;
diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
index 2948f25..ce58ca6 100644
--- a/src/pipe/SkGPipeWrite.cpp
+++ b/src/pipe/SkGPipeWrite.cpp
@@ -17,7 +17,7 @@
#include "SkGPipePriv.h"
#include "SkImageFilter.h"
#include "SkMaskFilter.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPaint.h"
#include "SkPathEffect.h"
#include "SkPictureFlat.h"
@@ -75,7 +75,7 @@
SkASSERT((isCrossProcess && fset != NULL) || (!isCrossProcess && NULL == fset));
if (isCrossProcess) {
this->setNamedFactorySet(fset);
- this->setWriteBufferFlags(SkFlattenableWriteBuffer::kCrossProcess_Flag);
+ this->setWriteBufferFlags(SkWriteBuffer::kCrossProcess_Flag);
}
}
@@ -151,7 +151,7 @@
///////////////////////////////////////////////////////////////////////////////
struct SkFlattenableTraits {
- static void flatten(SkOrderedWriteBuffer& buffer, const SkFlattenable& flattenable) {
+ static void flatten(SkWriteBuffer& buffer, const SkFlattenable& flattenable) {
buffer.writeFlattenable(&flattenable);
}
// No need to define unflatten if we never call it.
@@ -370,11 +370,11 @@
bool SkGPipeCanvas::shuttleBitmap(const SkBitmap& bm, int32_t slot) {
SkASSERT(shouldFlattenBitmaps(fFlags));
- SkOrderedWriteBuffer buffer;
+ SkWriteBuffer buffer;
buffer.setNamedFactoryRecorder(fFactorySet);
buffer.writeBitmap(bm);
this->flattenFactoryNames();
- uint32_t size = buffer.size();
+ uint32_t size = buffer.bytesWritten();
if (this->needOpBytes(size)) {
this->writeOp(kDef_Bitmap_DrawOp, 0, slot);
void* dst = static_cast<void*>(fWriter.reserve(size));
@@ -1146,7 +1146,7 @@
this->writeOp(kSetAnnotation_DrawOp, 0, 0);
}
} else {
- SkOrderedWriteBuffer buffer;
+ SkWriteBuffer buffer;
paint.getAnnotation()->writeToBuffer(buffer);
const size_t size = buffer.bytesWritten();
if (this->needOpBytes(size)) {
diff --git a/src/utils/SkUnitMappers.cpp b/src/utils/SkUnitMappers.cpp
index f86a454..336a26e 100644
--- a/src/utils/SkUnitMappers.cpp
+++ b/src/utils/SkUnitMappers.cpp
@@ -6,7 +6,8 @@
* found in the LICENSE file.
*/
#include "SkUnitMappers.h"
-#include "SkFlattenableBuffers.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
SkDiscreteMapper::SkDiscreteMapper(int segments) {
@@ -29,13 +30,13 @@
return SkToU16(x);
}
-SkDiscreteMapper::SkDiscreteMapper(SkFlattenableReadBuffer& rb)
+SkDiscreteMapper::SkDiscreteMapper(SkReadBuffer& rb)
: SkUnitMapper(rb) {
fSegments = rb.readInt();
fScale = rb.read32();
}
-void SkDiscreteMapper::flatten(SkFlattenableWriteBuffer& wb) const {
+void SkDiscreteMapper::flatten(SkWriteBuffer& wb) const {
this->INHERITED::flatten(wb);
wb.writeInt(fSegments);
@@ -56,5 +57,5 @@
return SkToU16(x);
}
-SkCosineMapper::SkCosineMapper(SkFlattenableReadBuffer& rb)
+SkCosineMapper::SkCosineMapper(SkReadBuffer& rb)
: SkUnitMapper(rb) {}
diff --git a/tests/AndroidPaintTest.cpp b/tests/AndroidPaintTest.cpp
index 49bab05..0fc2f9b 100644
--- a/tests/AndroidPaintTest.cpp
+++ b/tests/AndroidPaintTest.cpp
@@ -1,21 +1,21 @@
// SkPaints only have an SkPaintOptionsAndroid if SK_BUILD_FOR_ANDROID is true.
#ifdef SK_BUILD_FOR_ANDROID
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPaint.h"
#include "SkPaintOptionsAndroid.h"
#include "Test.h"
static size_t Reconstruct(const SkPaint& src, SkPaint* dst) {
- SkOrderedWriteBuffer writer;
+ SkWriteBuffer writer;
src.flatten(writer);
const size_t size = writer.bytesWritten();
SkAutoMalloc bytes(size);
writer.writeToMemory(bytes.get());
- SkOrderedReadBuffer reader(bytes.get(), size);
+ SkReadBuffer reader(bytes.get(), size);
dst->unflatten(reader);
return size;
diff --git a/tests/BitmapHeapTest.cpp b/tests/BitmapHeapTest.cpp
index 8059105..da41f47 100644
--- a/tests/BitmapHeapTest.cpp
+++ b/tests/BitmapHeapTest.cpp
@@ -9,14 +9,14 @@
#include "SkBitmapHeap.h"
#include "SkColor.h"
#include "SkFlattenable.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkPictureFlat.h"
#include "SkRefCnt.h"
#include "SkShader.h"
#include "Test.h"
struct SkShaderTraits {
- static void flatten(SkOrderedWriteBuffer& buffer, const SkShader& shader) {
+ static void flatten(SkWriteBuffer& buffer, const SkShader& shader) {
buffer.writeFlattenable(&shader);
}
};
diff --git a/tests/ColorFilterTest.cpp b/tests/ColorFilterTest.cpp
index e8cf8ba..f3f6a0a 100644
--- a/tests/ColorFilterTest.cpp
+++ b/tests/ColorFilterTest.cpp
@@ -9,22 +9,22 @@
#include "SkColorFilter.h"
#include "SkColorPriv.h"
#include "SkLumaColorFilter.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkRandom.h"
#include "SkXfermode.h"
#include "Test.h"
static SkColorFilter* reincarnate_colorfilter(SkFlattenable* obj) {
- SkOrderedWriteBuffer wb;
+ SkWriteBuffer wb;
wb.writeFlattenable(obj);
- size_t size = wb.size();
+ size_t size = wb.bytesWritten();
SkAutoSMalloc<1024> storage(size);
// make a copy into storage
wb.writeToMemory(storage.get());
- SkOrderedReadBuffer rb(storage.get(), size);
+ SkReadBuffer rb(storage.get(), size);
return rb.readColorFilter();
}
diff --git a/tests/DataRefTest.cpp b/tests/DataRefTest.cpp
index 731e448..adb05f9 100644
--- a/tests/DataRefTest.cpp
+++ b/tests/DataRefTest.cpp
@@ -8,8 +8,8 @@
#include "SkData.h"
#include "SkDataTable.h"
#include "SkOSFile.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkStream.h"
#include "Test.h"
diff --git a/tests/FlatDataTest.cpp b/tests/FlatDataTest.cpp
index 1f0e12a..36fecf9 100644
--- a/tests/FlatDataTest.cpp
+++ b/tests/FlatDataTest.cpp
@@ -17,12 +17,12 @@
#include "Test.h"
struct SkFlattenableTraits {
- static void flatten(SkOrderedWriteBuffer& buffer, const SkFlattenable& flattenable) {
+ static void flatten(SkWriteBuffer& buffer, const SkFlattenable& flattenable) {
buffer.writeFlattenable(&flattenable);
}
};
struct SkBitmapTraits {
- static void flatten(SkOrderedWriteBuffer& buffer, const SkBitmap& bitmap) {
+ static void flatten(SkWriteBuffer& buffer, const SkBitmap& bitmap) {
bitmap.flatten(buffer);
}
};
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 76612b6..2e02c3e 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -9,7 +9,7 @@
#include "SkBitmapSource.h"
#include "SkCanvas.h"
#include "SkMallocPixelRef.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
#include "SkValidatingReadBuffer.h"
#include "SkXfermodeImageFilter.h"
#include "Test.h"
@@ -28,7 +28,7 @@
template<typename T> struct SerializationUtils {
// Generic case for flattenables
- static void Write(SkOrderedWriteBuffer& writer, const T* flattenable) {
+ static void Write(SkWriteBuffer& writer, const T* flattenable) {
writer.writeFlattenable(flattenable);
}
static void Read(SkValidatingReadBuffer& reader, T** flattenable) {
@@ -37,7 +37,7 @@
};
template<> struct SerializationUtils<SkMatrix> {
- static void Write(SkOrderedWriteBuffer& writer, const SkMatrix* matrix) {
+ static void Write(SkWriteBuffer& writer, const SkMatrix* matrix) {
writer.writeMatrix(*matrix);
}
static void Read(SkValidatingReadBuffer& reader, SkMatrix* matrix) {
@@ -46,7 +46,7 @@
};
template<> struct SerializationUtils<SkPath> {
- static void Write(SkOrderedWriteBuffer& writer, const SkPath* path) {
+ static void Write(SkWriteBuffer& writer, const SkPath* path) {
writer.writePath(*path);
}
static void Read(SkValidatingReadBuffer& reader, SkPath* path) {
@@ -55,7 +55,7 @@
};
template<> struct SerializationUtils<SkRegion> {
- static void Write(SkOrderedWriteBuffer& writer, const SkRegion* region) {
+ static void Write(SkWriteBuffer& writer, const SkRegion* region) {
writer.writeRegion(*region);
}
static void Read(SkValidatingReadBuffer& reader, SkRegion* region) {
@@ -64,7 +64,7 @@
};
template<> struct SerializationUtils<unsigned char> {
- static void Write(SkOrderedWriteBuffer& writer, unsigned char* data, uint32_t arraySize) {
+ static void Write(SkWriteBuffer& writer, unsigned char* data, uint32_t arraySize) {
writer.writeByteArray(data, arraySize);
}
static bool Read(SkValidatingReadBuffer& reader, unsigned char* data, uint32_t arraySize) {
@@ -73,7 +73,7 @@
};
template<> struct SerializationUtils<SkColor> {
- static void Write(SkOrderedWriteBuffer& writer, SkColor* data, uint32_t arraySize) {
+ static void Write(SkWriteBuffer& writer, SkColor* data, uint32_t arraySize) {
writer.writeColorArray(data, arraySize);
}
static bool Read(SkValidatingReadBuffer& reader, SkColor* data, uint32_t arraySize) {
@@ -82,7 +82,7 @@
};
template<> struct SerializationUtils<int32_t> {
- static void Write(SkOrderedWriteBuffer& writer, int32_t* data, uint32_t arraySize) {
+ static void Write(SkWriteBuffer& writer, int32_t* data, uint32_t arraySize) {
writer.writeIntArray(data, arraySize);
}
static bool Read(SkValidatingReadBuffer& reader, int32_t* data, uint32_t arraySize) {
@@ -91,7 +91,7 @@
};
template<> struct SerializationUtils<SkPoint> {
- static void Write(SkOrderedWriteBuffer& writer, SkPoint* data, uint32_t arraySize) {
+ static void Write(SkWriteBuffer& writer, SkPoint* data, uint32_t arraySize) {
writer.writePointArray(data, arraySize);
}
static bool Read(SkValidatingReadBuffer& reader, SkPoint* data, uint32_t arraySize) {
@@ -100,7 +100,7 @@
};
template<> struct SerializationUtils<SkScalar> {
- static void Write(SkOrderedWriteBuffer& writer, SkScalar* data, uint32_t arraySize) {
+ static void Write(SkWriteBuffer& writer, SkScalar* data, uint32_t arraySize) {
writer.writeScalarArray(data, arraySize);
}
static bool Read(SkValidatingReadBuffer& reader, SkScalar* data, uint32_t arraySize) {
@@ -110,8 +110,8 @@
template<typename T>
static void TestObjectSerialization(T* testObj, skiatest::Reporter* reporter) {
- SkOrderedWriteBuffer writer;
- writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer;
+ writer.setFlags(SkWriteBuffer::kValidation_Flag);
SerializationUtils<T>::Write(writer, testObj);
size_t bytesWritten = writer.bytesWritten();
REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
@@ -141,8 +141,8 @@
template<typename T>
static T* TestFlattenableSerialization(T* testObj, bool shouldSucceed,
skiatest::Reporter* reporter) {
- SkOrderedWriteBuffer writer;
- writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer;
+ writer.setFlags(SkWriteBuffer::kValidation_Flag);
SerializationUtils<T>::Write(writer, testObj);
size_t bytesWritten = writer.bytesWritten();
REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
@@ -180,8 +180,8 @@
template<typename T>
static void TestArraySerialization(T* data, skiatest::Reporter* reporter) {
- SkOrderedWriteBuffer writer;
- writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+ SkWriteBuffer writer;
+ writer.setFlags(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