Remove SkDataTable from SkFlattenable hierarchy.

src/core/SkDataTable.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkDataTable.h"
-#include "SkFlattenableBuffers.h"
 
 SK_DEFINE_INST_COUNT(SkDataTable)
 
 static void malloc_freeproc(void* context) {
     sk_free(context);
 }
 
 // Makes empty table
 SkDataTable::SkDataTable() {
     fCount = 0;
@@ skipping 49 matching lines @@
         }
         return fU.fElems + index * fElemSize;
     } else {
         if (size) {
             *size = fU.fDir[index].fSize;
         }
         return fU.fDir[index].fPtr;
     }
 }
 
-SkDataTable::SkDataTable(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
-    fElemSize = 0;
-    fU.fElems = NULL;
-    fFreeProc = NULL;
-    fFreeProcContext = NULL;
-
-    fCount = buffer.read32();
-    if (fCount) {
-        fElemSize = buffer.read32();
-        if (fElemSize) {
-            size_t size = buffer.getArrayCount();
-            // size is the size of our elems data
-            SkASSERT(fCount * fElemSize == size);
-            void* addr = sk_malloc_throw(size);
-            if (buffer.readByteArray(addr) != size) {
-                sk_throw();
-            }
-            fU.fElems = (const char*)addr;
-            fFreeProcContext = addr;
-        } else {
-            size_t dataSize = buffer.read32();
-
-            size_t allocSize = fCount * sizeof(Dir) + dataSize;
-            void* addr = sk_malloc_throw(allocSize);
-            Dir* dir = (Dir*)addr;
-            char* elem = (char*)(dir + fCount);
-            for (int i = 0; i < fCount; ++i) {
-                dir[i].fPtr = elem;
-                dir[i].fSize = buffer.readByteArray(elem);
-                elem += dir[i].fSize;
-            }
-            fU.fDir = dir;
-            fFreeProcContext = addr;
-        }
-        fFreeProc = malloc_freeproc;
-    }
-}
-
-void SkDataTable::flatten(SkFlattenableWriteBuffer& buffer) const {
-    this->INHERITED::flatten(buffer);
-
-    buffer.write32(fCount);
-    if (fCount) {
-        buffer.write32(fElemSize);
-        if (fElemSize) {
-            buffer.writeByteArray(fU.fElems, fCount * fElemSize);
-        } else {
-            size_t dataSize = 0;
-            for (int i = 0; i < fCount; ++i) {
-                dataSize += fU.fDir[i].fSize;
-            }
-            buffer.write32(dataSize);
-            for (int i = 0; i < fCount; ++i) {
-                buffer.writeByteArray(fU.fDir[i].fPtr, fU.fDir[i].fSize);
-            }
-        }
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 SkDataTable* SkDataTable::NewEmpty() {
     static SkDataTable* gEmpty;
     if (NULL == gEmpty) {
         gEmpty = SkNEW(SkDataTable);
     }
     gEmpty->ref();
     return gEmpty;
 }
@@ skipping 92 matching lines @@
     memcpy(dir, fDir.begin(), count * sizeof(SkDataTable::Dir));
 
     SkDataTable* table = SkNEW_ARGS(SkDataTable,
                                     ((SkDataTable::Dir*)dir, count,
                                      chunkalloc_freeproc, fHeap));
     // we have to detach our fHeap, since we are giving that to the table
     fHeap = NULL;
     fDir.reset();
     return table;
 }