Make GrIODB keep pending IO refs on all resources it records into its cmd stream.

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 206 matching lines @@
     size_t                                        fBlockSize;
     size_t                                        fItemSize;
     int                                           fItemsPerBlock;
     bool                                          fOwnFirstBlock;
     int                                           fCount;
     int                                           fInsertionIndexInBlock;
 
     typedef SkNoncopyable INHERITED;
 };
 
-template <typename T>
-class GrTAllocator : SkNoncopyable {
+template <typename T> class GrTAllocator : SkNoncopyable {
 public:
     virtual ~GrTAllocator() { this->reset(); };
 
     /**
      * Create an allocator
      *
      * @param   itemsPerBlock   the number of items to allocate at once
      */
     explicit GrTAllocator(int itemsPerBlock)
         : fAllocator(sizeof(T), itemsPerBlock, NULL) {}
@@ skipping 114 matching lines @@
      *
      * @param   initialBlock    optional memory to use for the first block.
      *                          Must be at least size(T)*itemsPerBlock sized.
      *                          Caller is responsible for freeing this memory.
      */
     void setInitialBlock(void* initialBlock) {
         fAllocator.setInitialBlock(initialBlock);
     }
 
 private:
+    friend void* operator new<T>(size_t, GrTAllocator*);
+
     GrAllocator fAllocator;
     typedef SkNoncopyable INHERITED;
 };
 
 template <int N, typename T> class GrSTAllocator : public GrTAllocator<T> {
 private:
     typedef GrTAllocator<T> INHERITED;
 
 public:
     GrSTAllocator() : INHERITED(N) {
         this->setInitialBlock(fStorage.get());
     }
 
 private:
     SkAlignedSTStorage<N, T> fStorage;
 };
 
+template <typename T> void* operator new(size_t size, GrTAllocator<T>* allocator) {
+    return allocator->fAllocator.push_back();
+}
+
+// Skia doesn't use C++ exceptions but it may be compiled with them enabled. Having an op delete
+// to match the op new silences warnings about missing op delete when a constructor throws an
+// exception.
+template <typename T> void operator delete(void*, GrTAllocator<T>*) {
+    SK_CRASH();
+}
+
+#define GrNEW_APPEND_TO_ALLOCATOR(allocator_ptr, type_name, args) \
+    new (allocator_ptr) type_name args
+
 #endif