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

gm/imagefiltersbase.cpp

@@ -27,7 +27,7 @@ protected:
         return false;
     }
 
-    FailImageFilter(SkFlattenableReadBuffer& buffer)
+    FailImageFilter(SkReadBuffer& buffer)
       : INHERITED(1, buffer) {}
 
 private:
@@ -51,7 +51,7 @@ protected:
         return true;
     }
 
-    IdentityImageFilter(SkFlattenableReadBuffer& buffer)
+    IdentityImageFilter(SkReadBuffer& buffer)
       : INHERITED(1, buffer) {}
 
 private:

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 @@ public:
     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);

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) {

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/SkReadBuffer.cpp',
-        '<(skia_src_path)/core/SkOrderedWriteBuffer.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',

include/core/SkAnnotation.h

@@ -12,8 +12,8 @@
 #include "SkString.h"
 
 class SkData;
-class SkFlattenableReadBuffer;
+class SkReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkWriteBuffer;
 class SkStream;
 class SkWStream;
 struct SkPoint;
@@ -32,8 +32,8 @@ public:
      */
     SkData* find(const char key[]) const;
 
-    SkAnnotation(SkFlattenableReadBuffer&);
+    SkAnnotation(SkReadBuffer&);
-    void writeToBuffer(SkFlattenableWriteBuffer&) const;
+    void writeToBuffer(SkWriteBuffer&) const;
 
 private:
     SkString    fKey;

include/core/SkBitmap.h

@@ -658,8 +658,8 @@ public:
         buffers as they can optimize the recording process and avoid recording
         duplicate bitmaps and pixelRefs.
      */
-    void flatten(SkFlattenableWriteBuffer&) const;
+    void flatten(SkWriteBuffer&) const;
-    void unflatten(SkFlattenableReadBuffer&);
+    void unflatten(SkReadBuffer&);
 
     SkDEBUGCODE(void validate() const;)
 

include/core/SkColorFilter.h

@@ -135,7 +135,7 @@ public:
 
 protected:
     SkColorFilter() {}
-    SkColorFilter(SkFlattenableReadBuffer& rb) : INHERITED(rb) {}
+    SkColorFilter(SkReadBuffer& rb) : INHERITED(rb) {}
 
 private:
     typedef SkFlattenable INHERITED;

include/core/SkColorShader.h

@@ -52,8 +52,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorShader)
 
 protected:
-    SkColorShader(SkFlattenableReadBuffer&);
+    SkColorShader(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
 

include/core/SkColorTable.h

@@ -75,8 +75,8 @@ public:
         SkDEBUGCODE(f16BitCacheLockCount -= 1);
     }
 
-    explicit SkColorTable(SkFlattenableReadBuffer&);
+    explicit SkColorTable(SkReadBuffer&);
-    void writeToBuffer(SkFlattenableWriteBuffer&) const;
+    void writeToBuffer(SkWriteBuffer&) const;
 
 private:
     SkPMColor*  fColors;

include/core/SkComposeShader.h

@@ -43,8 +43,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposeShader)
 
 protected:
-    SkComposeShader(SkFlattenableReadBuffer& );
+    SkComposeShader(SkReadBuffer& );
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
 

include/core/SkDrawLooper.h

@@ -68,7 +68,7 @@ public:
 
 protected:
     SkDrawLooper() {}
