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

6 files changed, 31 insertions, 31 deletions

diff --git a/tests/AndroidPaintTest.cpp b/tests/AndroidPaintTest.cpp
index 49bab05576..0fc2f9b03a 100644
--- a/tests/AndroidPaintTest.cpp
+++ b/tests/AndroidPaintTest.cpp
@@ -1,21 +1,21 @@
 // SkPaints only have an SkPaintOptionsAndroid if SK_BUILD_FOR_ANDROID is true.
 #ifdef SK_BUILD_FOR_ANDROID
 
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkPaint.h"
 #include "SkPaintOptionsAndroid.h"
 #include "Test.h"
 
 static size_t Reconstruct(const SkPaint& src, SkPaint* dst) {
-    SkOrderedWriteBuffer writer;
+    SkWriteBuffer writer;
     src.flatten(writer);
 
     const size_t size = writer.bytesWritten();
     SkAutoMalloc bytes(size);
     writer.writeToMemory(bytes.get());
 
-    SkOrderedReadBuffer reader(bytes.get(), size);
+    SkReadBuffer reader(bytes.get(), size);
     dst->unflatten(reader);
 
     return size;
diff --git a/tests/BitmapHeapTest.cpp b/tests/BitmapHeapTest.cpp
index 80591054db..da41f477f7 100644
--- a/tests/BitmapHeapTest.cpp
+++ b/tests/BitmapHeapTest.cpp
@@ -9,14 +9,14 @@
 #include "SkBitmapHeap.h"
 #include "SkColor.h"
 #include "SkFlattenable.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkPictureFlat.h"
 #include "SkRefCnt.h"
 #include "SkShader.h"
 #include "Test.h"
 
 struct SkShaderTraits {
-    static void flatten(SkOrderedWriteBuffer& buffer, const SkShader& shader) {
+    static void flatten(SkWriteBuffer& buffer, const SkShader& shader) {
         buffer.writeFlattenable(&shader);
     }
 };
diff --git a/tests/ColorFilterTest.cpp b/tests/ColorFilterTest.cpp
index e8cf8ba019..f3f6a0a8e8 100644
--- a/tests/ColorFilterTest.cpp
+++ b/tests/ColorFilterTest.cpp
@@ -9,22 +9,22 @@
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkLumaColorFilter.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkRandom.h"
 #include "SkXfermode.h"
 #include "Test.h"
 
 static SkColorFilter* reincarnate_colorfilter(SkFlattenable* obj) {
-    SkOrderedWriteBuffer wb;
+    SkWriteBuffer wb;
     wb.writeFlattenable(obj);
 
-    size_t size = wb.size();
+    size_t size = wb.bytesWritten();
     SkAutoSMalloc<1024> storage(size);
     // make a copy into storage
     wb.writeToMemory(storage.get());
 
-    SkOrderedReadBuffer rb(storage.get(), size);
+    SkReadBuffer rb(storage.get(), size);
     return rb.readColorFilter();
 }
 
diff --git a/tests/DataRefTest.cpp b/tests/DataRefTest.cpp
index 731e4484c5..adb05f9af5 100644
--- a/tests/DataRefTest.cpp
+++ b/tests/DataRefTest.cpp
@@ -8,8 +8,8 @@
 #include "SkData.h"
 #include "SkDataTable.h"
 #include "SkOSFile.h"
-#include "SkOrderedReadBuffer.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkStream.h"
 #include "Test.h"
 
diff --git a/tests/FlatDataTest.cpp b/tests/FlatDataTest.cpp
index 1f0e12a34f..36fecf9625 100644
--- a/tests/FlatDataTest.cpp
+++ b/tests/FlatDataTest.cpp
@@ -17,12 +17,12 @@
 #include "Test.h"
 
 struct SkFlattenableTraits {
-    static void flatten(SkOrderedWriteBuffer& buffer, const SkFlattenable& flattenable) {
+    static void flatten(SkWriteBuffer& buffer, const SkFlattenable& flattenable) {
         buffer.writeFlattenable(&flattenable);
     }
 };
 struct SkBitmapTraits {
-    static void flatten(SkOrderedWriteBuffer& buffer, const SkBitmap& bitmap) {
+    static void flatten(SkWriteBuffer& buffer, const SkBitmap& bitmap) {
         bitmap.flatten(buffer);
     }
 };
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 76612b6318..2e02c3e714 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -9,7 +9,7 @@
 #include "SkBitmapSource.h"
 #include "SkCanvas.h"
 #include "SkMallocPixelRef.h"
-#include "SkOrderedWriteBuffer.h"
+#include "SkWriteBuffer.h"
 #include "SkValidatingReadBuffer.h"
 #include "SkXfermodeImageFilter.h"
 #include "Test.h"
@@ -28,7 +28,7 @@ static void TestAlignment(T* testObj, skiatest::Reporter* reporter) {
 
 template<typename T> struct SerializationUtils {
     // Generic case for flattenables
-    static void Write(SkOrderedWriteBuffer& writer, const T* flattenable) {
+    static void Write(SkWriteBuffer& writer, const T* flattenable) {
         writer.writeFlattenable(flattenable);
     }
     static void Read(SkValidatingReadBuffer& reader, T** flattenable) {
@@ -37,7 +37,7 @@ template<typename T> struct SerializationUtils {
 };
 
 template<> struct SerializationUtils<SkMatrix> {
-    static void Write(SkOrderedWriteBuffer& writer, const SkMatrix* matrix) {
+    static void Write(SkWriteBuffer& writer, const SkMatrix* matrix) {
         writer.writeMatrix(*matrix);
     }
     static void Read(SkValidatingReadBuffer& reader, SkMatrix* matrix) {
@@ -46,7 +46,7 @@ template<> struct SerializationUtils<SkMatrix> {
 };
 
 template<> struct SerializationUtils<SkPath> {
-    static void Write(SkOrderedWriteBuffer& writer, const SkPath* path) {
+    static void Write(SkWriteBuffer& writer, const SkPath* path) {
         writer.writePath(*path);
     }
     static void Read(SkValidatingReadBuffer& reader, SkPath* path) {
@@ -55,7 +55,7 @@ template<> struct SerializationUtils<SkPath> {
 };
 
 template<> struct SerializationUtils<SkRegion> {
-    static void Write(SkOrderedWriteBuffer& writer, const SkRegion* region) {
+    static void Write(SkWriteBuffer& writer, const SkRegion* region) {
         writer.writeRegion(*region);
     }
     static void Read(SkValidatingReadBuffer& reader, SkRegion* region) {
@@ -64,7 +64,7 @@ template<> struct SerializationUtils<SkRegion> {
 };
 
 template<> struct SerializationUtils<unsigned char> {
-    static void Write(SkOrderedWriteBuffer& writer, unsigned char* data, uint32_t arraySize) {
+    static void Write(SkWriteBuffer& writer, unsigned char* data, uint32_t arraySize) {
         writer.writeByteArray(data, arraySize);
     }
     static bool Read(SkValidatingReadBuffer& reader, unsigned char* data, uint32_t arraySize) {
@@ -73,7 +73,7 @@ template<> struct SerializationUtils<unsigned char> {
 };
 
 template<> struct SerializationUtils<SkColor> {
-    static void Write(SkOrderedWriteBuffer& writer, SkColor* data, uint32_t arraySize) {
+    static void Write(SkWriteBuffer& writer, SkColor* data, uint32_t arraySize) {
         writer.writeColorArray(data, arraySize);
     }
     static bool Read(SkValidatingReadBuffer& reader, SkColor* data, uint32_t arraySize) {
@@ -82,7 +82,7 @@ template<> struct SerializationUtils<SkColor> {
 };
 
 template<> struct SerializationUtils<int32_t> {
-    static void Write(SkOrderedWriteBuffer& writer, int32_t* data, uint32_t arraySize) {
+    static void Write(SkWriteBuffer& writer, int32_t* data, uint32_t arraySize) {
         writer.writeIntArray(data, arraySize);
     }
     static bool Read(SkValidatingReadBuffer& reader, int32_t* data, uint32_t arraySize) {
@@ -91,7 +91,7 @@ template<> struct SerializationUtils<int32_t> {
 };
 
 template<> struct SerializationUtils<SkPoint> {
-    static void Write(SkOrderedWriteBuffer& writer, SkPoint* data, uint32_t arraySize) {
+    static void Write(SkWriteBuffer& writer, SkPoint* data, uint32_t arraySize) {
         writer.writePointArray(data, arraySize);
     }
     static bool Read(SkValidatingReadBuffer& reader, SkPoint* data, uint32_t arraySize) {
@@ -100,7 +100,7 @@ template<> struct SerializationUtils<SkPoint> {
 };
 
 template<> struct SerializationUtils<SkScalar> {
-    static void Write(SkOrderedWriteBuffer& writer, SkScalar* data, uint32_t arraySize) {
+    static void Write(SkWriteBuffer& writer, SkScalar* data, uint32_t arraySize) {
         writer.writeScalarArray(data, arraySize);
     }
     static bool Read(SkValidatingReadBuffer& reader, SkScalar* data, uint32_t arraySize) {
@@ -110,8 +110,8 @@ template<> struct SerializationUtils<SkScalar> {
 
 template<typename T>
 static void TestObjectSerialization(T* testObj, skiatest::Reporter* reporter) {
-    SkOrderedWriteBuffer writer;
-    writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+    SkWriteBuffer writer;
+    writer.setFlags(SkWriteBuffer::kValidation_Flag);
     SerializationUtils<T>::Write(writer, testObj);
     size_t bytesWritten = writer.bytesWritten();
     REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
@@ -141,8 +141,8 @@ static void TestObjectSerialization(T* testObj, skiatest::Reporter* reporter) {
 template<typename T>
 static T* TestFlattenableSerialization(T* testObj, bool shouldSucceed,
                                        skiatest::Reporter* reporter) {
-    SkOrderedWriteBuffer writer;
-    writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+    SkWriteBuffer writer;
+    writer.setFlags(SkWriteBuffer::kValidation_Flag);
     SerializationUtils<T>::Write(writer, testObj);
     size_t bytesWritten = writer.bytesWritten();
     REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
@@ -180,8 +180,8 @@ static T* TestFlattenableSerialization(T* testObj, bool shouldSucceed,
 
 template<typename T>
 static void TestArraySerialization(T* data, skiatest::Reporter* reporter) {
-    SkOrderedWriteBuffer writer;
-    writer.setFlags(SkOrderedWriteBuffer::kValidation_Flag);
+    SkWriteBuffer writer;
+    writer.setFlags(SkWriteBuffer::kValidation_Flag);
     SerializationUtils<T>::Write(writer, data, kArraySize);
     size_t bytesWritten = writer.bytesWritten();
     // This should write the length (in 4 bytes) and the array