Remove debug-only fData from SKTDArray.

include/core/SkTDArray.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 SkTDArray_DEFINED
 #define SkTDArray_DEFINED
 
 #include "SkTypes.h"
 
 template <typename T> class SkTDArray {
 public:
     SkTDArray() {
         fReserve = fCount = 0;
         fArray = NULL;
-#ifdef SK_DEBUG
-        fData = NULL;
-#endif
     }
     SkTDArray(const T src[], int count) {
         SkASSERT(src || count == 0);
 
         fReserve = fCount = 0;
         fArray = NULL;
-#ifdef SK_DEBUG
-        fData = NULL;
-#endif
         if (count) {
             fArray = (T*)sk_malloc_throw(count * sizeof(T));
-#ifdef SK_DEBUG
-            fData = (ArrayT*)fArray;
-#endif
             memcpy(fArray, src, sizeof(T) * count);
             fReserve = fCount = count;
         }
     }
     SkTDArray(const SkTDArray<T>& src) {
         fReserve = fCount = 0;
         fArray = NULL;
-#ifdef SK_DEBUG
-        fData = NULL;
-#endif
         SkTDArray<T> tmp(src.fArray, src.fCount);
         this->swap(tmp);
     }
     ~SkTDArray() {
         sk_free(fArray);
     }
 
     SkTDArray<T>& operator=(const SkTDArray<T>& src) {
         if (this != &src) {
             if (src.fCount > fReserve) {
@@ skipping 11 matching lines @@
         return  a.fCount == b.fCount &&
                 (a.fCount == 0 ||
                  !memcmp(a.fArray, b.fArray, a.fCount * sizeof(T)));
     }
     friend bool operator!=(const SkTDArray<T>& a, const SkTDArray<T>& b) {
         return !(a == b);
     }
 
     void swap(SkTDArray<T>& other) {
         SkTSwap(fArray, other.fArray);
-#ifdef SK_DEBUG
-        SkTSwap(fData, other.fData);
-#endif
         SkTSwap(fReserve, other.fReserve);
         SkTSwap(fCount, other.fCount);
     }
 
     /** Return a ptr to the array of data, to be freed with sk_free. This also
         resets the SkTDArray to be empty.
      */
     T* detach() {
         T* array = fArray;
         fArray = NULL;
         fReserve = fCount = 0;
-        SkDEBUGCODE(fData = NULL;)
         return array;
     }
 
     bool isEmpty() const { return fCount == 0; }
 
     /**
      *  Return the number of elements in the array
      */
     int count() const { return fCount; }
 
@@ skipping 27 matching lines @@
         return (*this)[index];
     }
     const T&  getAt(int index) const {
         return (*this)[index];
     }
 
     void reset() {
         if (fArray) {
             sk_free(fArray);
             fArray = NULL;
-#ifdef SK_DEBUG
-            fData = NULL;
-#endif
             fReserve = fCount = 0;
         } else {
             SkASSERT(fReserve == 0 && fCount == 0);
         }
     }
 
     void rewind() {
         // same as setCount(0)
         fCount = 0;
     }
@@ skipping 183 matching lines @@
                 visitor(*curr);
             }
         }
     }
 
 #ifdef SK_DEBUG
     void validate() const {
         SkASSERT((fReserve == 0 && fArray == NULL) ||
                  (fReserve > 0 && fArray != NULL));
         SkASSERT(fCount <= fReserve);
-        SkASSERT(fData == (ArrayT*)fArray);
     }
 #endif
 
     void shrinkToFit() {
         fReserve = fCount;
         fArray = (T*)sk_realloc_throw(fArray, fReserve * sizeof(T));
     }
 
 private:
-#ifdef SK_DEBUG
-    enum {
-        kDebugArraySize = 16
-    };
-    typedef T ArrayT[kDebugArraySize];
-    ArrayT* fData;
-#endif
     T*      fArray;
     int     fReserve;
     int     fCount;
 
     /**
      *  Adjusts the number of elements in the array.
      *  This is the same as calling setCount(count() + delta).
      */
     void adjustCount(int delta) {
         this->setCount(fCount + delta);
     }
 
     /**
      *  Increase the storage allocation such that it can hold (fCount + extra)
      *  elements.
      *  It never shrinks the allocation, and it may increase the allocation by
      *  more than is strictly required, based on a private growth heuristic.
      *
      *  note: does NOT modify fCount
      */
     void resizeStorageToAtLeast(int count) {
         SkASSERT(count > fReserve);
         fReserve = count + 4;
         fReserve += fReserve / 4;
         fArray = (T*)sk_realloc_throw(fArray, fReserve * sizeof(T));
-#ifdef SK_DEBUG
-        fData = (ArrayT*)fArray;
-#endif
     }
 };
 
 #endif