-    SkDrawLooper(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    SkDrawLooper(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
 private:
     typedef SkFlattenable INHERITED;

include/core/SkEmptyShader.h

@@ -34,7 +34,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmptyShader)
 
 protected:
-    SkEmptyShader(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    SkEmptyShader(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
 private:
     typedef SkShader INHERITED;

include/core/SkFlattenable.h

@@ -12,8 +12,8 @@
 
 #include "SkRefCnt.h"
 
-class SkFlattenableReadBuffer;
+class SkReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkWriteBuffer;
 
 #define SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(flattenable) \
         SkFlattenable::Registrar(#flattenable, flattenable::CreateProc, \
@@ -32,7 +32,7 @@ class SkFlattenableWriteBuffer;
 
 #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 @@ public:
 
     SK_DECLARE_INST_COUNT(SkFlattenable)
 
-    typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
+    typedef SkFlattenable* (*Factory)(SkReadBuffer&);
 
     SkFlattenable() {}
 
@@ -94,19 +94,19 @@ public:
         }
     };
 
-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;
 };

include/core/SkFlattenableBuffers.h

@@ -1,260 +1,10 @@
-
+// Temporary shim to keep a couple dependencies working in Chromium.
-/*
- * Copyright 2012 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
 #ifndef SkFlattenableBuffers_DEFINED
 #define SkFlattenableBuffers_DEFINED
 
-#include "SkColor.h"
+#include "SkReadBuffer.h"
-#include "SkData.h"
+#include "SkWriteBuffer.h"
-#include "SkPaint.h"
-#include "SkPoint.h"
 
-class SkBitmap;
+typedef SkReadBuffer SkFlattenableReadBuffer;
-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;
 
-class SkFlattenableReadBuffer {
+#endif//SkFlattenableBuffers_DEFINED
-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

include/core/SkImageFilter.h

@@ -160,15 +160,15 @@ protected:
     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

include/core/SkImageInfo.h

@@ -11,8 +11,8 @@
 #include "SkTypes.h"
 #include "SkSize.h"
 
-class SkFlattenableWriteBuffer;
+class SkWriteBuffer;
-class SkFlattenableReadBuffer;
+class SkReadBuffer;
 
 /**
  *  Describes how to interpret the alpha compoent of a pixel.
@@ -178,8 +178,8 @@ struct SkImageInfo {
         return 0 != memcmp(this, &other, sizeof(other));
     }
 
-    void unflatten(SkFlattenableReadBuffer&);
+    void unflatten(SkReadBuffer&);
-    void flatten(SkFlattenableWriteBuffer&) const;
+    void flatten(SkWriteBuffer&) const;
 
     size_t getSafeSize(size_t rowBytes) const {
         if (0 == fHeight) {

include/core/SkMallocPixelRef.h

@@ -91,12 +91,12 @@ protected:
     // 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:

include/core/SkMaskFilter.h

@@ -137,7 +137,7 @@ public:
 
 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,

include/core/SkPaint.h

@@ -24,8 +24,8 @@ class SkAutoGlyphCache;
 class SkColorFilter;
 class SkDescriptor;
 struct SkDeviceProperties;
-class SkFlattenableReadBuffer;
+class SkReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkWriteBuffer;
 struct SkGlyph;
 struct SkRect;
 class SkGlyphCache;
@@ -72,8 +72,8 @@ public:
         return !(a == b);
     }
 
-    void flatten(SkFlattenableWriteBuffer&) const;
+    void flatten(SkWriteBuffer&) const;
-    void unflatten(SkFlattenableReadBuffer&);
+    void unflatten(SkReadBuffer&);
 
     /** Restores the paint to its initial settings.
     */

include/core/SkPaintOptionsAndroid.h

@@ -13,8 +13,8 @@
 #include "SkTypes.h"
 #include "SkString.h"
 
-class SkFlattenableReadBuffer;
+class SkReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkWriteBuffer;
 
 /** \class SkLanguage
 
@@ -80,8 +80,8 @@ public:
                fUseFontFallbacks != b.fUseFontFallbacks;
     }
 
-    void flatten(SkFlattenableWriteBuffer&) const;
+    void flatten(SkWriteBuffer&) const;
-    void unflatten(SkFlattenableReadBuffer&);
+    void unflatten(SkReadBuffer&);
 
     /** Return the paint's language value used for drawing text.
         @return the paint's language value used for drawing text.

include/core/SkPathEffect.h

@@ -109,7 +109,7 @@ public:
     SK_DEFINE_FLATTENABLE_TYPE(SkPathEffect)
 
 protected:
-    SkPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    SkPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
 private:
     // illegal
@@ -131,8 +131,8 @@ public:
     virtual ~SkPairPathEffect();
 
 protected:
-    SkPairPathEffect(SkFlattenableReadBuffer&);
+    SkPairPathEffect(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     // these are visible to our subclasses
     SkPathEffect* fPE0, *fPE1;
@@ -162,7 +162,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkComposePathEffect)
 
 protected:
-    SkComposePathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    SkComposePathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
 private:
     // illegal
@@ -193,7 +193,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSumPathEffect)
 
 protected:
-    SkSumPathEffect(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    SkSumPathEffect(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
 private:
     // illegal

include/core/SkPicture.h

@@ -169,8 +169,8 @@ public:
 
     /**
      *  Function to encode an SkBitmap to an SkData. A function with this
-     *  signature can be passed to serialize() and SkOrderedWriteBuffer.
+     *  signature can be passed to serialize() and SkWriteBuffer.
-     *  Returning NULL will tell the SkOrderedWriteBuffer to use
+     *  Returning NULL will tell the SkWriteBuffer to use
      *  SkBitmap::flatten() to store the bitmap.
      *
      *  @param pixelRefOffset DEPRECATED -- caller assumes it will return 0.

include/core/SkPixelRef.h

@@ -328,8 +328,8 @@ protected:
     SkBaseMutex* mutex() const { return fMutex; }
 
     // serialization
-    SkPixelRef(SkFlattenableReadBuffer&, SkBaseMutex*);
+    SkPixelRef(SkReadBuffer&, SkBaseMutex*);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    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.

include/core/SkRasterizer.h

@@ -33,7 +33,7 @@ public:
     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,

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

include/core/SkShader.h

@@ -363,8 +363,8 @@ protected:
     const SkMatrix&     getTotalInverse() const { return fTotalInverse; }
     MatrixClass         getInverseClass() const { return (MatrixClass)fTotalInverseClass; }
 
-    SkShader(SkFlattenableReadBuffer& );
+    SkShader(SkReadBuffer& );
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 private:
     SkMatrix            fLocalMatrix;
     SkMatrix            fTotalInverse;

include/core/SkUnitMapper.h

@@ -28,7 +28,7 @@ public:
     SK_DEFINE_FLATTENABLE_TYPE(SkUnitMapper)
 
 protected:
-    SkUnitMapper(SkFlattenableReadBuffer& rb) : SkFlattenable(rb) {}
+    SkUnitMapper(SkReadBuffer& rb) : SkFlattenable(rb) {}
 
 private:
     typedef SkFlattenable INHERITED;

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

include/core/SkXfermode.h

@@ -218,7 +218,7 @@ public:
     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 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkProcXfermode)
 
 protected:
-    SkProcXfermode(SkFlattenableReadBuffer&);
+    SkProcXfermode(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     // allow subclasses to update this after we unflatten
     void setProc(SkXfermodeProc proc) {

include/effects/Sk1DPathEffect.h

@@ -60,8 +60,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPath1DPathEffect)
 
 protected:
-    SkPath1DPathEffect(SkFlattenableReadBuffer& buffer);
+    SkPath1DPathEffect(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     // overrides from Sk1DPathEffect
     virtual SkScalar begin(SkScalar contourLength) const SK_OVERRIDE;

include/effects/Sk2DPathEffect.h

@@ -41,8 +41,8 @@ protected:
     const SkMatrix& getMatrix() const { return fMatrix; }
 
     // protected so that subclasses can call this during unflattening
-    Sk2DPathEffect(SkFlattenableReadBuffer&);
+    Sk2DPathEffect(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkMatrix    fMatrix, fInverse;
@@ -69,9 +69,9 @@ public:
 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 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPath2DPathEffect)
 
 protected:
-    SkPath2DPathEffect(SkFlattenableReadBuffer& buffer);
+    SkPath2DPathEffect(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual void next(const SkPoint&, int u, int v, SkPath*) const SK_OVERRIDE;
 

include/effects/SkAvoidXfermode.h

@@ -51,8 +51,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAvoidXfermode)
 
 protected:
-    SkAvoidXfermode(SkFlattenableReadBuffer&);
+    SkAvoidXfermode(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkColor     fOpColor;

include/effects/SkBicubicImageFilter.h

@@ -35,8 +35,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBicubicImageFilter)
 
 protected:
-    SkBicubicImageFilter(SkFlattenableReadBuffer& buffer);
+    SkBicubicImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkBitmapSource.h

@@ -20,8 +20,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBitmapSource)
 
 protected:
-    explicit SkBitmapSource(SkFlattenableReadBuffer& buffer);
+    explicit SkBitmapSource(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
 

include/effects/SkBlurDrawLooper.h

@@ -51,8 +51,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurDrawLooper)
 
 protected:
-    SkBlurDrawLooper(SkFlattenableReadBuffer&);
+    SkBlurDrawLooper(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkMaskFilter*   fBlur;

include/effects/SkBlurImageFilter.h

@@ -22,8 +22,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurImageFilter)
 
 protected:
-    explicit SkBlurImageFilter(SkFlattenableReadBuffer& buffer);
+    explicit SkBlurImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;

include/effects/SkColorFilterImageFilter.h

@@ -22,8 +22,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorFilterImageFilter)
 
 protected:
-    SkColorFilterImageFilter(SkFlattenableReadBuffer& buffer);
+    SkColorFilterImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkColorMatrixFilter.h

@@ -35,8 +35,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorMatrixFilter)
 
 protected:
-    SkColorMatrixFilter(SkFlattenableReadBuffer& buffer);
+    SkColorMatrixFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkColorMatrix fMatrix;

include/effects/SkComposeImageFilter.h

@@ -18,7 +18,7 @@ public:
     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;

include/effects/SkCornerPathEffect.h

@@ -29,8 +29,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkCornerPathEffect)
 
 protected:
-    SkCornerPathEffect(SkFlattenableReadBuffer&);
+    SkCornerPathEffect(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkScalar    fRadius;

include/effects/SkDashPathEffect.h

@@ -49,11 +49,11 @@ public:
 
     virtual Factory getFactory() const SK_OVERRIDE;
 
-    static SkFlattenable* CreateProc(SkFlattenableReadBuffer&);
+    static SkFlattenable* CreateProc(SkReadBuffer&);
 
 protected:
-    SkDashPathEffect(SkFlattenableReadBuffer&);
+    SkDashPathEffect(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkScalar*   fIntervals;

include/effects/SkDiscretePathEffect.h

@@ -28,8 +28,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiscretePathEffect)
 
 protected:
-    SkDiscretePathEffect(SkFlattenableReadBuffer&);
+    SkDiscretePathEffect(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkScalar fSegLength, fPerterb;

include/effects/SkDisplacementMapEffect.h

@@ -46,8 +46,8 @@ public:
 #endif
 
 protected:
-    explicit SkDisplacementMapEffect(SkFlattenableReadBuffer& buffer);
+    explicit SkDisplacementMapEffect(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     ChannelSelectorType fXChannelSelector;

include/effects/SkDropShadowImageFilter.h

@@ -17,8 +17,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDropShadowImageFilter)
 
 protected:
-    explicit SkDropShadowImageFilter(SkFlattenableReadBuffer&);
+    explicit SkDropShadowImageFilter(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
     virtual bool onFilterImage(Proxy*, const SkBitmap& source, const SkMatrix&, SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
 
 private:

include/effects/SkEmbossMaskFilter.h

@@ -39,8 +39,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkEmbossMaskFilter)
 
 protected:
-    SkEmbossMaskFilter(SkFlattenableReadBuffer&);
+    SkEmbossMaskFilter(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     Light       fLight;

include/effects/SkKernel33MaskFilter.h

@@ -24,8 +24,8 @@ public:
     SkDEVCODE(virtual void toString(SkString* str) const SK_OVERRIDE;)
 
 protected:
-    SkKernel33ProcMaskFilter(SkFlattenableReadBuffer& rb);
+    SkKernel33ProcMaskFilter(SkReadBuffer& rb);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     int fPercent256;
@@ -53,8 +53,8 @@ private:
     int fKernel[3][3];
     int fShift;
 
-    SkKernel33MaskFilter(SkFlattenableReadBuffer& rb);
+    SkKernel33MaskFilter(SkReadBuffer& rb);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     typedef SkKernel33ProcMaskFilter INHERITED;
 };

include/effects/SkLayerDrawLooper.h

@@ -110,8 +110,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLayerDrawLooper)
 
 protected:
-    SkLayerDrawLooper(SkFlattenableReadBuffer&);
+    SkLayerDrawLooper(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     struct Rec {

include/effects/SkLayerRasterizer.h

@@ -35,8 +35,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLayerRasterizer)
 
 protected:
-    SkLayerRasterizer(SkFlattenableReadBuffer&);
+    SkLayerRasterizer(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     // override from SkRasterizer
     virtual bool onRasterize(const SkPath& path, const SkMatrix& matrix,

include/effects/SkLerpXfermode.h

@@ -32,8 +32,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLerpXfermode)
 
 protected:
-    SkLerpXfermode(SkFlattenableReadBuffer&);
+    SkLerpXfermode(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkLerpXfermode(unsigned scale256);

include/effects/SkLightingImageFilter.h

@@ -74,8 +74,8 @@ protected:
                           SkScalar surfaceScale,
                           SkImageFilter* input,
                           const CropRect* cropRect = NULL);
-    explicit SkLightingImageFilter(SkFlattenableReadBuffer& buffer);
+    explicit SkLightingImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
     const SkLight* light() const { return fLight; }
     SkScalar surfaceScale() const { return fSurfaceScale; }
 

include/effects/SkLumaColorFilter.h

@@ -35,8 +35,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLumaColorFilter)
 
 protected:
-    SkLumaColorFilter(SkFlattenableReadBuffer& buffer);
+    SkLumaColorFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkLumaColorFilter();

include/effects/SkMagnifierImageFilter.h

@@ -19,8 +19,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMagnifierImageFilter)
 
 protected:
-    explicit SkMagnifierImageFilter(SkFlattenableReadBuffer& buffer);
+    explicit SkMagnifierImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;

include/effects/SkMatrixConvolutionImageFilter.h

@@ -64,8 +64,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMatrixConvolutionImageFilter)
 
 protected:
-    SkMatrixConvolutionImageFilter(SkFlattenableReadBuffer& buffer);
+    SkMatrixConvolutionImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkMergeImageFilter.h

@@ -25,8 +25,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMergeImageFilter)
 
 protected:
-    SkMergeImageFilter(SkFlattenableReadBuffer& buffer);
+    SkMergeImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkMorphologyImageFilter.h

@@ -32,8 +32,8 @@ protected:
     bool filterImageGeneric(Proc procX, Proc procY,
                             Proxy*, const SkBitmap& src, const SkMatrix&,
                             SkBitmap* result, SkIPoint* offset);
-    SkMorphologyImageFilter(SkFlattenableReadBuffer& buffer);
+    SkMorphologyImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    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 @@ public:
     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 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkErodeImageFilter)
 
 protected:
-    SkErodeImageFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    SkErodeImageFilter(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
 private:
     typedef SkMorphologyImageFilter INHERITED;

include/effects/SkOffsetImageFilter.h

@@ -21,8 +21,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkOffsetImageFilter)
 
 protected:
-    SkOffsetImageFilter(SkFlattenableReadBuffer& buffer);
+    SkOffsetImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkPerlinNoiseShader.h

@@ -73,8 +73,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPerlinNoiseShader)
 
 protected:
-    SkPerlinNoiseShader(SkFlattenableReadBuffer&);
+    SkPerlinNoiseShader(SkReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkPerlinNoiseShader(SkPerlinNoiseShader::Type type, SkScalar baseFrequencyX,

include/effects/SkPictureImageFilter.h

@@ -28,8 +28,8 @@ public:
 
 protected:
     virtual ~SkPictureImageFilter();
-    explicit SkPictureImageFilter(SkFlattenableReadBuffer& buffer);
+    explicit SkPictureImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
 

include/effects/SkPixelXorXfermode.h

@@ -23,8 +23,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkPixelXorXfermode)
 
 protected:
-    SkPixelXorXfermode(SkFlattenableReadBuffer& rb);
+    SkPixelXorXfermode(SkReadBuffer& rb);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     // override from SkXfermode
     virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const;

include/effects/SkRectShaderImageFilter.h

@@ -34,8 +34,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkRectShaderImageFilter)
 
 protected:
-    SkRectShaderImageFilter(SkFlattenableReadBuffer& buffer);
+    SkRectShaderImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkResizeImageFilter.h

@@ -36,8 +36,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkResizeImageFilter)
 
 protected:
-    SkResizeImageFilter(SkFlattenableReadBuffer& buffer);
+    SkResizeImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkStippleMaskFilter.h

@@ -31,7 +31,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkStippleMaskFilter);
 
 protected:
-    SkStippleMaskFilter(SkFlattenableReadBuffer& buffer)
+    SkStippleMaskFilter(SkReadBuffer& buffer)
     : SkMaskFilter(buffer) {
     }
 

include/effects/SkTableMaskFilter.h

@@ -51,8 +51,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTableMaskFilter)
 
 protected:
-    SkTableMaskFilter(SkFlattenableReadBuffer& rb);
+    SkTableMaskFilter(SkReadBuffer& rb);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     uint8_t fTable[256];

include/effects/SkTestImageFilters.h

@@ -12,8 +12,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDownSampleImageFilter)
 
 protected:
-    SkDownSampleImageFilter(SkFlattenableReadBuffer& buffer);
+    SkDownSampleImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;

include/effects/SkTileImageFilter.h

@@ -28,9 +28,9 @@ public:
     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;

include/effects/SkTransparentShader.h

@@ -29,7 +29,7 @@ private:
     const SkBitmap* fDevice;
     uint8_t         fAlpha;
 
-    SkTransparentShader(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    SkTransparentShader(SkReadBuffer& buffer) : INHERITED(buffer) {}
 
     typedef SkShader INHERITED;
 };

include/effects/SkXfermodeImageFilter.h

@@ -40,8 +40,8 @@ public:
 #endif
 
 protected:
-    explicit SkXfermodeImageFilter(SkFlattenableReadBuffer& buffer);
+    explicit SkXfermodeImageFilter(SkReadBuffer& buffer);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkXfermode* fMode;

include/images/SkImageRef.h

@@ -76,8 +76,8 @@ protected:
     // override this in your subclass to clean up when we're unlocking pixels
     virtual void onUnlockPixels() SK_OVERRIDE {}
 
-    SkImageRef(SkFlattenableReadBuffer&, SkBaseMutex* mutex = NULL);
+    SkImageRef(SkReadBuffer&, SkBaseMutex* mutex = NULL);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     SkBitmap fBitmap;
 

include/images/SkImageRef_GlobalPool.h

@@ -53,7 +53,7 @@ protected:
 
     virtual void onUnlockPixels();
 
-    SkImageRef_GlobalPool(SkFlattenableReadBuffer&);
+    SkImageRef_GlobalPool(SkReadBuffer&);
 
 private:
     typedef SkImageRef INHERITED;

include/utils/SkUnitMappers.h

@@ -23,8 +23,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiscreteMapper)
 
 protected:
-    SkDiscreteMapper(SkFlattenableReadBuffer& );
+    SkDiscreteMapper(SkReadBuffer& );
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     int     fSegments;
@@ -45,7 +45,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkCosineMapper)
 
 protected:
-    SkCosineMapper(SkFlattenableReadBuffer&);
+    SkCosineMapper(SkReadBuffer&);
 
 private:
 

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 @@ protected:
         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 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(InverseFillPE)
 
 protected:
-    InverseFillPE(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {}
+    InverseFillPE(SkReadBuffer& buffer) : INHERITED(buffer) {}
 private:
 
     typedef SkPathEffect INHERITED;

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 @@ protected:
         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);
     }

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"

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 @@ public:
     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 @@ public:
     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 @@ public:
     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 @@ private:
     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));
     }

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 @@ SkData* SkAnnotation::find(const char key[]) const {
     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);
 }

src/core/SkBitmap.cpp

@@ -14,8 +14,8 @@
 #include "SkImagePriv.h"
 #include "SkMallocPixelRef.h"
 #include "SkMask.h"
-#include "SkOrderedReadBuffer.h"
+#include "SkReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkPixelRef.h"
 #include "SkThread.h"
 #include "SkUnPreMultiply.h"
@@ -1583,7 +1583,7 @@ enum {
     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::flatten(SkFlattenableWriteBuffer& buffer) const {
     }
 }
 
-void SkBitmap::unflatten(SkFlattenableReadBuffer& buffer) {
+void SkBitmap::unflatten(SkReadBuffer& buffer) {
     this->reset();
 
     int width = buffer.readInt();

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()

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 @@ SkBitmapProcShader::SkBitmapProcShader(const SkBitmap& src,
     fFlags = 0; // computed in setContext
 }
 
-SkBitmapProcShader::SkBitmapProcShader(SkFlattenableReadBuffer& buffer)
+SkBitmapProcShader::SkBitmapProcShader(SkReadBuffer& buffer)
         : INHERITED(buffer) {
     buffer.readBitmap(&fRawBitmap);
     fRawBitmap.setImmutable();
@@ -63,7 +64,7 @@ SkShader::BitmapType SkBitmapProcShader::asABitmap(SkBitmap* texture,
     return kDefault_BitmapType;
 }
 
-void SkBitmapProcShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkBitmapProcShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
 
     buffer.writeBitmap(fRawBitmap);

src/core/SkBitmapProcShader.h

@@ -37,8 +37,8 @@ public:
 #endif
 
 protected:
-    SkBitmapProcShader(SkFlattenableReadBuffer& );
+    SkBitmapProcShader(SkReadBuffer& );
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     SkBitmap          fRawBitmap;   // experimental for RLE encoding
     SkBitmapProcState fState;

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 @@ public:
     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);

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"

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 @@ const uint16_t* SkColorTable::lock16BitCache() {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkColorTable::SkColorTable(SkFlattenableReadBuffer& buffer) {
+SkColorTable::SkColorTable(SkReadBuffer& buffer) {
     f16BitCache = NULL;
     SkDEBUGCODE(fColorLockCount = 0;)
     SkDEBUGCODE(f16BitCacheLockCount = 0;)
@@ -105,7 +106,7 @@ SkColorTable::SkColorTable(SkFlattenableReadBuffer& buffer) {
 #endif
 }
 
-void SkColorTable::writeToBuffer(SkFlattenableWriteBuffer& buffer) const {
+void SkColorTable::writeToBuffer(SkWriteBuffer& buffer) const {
     buffer.writeUInt(fAlphaType);
     buffer.writeColorArray(fColors, fCount);
 }

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 @@ SkComposeShader::SkComposeShader(SkShader* sA, SkShader* sB, SkXfermode* mode) {
     SkSafeRef(mode);
 }
 
-SkComposeShader::SkComposeShader(SkFlattenableReadBuffer& buffer) :
+SkComposeShader::SkComposeShader(SkReadBuffer& buffer) :
     INHERITED(buffer) {
     fShaderA = buffer.readShader();
     if (NULL == fShaderA) {
@@ -61,7 +62,7 @@ private:
 };
 #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);

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"
 

src/core/SkDraw.cpp

@@ -2382,7 +2382,7 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkTriColorShader)
 
 protected:
-    SkTriColorShader(SkFlattenableReadBuffer& buffer) : SkShader(buffer) {}
+    SkTriColorShader(SkReadBuffer& buffer) : SkShader(buffer) {}
 
 private:
     SkMatrix    fDstToUnit;

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 @@ SkFilterShader::SkFilterShader(SkShader* shader, SkColorFilter* filter) {
     filter->ref();
 }
 
-SkFilterShader::SkFilterShader(SkFlattenableReadBuffer& buffer)
+SkFilterShader::SkFilterShader(SkReadBuffer& buffer)
     : INHERITED(buffer) {
     fShader = buffer.readShader();
     fFilter = buffer.readColorFilter();
@@ -31,7 +32,7 @@ SkFilterShader::~SkFilterShader() {
     fShader->unref();
 }
 
-void SkFilterShader::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkFilterShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeFlattenable(fShader);
     buffer.writeFlattenable(fFilter);

src/core/SkFilterShader.h

@@ -28,8 +28,8 @@ public:
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkFilterShader)
 
 protected:
-    SkFilterShader(SkFlattenableReadBuffer& );
+    SkFilterShader(SkReadBuffer& );
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
+    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkShader*       fShader;

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()

src/core/SkFlattenableBuffers.cpp

@@ -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);
-}

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;
+    SkWriteBuffer writer;
-    writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+    writer.setFlags(SkWriteBuffer::kValidation_Flag);
     writer.writeFlattenable(flattenable);
     uint32_t size = writer.bytesWritten();
     void* data = sk_malloc_throw(size);

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 @@ SkImageFilter::~SkImageFilter() {
     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 @@ SkImageFilter::SkImageFilter(int inputCount, SkFlattenableReadBuffer& buffer) {
     }
 }
 
-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);

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 @@ static bool color_type_is_valid(SkColorType colorType) {
     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 @@ void SkImageInfo::unflatten(SkFlattenableReadBuffer& buffer) {
                     color_type_is_valid(fColorType));
 }
 
-void SkImageInfo::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkImageInfo::flatten(SkWriteBuffer& buffer) const {
     buffer.write32(fWidth);
     buffer.write32(fHeight);
 

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 @@ size_t SkMallocPixelRef::getAllocatedSizeInBytes() const {
     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 @@ void SkMallocPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
     }
 }
 
-SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer)
+SkMallocPixelRef::SkMallocPixelRef(SkReadBuffer& buffer)
     : INHERITED(buffer, NULL)
     , fReleaseProc(sk_free_releaseproc)
     , fReleaseProcContext(NULL)

src/core/SkOrderedReadBuffer.h

@@ -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

src/core/SkOrderedWriteBuffer.h

@@ -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

src/core/SkPaint.cpp

@@ -18,8 +18,8 @@
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkMaskGamma.h"
-#include "SkOrderedReadBuffer.h"
+#include "SkReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkPaintDefaults.h"
 #include "SkPaintOptionsAndroid.h"
 #include "SkPathEffect.h"
@@ -1474,8 +1474,8 @@ void SkPaint::getPosTextPath(const void* textData, size_t length,
 }
 
 static void add_flattenable(SkDescriptor* desc, uint32_t tag,
-                            SkOrderedWriteBuffer* buffer) {
+                            SkWriteBuffer* buffer) {
-    buffer->writeToMemory(desc->addEntry(tag, buffer->size(), NULL));
+    buffer->writeToMemory(desc->addEntry(tag, buffer->bytesWritten(), NULL));
 }
 
 // SkFontHost can override this choice in FilterRec()
@@ -1815,18 +1815,18 @@ void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
     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 @@ void SkPaint::descriptorProc(const SkDeviceProperties* deviceProperties,
     }
     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 @@ static const uint32_t kPODPaintSize =   5 * sizeof(SkScalar) +
 /*  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 @@ void SkPaint::flatten(SkFlattenableWriteBuffer& buffer) const {
     }
 #endif
 
-    if (buffer.isOrderedBinaryBuffer()) {
+    SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
-        SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
+    uint32_t* ptr = buffer.reserve(kPODPaintSize);
-        uint32_t* ptr = buffer.getOrderedBinaryBuffer()->reserve(kPODPaintSize);
 
-        ptr = write_scalar(ptr, this->getTextSize());
+    ptr = write_scalar(ptr, this->getTextSize());
-        ptr = write_scalar(ptr, this->getTextScaleX());
+    ptr = write_scalar(ptr, this->getTextScaleX());
-        ptr = write_scalar(ptr, this->getTextSkewX());
+    ptr = write_scalar(ptr, this->getTextSkewX());
-        ptr = write_scalar(ptr, this->getStrokeWidth());
+    ptr = write_scalar(ptr, this->getStrokeWidth());
-        ptr = write_scalar(ptr, this->getStrokeMiter());
+    ptr = write_scalar(ptr, this->getStrokeMiter());
-        *ptr++ = this->getColor();
+    *ptr++ = this->getColor();
-        // previously flags:16, textAlign:8, flatFlags:8
+    // previously flags:16, textAlign:8, flatFlags:8
-        // now flags:16, hinting:4, textAlign:4, flatFlags:8
+    // now flags:16, hinting:4, textAlign:4, flatFlags:8
-        *ptr++ = (this->getFlags() << 16) |
+    *ptr++ = (this->getFlags() << 16) |
-                 // hinting added later. 0 in this nibble means use the default.
+        // hinting added later. 0 in this nibble means use the default.
-                 ((this->getHinting()+1) << 12) |
+        ((this->getHinting()+1) << 12) |
-                 (this->getTextAlign() << 8) |
+        (this->getTextAlign() << 8) |
-                 flatFlags;
+        flatFlags;
-        *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
+    *ptr++ = pack_4(this->getStrokeCap(), this->getStrokeJoin(),
-                        this->getStyle(), this->getTextEncoding());
+                    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);
-    }
 
     // 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 @@ void SkPaint::flatten(SkFlattenableWriteBuffer& buffer) const {
 #endif
 }
 
-void SkPaint::unflatten(SkFlattenableReadBuffer& buffer) {
+void SkPaint::unflatten(SkReadBuffer& buffer) {
     uint8_t flatFlags = 0;
-    if (buffer.isOrderedBinaryBuffer()) {
+    SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
-        SkASSERT(SkAlign4(kPODPaintSize) == kPODPaintSize);
+    const void* podData = buffer.skip(kPODPaintSize);
-        const void* podData = buffer.getOrderedBinaryBuffer()->skip(kPODPaintSize);
+    const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
-        const uint32_t* pod = reinterpret_cast<const uint32_t*>(podData);
 
-        // the order we read must match the order we wrote in flatten()
+    // the order we read must match the order we wrote in flatten()
-        this->setTextSize(read_scalar(pod));
+    this->setTextSize(read_scalar(pod));
-        this->setTextScaleX(read_scalar(pod));
+    this->setTextScaleX(read_scalar(pod));
-        this->setTextSkewX(read_scalar(pod));
+    this->setTextSkewX(read_scalar(pod));
-        this->setStrokeWidth(read_scalar(pod));
+    this->setStrokeWidth(read_scalar(pod));
-        this->setStrokeMiter(read_scalar(pod));
+    this->setStrokeMiter(read_scalar(pod));
-        this->setColor(*pod++);
+    this->setColor(*pod++);
 
-        // previously flags:16, textAlign:8, flatFlags:8
+    // previously flags:16, textAlign:8, flatFlags:8
-        // now flags:16, hinting:4, textAlign:4, flatFlags:8
+    // now flags:16, hinting:4, textAlign:4, flatFlags:8
-        uint32_t tmp = *pod++;
+    uint32_t tmp = *pod++;
-        this->setFlags(tmp >> 16);
+    this->setFlags(tmp >> 16);
 
-        // hinting added later. 0 in this nibble means use the default.
+    // hinting added later. 0 in this nibble means use the default.
-        uint32_t hinting = (tmp >> 12) & 0xF;
+    uint32_t hinting = (tmp >> 12) & 0xF;
-        this->setHinting(0 == hinting ? kNormal_Hinting : static_cast<Hinting>(hinting-1));
+    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++;
+    tmp = *pod++;
-        this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
+    this->setStrokeCap(static_cast<Cap>((tmp >> 24) & 0xFF));
-        this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
+    this->setStrokeJoin(static_cast<Join>((tmp >> 16) & 0xFF));
-        this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
+    this->setStyle(static_cast<Style>((tmp >> 8) & 0xFF));
-        this->setTextEncoding(static_cast<TextEncoding>((tmp >> 0) & 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()));
-    }
 
     if (flatFlags & kHasTypeface_FlatFlag) {
         this->setTypeface(buffer.readTypeface());

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 @@ SkLanguage SkLanguage::getParent() const {
     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);

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 @@ SkPairPathEffect::~SkPairPathEffect() {
 /*
     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

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 @@ int SkPathHeap::append(const SkPath& path) {
     return fPaths.count();
 }
 
-void SkPathHeap::flatten(SkFlattenableWriteBuffer& buffer) const {
+void SkPathHeap::flatten(SkWriteBuffer& buffer) const {
     int count = fPaths.count();
 
     buffer.writeInt(count);

src/core/SkPathHeap.h

@@ -13,15 +13,15 @@
 #include "SkTDArray.h"
 
 class SkPath;
-class SkFlattenableReadBuffer;
+class SkReadBuffer;
-class SkFlattenableWriteBuffer;
+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 @@ public:
         return *fPaths[index];
     }
 
-    void flatten(SkFlattenableWriteBuffer&) const;
+    void flatten(SkWriteBuffer&) const;
 
 private:
     // we store the paths in the heap (placement new)