Remove SkDataTable from SkFlattenable hierarchy.

include/core/SkDataTable.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkDataTable_DEFINED
 #define SkDataTable_DEFINED
 
 #include "SkChunkAlloc.h"
 #include "SkData.h"
-#include "SkFlattenable.h"
 #include "SkString.h"
 #include "SkTDArray.h"
 
 /**
  *  Like SkData, SkDataTable holds an immutable data buffer. The data buffer is
  *  organized into a table of entries, each with a length, so the entries are
  *  not required to all be the same size.
  */
-class SK_API SkDataTable : public SkFlattenable {
+class SK_API SkDataTable : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkDataTable)
 
     /**
      *  Returns true if the table is empty (i.e. has no entries).
      */
     bool isEmpty() const { return 0 == fCount; }
 
     /**
      *  Return the number of entries in the table. 0 for an empty table
@@ skipping 54 matching lines @@
      *  @param elemSize byte-length for a given element.
      *  @param count the number of entries to be copied out of array. The number
      *               of bytes that will be copied is count * elemSize.
      */
     static SkDataTable* NewCopyArray(const void* array, size_t elemSize,
                                      int count);
 
     static SkDataTable* NewArrayProc(const void* array, size_t elemSize,
                                      int count, FreeProc proc, void* context);
 
-    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDataTable)
-
-protected:
-    SkDataTable(SkFlattenableReadBuffer&);
-    virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
-
 private:
     struct Dir {
         const void* fPtr;
         uintptr_t   fSize;
     };
 
     int         fCount;
     size_t      fElemSize;
     union {
         const Dir*  fDir;
         const char* fElems;
     } fU;
 
     FreeProc    fFreeProc;
     void*       fFreeProcContext;
 
     SkDataTable();
     SkDataTable(const void* array, size_t elemSize, int count,
                 FreeProc, void* context);
     SkDataTable(const Dir*, int count, FreeProc, void* context);
     virtual ~SkDataTable();
 
     friend class SkDataTableBuilder;    // access to Dir
 
-    typedef SkFlattenable INHERITED;
+    typedef SkRefCnt INHERITED;
 };
 
 /**
  *  Helper class that allows for incrementally building up the data needed to
  *  create a SkDataTable.
  */
 class SK_API SkDataTableBuilder : SkNoncopyable {
 public:
     SkDataTableBuilder(size_t minChunkSize);
     ~SkDataTableBuilder();
@@ skipping 37 matching lines @@
      */
     SkDataTable* detachDataTable();
 
 private:
     SkTDArray<SkDataTable::Dir> fDir;
     SkChunkAlloc*               fHeap;
     size_t                      fMinChunkSize;
 };
 
 #endif