Eliminate useless NULL push by making fIndexedData 0-based.

src/core/SkPictureFlat.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPictureFlat_DEFINED
 #define SkPictureFlat_DEFINED
 
@@ skipping 371 matching lines @@
     , fReady(false) {
         this->reset();
     }
 
     /**
      * Clears the dictionary of all entries. However, it does NOT free the
      * memory that was allocated for each entry (that's owned by controller).
      */
     void reset() {
         fIndexedData.rewind();
-        // TODO(mtklein): There's no reason to have the index start from 1.  Clean this up.
-        // index 0 is always empty since it is used as a signal that find failed
-        fIndexedData.push(NULL);
     }
 
     ~SkFlatDictionary() {
         sk_free(fScratch);
     }
 
     int count() const {
-        SkASSERT(fHash.count() == fIndexedData.count() - 1);
+        SkASSERT(fHash.count() == fIndexedData.count());
         return fHash.count();
     }
 
     // For testing only.  Index is zero-based.
     const SkFlatData* operator[](int index) {
-        return fIndexedData[index+1];
+        return fIndexedData[index];
     }
 
     /**
      * Given an element of type T return its 1-based index in the dictionary. If
      * the element wasn't previously in the dictionary it is automatically
      * added.
      *
      */
     int find(const T& element) {
         return this->findAndReturnFlat(element)->index();
@@ skipping 23 matching lines @@
         }
 
         // If we don't have the thing to replace, we're done.
         const SkFlatData* found = fHash.find(*toReplace);
         if (found == NULL) {
             *replaced = false;
             return flat;
         }
 
         // findAndReturnMutableFlat put flat at the back.  Swap it into found->index() instead.
+        // indices in SkFlatData are 1-based, while fIndexedData is 0-based.  Watch out!
         SkASSERT(flat->index() == this->count());
         flat->setIndex(found->index());
-        fIndexedData.removeShuffle(found->index());
-        SkASSERT(flat == fIndexedData[found->index()]);
+        fIndexedData.removeShuffle(found->index()-1);
+        SkASSERT(flat == fIndexedData[found->index()-1]);
 
         // findAndReturnMutableFlat already called fHash.add(), so we just clean up the old entry.
         fHash.remove(*found);
         fController->unalloc((void*)found);
         SkASSERT(this->count() == oldCount);
 
         *replaced = true;
         return flat;
     }
 
     /**
      *  Unflatten the objects and return them in SkTRefArray, or return NULL
      *  if there no objects.  Caller takes ownership of result.
      */
     SkTRefArray<T>* unflattenToArray() const {
         const int count = this->count();
         if (count == 0) {
             return NULL;
         }
         SkTRefArray<T>* array = SkTRefArray<T>::Create(count);
         for (int i = 0; i < count; i++) {
-            this->unflatten(&array->writableAt(i), fIndexedData[i+1]);
+            this->unflatten(&array->writableAt(i), fIndexedData[i]);
         }
         return array;
     }
 
     /**
      * Unflatten the specific object at the given index.
      * Caller takes ownership of the result.
      */
     T* unflatten(int index) const {
-        const SkFlatData* element = fIndexedData[index];
+        // index is 1-based, while fIndexedData is 0-based.
+        const SkFlatData* element = fIndexedData[index-1];
         SkASSERT(index == element->index());
 
         T* dst = new T;
         this->unflatten(dst, element);
         return dst;
     }
 
     /**
      * Find or insert a flattened version of element into the dictionary.
      * Caller does not take ownership of the result.  This will not return NULL.
@@ skipping 100 matching lines @@
                                    fController->getTypefacePlayback());
     }
 
     // All SkFlatData* stored in fIndexedData and fHash are owned by the controller.
     SkAutoTUnref<SkFlatController> fController;
     size_t fScratchSize;  // How many bytes fScratch has allocated for data itself.
     SkFlatData* fScratch;  // Owned, lazily allocated, must be freed with sk_free.
     SkOrderedWriteBuffer fWriteBuffer;
     bool fReady;
 
-    // For index -> SkFlatData.  fIndexedData[0] is always NULL.
+    // For index -> SkFlatData.  0-based, while all indices in the API are 1-based.  Careful!
     SkTDArray<const SkFlatData*> fIndexedData;
 
     // For SkFlatData -> cached SkFlatData, which has index().
     SkTDynamicHash<SkFlatData, SkFlatData,
                    SkFlatData::Identity, SkFlatData::Hash, SkFlatData::Equal> fHash;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Some common dictionaries are defined here for both reference and convenience
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 60 matching lines @@
     }
 
 private:
     SkChunkAlloc               fHeap;
     SkAutoTUnref<SkRefCntSet>  fTypefaceSet;
     void*                      fLastAllocated;
     mutable SkTypefacePlayback fTypefacePlayback;
 };
 
 #endif