Proof of adoption in SkRecord::replace.

src/record/SkRecord.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
@@ skipping 64 matching lines @@
             fRecords.realloc(fReserved);
             fTypes.realloc(fReserved);
         }
 
         fTypes[fCount] = T::kType;
         return fRecords[fCount++].set(this->alloc<T>());
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
-    // References to the old command remain valid for the life of the SkRecord, but
-    // you must destroy the old command.  (It's okay to destroy it first before calling replace.)
+    // References to the original command are invalidated.
     template <typename T>
     T* replace(unsigned i) {
         SkASSERT(i < this->count());
+
+        Destroyer destroyer;
+        this->mutate(i, destroyer);
+
         fTypes[i] = T::kType;
         return fRecords[i].set(this->alloc<T>());
     }
 
-    // A mutator that can be used with replace to destroy canvas commands.
-    struct Destroyer {
-        template <typename T>
-        void operator()(T* record) { record->~T(); }
-    };
+    // Replace the i-th command with a new command of type T.
+    // You are expected to placement new an object of type T onto this pointer.
+    // You must show proof that you've already adopted the existing command.
+    template <typename T, typename Existing>
+    T* replace(unsigned i, const SkRecords::Adopted<Existing>& proofOfAdoption) {
+        SkASSERT(i < this->count());
+
+        SkASSERT(Existing::kType == fTypes[i]);
+        SkASSERT(proofOfAdoption == fRecords[i].ptr<Existing>());
+
+        fTypes[i] = T::kType;
+        return fRecords[i].set(this->alloc<T>());
+    }
 
 private:
     // Implementation notes!
     //
     // Logically an SkRecord is structured as an array of pointers into a big chunk of memory where
     // records representing each canvas draw call are stored:
     //
     // fRecords:  [*][*][*]...
     //             |  |  |
     //             |  |  |
@@ skipping 18 matching lines @@
     // visit() or mutate().  The recorded canvas calls don't have to have any idea about the
     // operations performed on them.
     //
     // We store the types in a parallel fTypes array, mainly so that they can be tightly packed as
     // single bytes.  This has the side effect of allowing very fast analysis passes over an
     // SkRecord looking for just patterns of draw commands (or using this as a quick reject
     // mechanism) though there's admittedly not a very good API exposed publically for this.
     //
     // The cost to append a T into this structure is 1 + sizeof(void*) + sizeof(T).
 
+    // A mutator that can be used with replace to destroy canvas commands.
+    struct Destroyer {
+        template <typename T>
+        void operator()(T* record) { record->~T(); }
+    };
 
     // Logically the same as SkRecords::Type, but packed into 8 bits.
     struct Type8 {
     public:
         // This intentionally converts implicitly back and forth.
         Type8(SkRecords::Type type) : fType(type) { SkASSERT(*this == type); }
         operator SkRecords::Type () { return (SkRecords::Type)fType; }
 
     private:
         uint8_t fType;
     };
 
     // An untyped pointer to some bytes in fAlloc.  This is the interface for polymorphic dispatch:
     // visit() and mutate() work with the parallel fTypes array to do the work of a vtable.
     struct Record {
     public:
         // Point this record to its data in fAlloc.  Returns ptr for convenience.
         template <typename T>
         T* set(T* ptr) {
             fPtr = ptr;
             return ptr;
         }
 
+        // Get the data in fAlloc, assuming it's of type T.
+        template <typename T>
+        T* ptr() const { return (T*)fPtr; }
+
         // Visit this record with functor F (see public API above) assuming the record we're
         // pointing to has this type.
         template <typename F>
         void visit(Type8 type, F& f) const {
         #define CASE(T) case SkRecords::T##_Type: return f(*this->ptr<SkRecords::T>());
             switch(type) { SK_RECORD_TYPES(CASE) }
         #undef CASE
         }
 
         // Mutate this record with functor F (see public API above) assuming the record we're
         // pointing to has this type.
         template <typename F>
         void mutate(Type8 type, F& f) {
         #define CASE(T) case SkRecords::T##_Type: return f(this->ptr<SkRecords::T>());
             switch(type) { SK_RECORD_TYPES(CASE) }
         #undef CASE
         }
 
     private:
-        template <typename T>
-        T* ptr() const { return (T*)fPtr; }
-
         void* fPtr;
     };
 
     // fAlloc needs to be a data structure which can append variable length data in contiguous
     // chunks, returning a stable handle to that data for later retrieval.
     //
     // fRecords and fTypes need to be data structures that can append fixed length data, and need to
     // support efficient forward iteration.  (They don't need to be contiguous or indexable.)
 
     SkChunkAlloc fAlloc;
     SkAutoTMalloc<Record> fRecords;
     SkAutoTMalloc<Type8> fTypes;
     // fCount and fReserved measure both fRecords and fTypes, which always grow in lock step.
     unsigned fCount;
     unsigned fReserved;
     const unsigned kFirstReserveCount;
 };
 
 #endif//SkRecord_DEFINED