Refactor read and write buffers.

include/core/SkFlattenable.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkFlattenable_DEFINED
 #define SkFlattenable_DEFINED
 
 #include "SkRefCnt.h"
 
-class SkFlattenableReadBuffer;
-class SkFlattenableWriteBuffer;
+class SkReadBuffer;
+class SkWriteBuffer;
 
 #define SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(flattenable) \
         SkFlattenable::Registrar(#flattenable, flattenable::CreateProc, \
                                  flattenable::GetFlattenableType());
 
 #define SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP() static void InitializeFlattenables();
 
 #define SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(flattenable) \
     void flattenable::InitializeFlattenables() {
 
 #define SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END \
     }
 
 #define SK_DECLARE_UNFLATTENABLE_OBJECT() \
     virtual Factory getFactory() const SK_OVERRIDE { return NULL; }
 
 #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)); \
     }
 
 /** For SkFlattenable derived objects with a valid type
     This macro should only be used in base class objects in core
   */
 #define SK_DEFINE_FLATTENABLE_TYPE(flattenable) \
     static Type GetFlattenableType() { \
         return k##flattenable##_Type; \
     }
@@ skipping 14 matching lines @@
         kSkPathEffect_Type,
         kSkPixelRef_Type,
         kSkRasterizer_Type,
         kSkShader_Type,
         kSkUnitMapper_Type,
         kSkXfermode_Type,
     };
 
     SK_DECLARE_INST_COUNT(SkFlattenable)
 
-    typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
+    typedef SkFlattenable* (*Factory)(SkReadBuffer&);
 
     SkFlattenable() {}
 
     /** Implement this to return a factory function pointer that can be called
      to recreate your class given a buffer (previously written to by your
      override of flatten().
      */
     virtual Factory getFactory() const = 0;
 
     /** Returns the name of the object's class
       */
     const char* getTypeName() const { return FactoryToName(getFactory()); }
 
     static Factory NameToFactory(const char name[]);
     static const char* FactoryToName(Factory);
     static bool NameToType(const char name[], Type* type);
 
     static void Register(const char name[], Factory, Type);
 
     class Registrar {
     public:
         Registrar(const char name[], Factory factory, Type type) {
             SkFlattenable::Register(name, factory, type);
         }
     };
 
-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;
 };
 
 #endif