Make GrDrawState and GrEffectStage use the pending io/exec ref mechanisms.

src/gpu/GrAllocator.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAllocator_DEFINED
 #define GrAllocator_DEFINED
 
@@ skipping 42 matching lines @@
         if (fItemsPerBlock == fInsertionIndexInBlock) {
             fBlocks.push_back() = sk_malloc_throw(fBlockSize);
             fInsertionIndexInBlock = 0;
         }
         void* ret = (char*)fBlocks.back() + fItemSize * fInsertionIndexInBlock;
         ++fCount;
         ++fInsertionIndexInBlock;
         return ret;
     }
 
     /**

[robertphillips, 2014/09/04 20:24:35]

Add a unit test for this new capability ?

[bsalomon, 2014/09/05 20:02:54]

Done (in separate CL)

+     * Remove the last item, only call if count() != 0
+     */
+    void pop_back() {
+        SkASSERT(fCount);
+        SkASSERT(fInsertionIndexInBlock > 0);
+        --fInsertionIndexInBlock;
+        --fCount;
+        if (0 == fInsertionIndexInBlock) {
+            // Never delete the first block
+            if (fBlocks.count() > 1) {
+                sk_free(fBlocks.back());
+                fBlocks.pop_back();
+                fInsertionIndexInBlock = fItemsPerBlock;
+            }
+        }
+    }
+
+    /**
      * Removes all added items.
      */
     void reset() {
         int firstBlockToFree = fOwnFirstBlock ? 0 : 1;
         for (int i = firstBlockToFree; i < fBlocks.count(); ++i) {
             sk_free(fBlocks[i]);
         }
         if (fOwnFirstBlock) {
             fBlocks.reset();
             // This force us to allocate a new block on push_back().
@@ skipping 28 matching lines @@
 
     /**
      * Access last item, only call if count() != 0
      */
     const void* back() const {
         SkASSERT(fCount);
         SkASSERT(fInsertionIndexInBlock > 0);
         return (const char*)(fBlocks.back()) + (fInsertionIndexInBlock - 1) * fItemSize;
     }
 
-
     /**
      * Iterates through the allocator. This is faster than using operator[] when walking linearly
      * through the allocator.
      */
     class Iter {
     public:
         /**
          * Initializes the iterator. next() must be called before get().
          */
         Iter(const GrAllocator* allocator)
@@ skipping 110 matching lines @@
     }
 
     T& push_back(const T& t) {
         void* item = fAllocator.push_back();
         SkASSERT(NULL != item);
         SkNEW_PLACEMENT_ARGS(item, T, (t));
         return *(T*)item;
     }
 
     /**
+     * Remove the last item, only call if count() != 0
+     */
+    void pop_back() {
+        this->back().~T();
+        fAllocator.pop_back();
+    }
+
+    /**
      * Removes all added items.
      */
     void reset() {
         int c = fAllocator.count();
         for (int i = 0; i < c; ++i) {
             ((T*)fAllocator[i])->~T();
         }
         fAllocator.reset();
     }
 
@@ skipping 93 matching lines @@
 public:
     GrSTAllocator() : INHERITED(N) {
         this->setInitialBlock(fStorage.get());
     }
 
 private:
     SkAlignedSTStorage<N, T> fStorage;
 };
 
 #endif