Proof of adoption in SkRecord::replace.

src/record/SkRecordOpts.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRecordOpts.h"
 
 #include "SkRecords.h"
 #include "SkTDArray.h"
 
 void SkRecordOptimize(SkRecord* record) {
     // TODO(mtklein): fuse independent optimizations to reduce number of passes?
     SkRecordNoopSaveRestores(record);
     SkRecordAnnotateCullingPairs(record);
     SkRecordReduceDrawPosTextStrength(record);  // Helpful to run this before BoundDrawPosTextH.
     SkRecordBoundDrawPosTextH(record);
 }
 
-// Streamline replacing one command with another.
-#define REPLACE(record, index, T, ...) \
-    SkNEW_PLACEMENT_ARGS(record->replace<SkRecords::T>(index), SkRecords::T, (__VA_ARGS__))
-
 namespace {
 
 // Convenience base class to share some common implementation code.
 class Common : SkNoncopyable {
 public:
     explicit Common(SkRecord* record) : fRecord(record), fIndex(0) {}
 
     unsigned index() const { return fIndex; }
     void next() { ++fIndex; }
 
@@ skipping 39 matching lines @@
 template <>
 void SaveRestoreNooper::operator()(SkRecords::Save* r) {
     fSave = SkCanvas::kMatrixClip_SaveFlag == r->flags ? this->index() : kInactive;
 }
 
 template <>
 void SaveRestoreNooper::operator()(SkRecords::Restore* r) {
     if (fSave != kInactive) {
         // Remove everything between the save and restore, inclusive on both sides.
         fChanged = true;
-        SkRecord::Destroyer destroyer;
         for (unsigned i = fSave; i <= this->index(); i++) {
-            fRecord->mutate(i, destroyer);
-            REPLACE(fRecord, i, NoOp);
+            fRecord->replace<SkRecords::NoOp>(i);
         }
         fSave = kInactive;
     }
 }
 
 
 // Tries to replace PushCull with PairedPushCull, which lets us skip to the paired PopCull
 // when the canvas can quickReject the cull rect.
 class CullAnnotator : public Common {
 public:
@@ skipping 19 matching lines @@
 }
 
 template <>
 void CullAnnotator::operator()(SkRecords::PopCull* pop) {
     Pair push = fPushStack.top();
     fPushStack.pop();
 
     SkASSERT(this->index() > push.index);
     unsigned skip = this->index() - push.index;
 
-    // PairedPushCull adopts push.command.
-    REPLACE(fRecord, push.index, PairedPushCull, push.command, skip);
+    SkRecords::Adopted<SkRecords::PushCull> adopted(push.command);
+    SkNEW_PLACEMENT_ARGS(fRecord->replace<SkRecords::PairedPushCull>(push.index, adopted),
+                         SkRecords::PairedPushCull, (&adopted, skip));
 }
 
 // Replaces DrawPosText with DrawPosTextH when all Y coordinates are equal.
 class StrengthReducer : public Common {
 public:
     explicit StrengthReducer(SkRecord* record) : Common(record) {}
 
     // Do nothing to most ops.
     template <typename T>
     void operator()(T*) {}
@@ skipping 18 matching lines @@
 
     // r->pos is points SkPoints, [(x,y),(x,y),(x,y),(x,y), ... ].
     // We're going to squint and look at that as 2*points SkScalars, [x,y,x,y,x,y,x,y, ...].
     // Then we'll rearrange things so all the xs are in order up front, clobbering the ys.
     SK_COMPILE_ASSERT(sizeof(SkPoint) == 2 * sizeof(SkScalar), SquintingIsNotSafe);
     SkScalar* scalars = &r->pos[0].fX;
     for (unsigned i = 0; i < 2*points; i += 2) {
         scalars[i/2] = scalars[i];
     }
 
-    SkRecord::Destroyer destroyer;
-    fRecord->mutate(this->index(), destroyer);
-    REPLACE(fRecord, this->index(),
-            DrawPosTextH, (char*)r->text, r->byteLength, scalars, firstY, r->paint);
+    // Extend lifetime of r to the end of the method so we can copy its parts.
+    SkRecords::Adopted<SkRecords::DrawPosText> adopted(r);
+    SkNEW_PLACEMENT_ARGS(fRecord->replace<SkRecords::DrawPosTextH>(this->index(), adopted),
+                         SkRecords::DrawPosTextH,
+                         (r->text, r->byteLength, scalars, firstY, r->paint));
 }
 
 
 // Tries to replace DrawPosTextH with BoundedDrawPosTextH, which knows conservative upper and lower
 // bounds to use with SkCanvas::quickRejectY.
 class TextBounder : public Common {
 public:
     explicit TextBounder(SkRecord* record) : Common(record) {}
 
     // Do nothing to most ops.
@@ skipping 16 matching lines @@
     SkDEBUGCODE(r->paint.getFontMetrics(&metrics);)
     SkASSERT(-buffer <= metrics.fTop);
     SkASSERT(+buffer >= metrics.fBottom);
 
     // Let the paint adjust the text bounds.  We don't care about left and right here, so we use
     // 0 and 1 respectively just so the bounds rectangle isn't empty.
     SkRect bounds;
     bounds.set(0, r->y - buffer, SK_Scalar1, r->y + buffer);
     SkRect adjusted = r->paint.computeFastBounds(bounds, &bounds);
 
-    // BoundedDrawPosTextH adopts r.
-    REPLACE(fRecord, this->index(), BoundedDrawPosTextH, r, adjusted.fTop, adjusted.fBottom);
+    SkRecords::Adopted<SkRecords::DrawPosTextH> adopted(r);
+    SkNEW_PLACEMENT_ARGS(fRecord->replace<SkRecords::BoundedDrawPosTextH>(this->index(), adopted),
+                         SkRecords::BoundedDrawPosTextH,
+                         (&adopted, adjusted.fTop, adjusted.fBottom));
 }
 
 template <typename Pass>
 static void run_pass(Pass& pass, SkRecord* record) {
     for (; pass.index() < record->count(); pass.next()) {
         record->mutate(pass.index(), pass);
     }
 }
 
 }  // namespace
@@ skipping 16 matching lines @@
 
 void SkRecordReduceDrawPosTextStrength(SkRecord* record) {
     StrengthReducer reducer(record);
     run_pass(reducer, record);
 }
 
 void SkRecordBoundDrawPosTextH(SkRecord* record) {
     TextBounder bounder(record);
     run_pass(bounder, record);
 }
-
-#undef REPLACE