fNextIndex is redundant. Remove it.

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 374 matching lines @@
 
     /**
      * 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);
-        fNextIndex = 1;
     }
 
     ~SkFlatDictionary() {
         sk_free(fScratch);
     }
 
     int count() const {
-        SkASSERT(fIndexedData.count() == fNextIndex);
-        SkASSERT(fHash.count() == fNextIndex - 1);
-        return fNextIndex - 1;
+        SkASSERT(fHash.count() == fIndexedData.count() - 1);
+        return fHash.count();
     }
 
     // For testing only.  Index is zero-based.
     const SkFlatData* operator[](int index) {
         return fIndexedData[index+1];
     }
 
     /**
      * 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
@@ skipping 27 matching lines @@
             return flat;
         }
 
         // 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 gave us index (fNextIndex-1), but we'll use the old one.
-        fIndexedData.remove(flat->index());
-        fNextIndex--;
+        // findAndReturnMutableFlat put flat at the back.  Swap it into found->index() instead.
+        SkASSERT(flat->index() == this->count());
         flat->setIndex(found->index());
-        fIndexedData[flat->index()] = flat;
+        fIndexedData.removeShuffle(found->index());
+        SkASSERT(flat == fIndexedData[found->index()]);
 
         // 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;
     }
 
@@ skipping 63 matching lines @@
         fWriteBuffer.setBitmapHeap(fController->getBitmapHeap());
         fWriteBuffer.setTypefaceRecorder(fController->getTypefaceSet());
         fWriteBuffer.setNamedFactoryRecorder(fController->getNamedFactorySet());
         fWriteBuffer.setFlags(fController->getWriteBufferFlags());
         fReady = true;
     }
 
     // As findAndReturnFlat, but returns a mutable pointer for internal use.
     SkFlatData* findAndReturnMutableFlat(const T& element) {
         // Only valid until the next call to resetScratch().
-        const SkFlatData& scratch = this->resetScratch(element, fNextIndex);
+        const SkFlatData& scratch = this->resetScratch(element, this->count()+1);
 
         SkFlatData* candidate = fHash.find(scratch);
         if (candidate != NULL) return candidate;
 
         SkFlatData* detached = this->detachScratch();
         fHash.add(detached);
-        *fIndexedData.insert(fNextIndex) = detached;
-        fNextIndex++;
+        *fIndexedData.append() = detached;
+        SkASSERT(fIndexedData.top()->index() == this->count());
         return detached;
     }
 
     // This reference is valid only until the next call to resetScratch() or detachScratch().
     const SkFlatData& resetScratch(const T& element, int index) {
         this->lazyInit();
 
         // Flatten element into fWriteBuffer (using fScratch as storage).
         fWriteBuffer.reset(fScratch->data(), fScratchSize);
         Traits::flatten(fWriteBuffer, element);
@@ skipping 40 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;
 
-    // We map between SkFlatData and a 1-based integer index.
-    int fNextIndex;
-
     // For index -> SkFlatData.  fIndexedData[0] is always NULL.
     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 61 matching lines @@
     }
 
 private:
     SkChunkAlloc               fHeap;
     SkAutoTUnref<SkRefCntSet>  fTypefaceSet;
     void*                      fLastAllocated;
     mutable SkTypefacePlayback fTypefacePlayback;
 };
 
 #endif