Implement vertex buffer caching in the tessellated path renderer.

src/core/SkPathRef.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBuffer.h"
 #include "SkLazyPtr.h"
 #include "SkPath.h"
 #include "SkPathRef.h"
 
 //////////////////////////////////////////////////////////////////////////////
 SkPathRef::Editor::Editor(SkAutoTUnref<SkPathRef>* pathRef,
                           int incReserveVerbs,
                           int incReservePoints)
 {
     if ((*pathRef)->unique()) {
         (*pathRef)->incReserve(incReserveVerbs, incReservePoints);
     } else {
         SkPathRef* copy = SkNEW(SkPathRef);
         copy->copy(**pathRef, incReserveVerbs, incReservePoints);
         pathRef->reset(copy);
     }
     fPathRef = *pathRef;
+    fPathRef->callGenIDChangeListeners();
     fPathRef->fGenerationID = 0;
     SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);)
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
+SkPathRef::~SkPathRef() {
+    this->callGenIDChangeListeners();
+    SkDEBUGCODE(this->validate();)
+    sk_free(fPoints);
+
+    SkDEBUGCODE(fPoints = NULL;)
+    SkDEBUGCODE(fVerbs = NULL;)
+    SkDEBUGCODE(fVerbCnt = 0x9999999;)
+    SkDEBUGCODE(fPointCnt = 0xAAAAAAA;)
+    SkDEBUGCODE(fPointCnt = 0xBBBBBBB;)
+    SkDEBUGCODE(fGenerationID = 0xEEEEEEEE;)
+    SkDEBUGCODE(fEditorsAttached = 0x7777777;)
+}
+
 // As a template argument, this must have external linkage.
 SkPathRef* sk_create_empty_pathref() {
     SkPathRef* empty = SkNEW(SkPathRef);
     empty->computeBounds();   // Avoids races later to be the first to do this.
     return empty;
 }
 
 SK_DECLARE_STATIC_LAZY_PTR(SkPathRef, empty, sk_create_empty_pathref);
 
 SkPathRef* SkPathRef::CreateEmpty() {
@@ skipping 105 matching lines @@
 
     // resetToSize clears fSegmentMask and fIsOval
     ref->fSegmentMask = segmentMask;
     ref->fIsOval = isOval;
     return ref;
 }
 
 void SkPathRef::Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
     if ((*pathRef)->unique()) {
         SkDEBUGCODE((*pathRef)->validate();)
+        (*pathRef)->callGenIDChangeListeners();
         (*pathRef)->fBoundsIsDirty = true;  // this also invalidates fIsFinite
         (*pathRef)->fVerbCnt = 0;
         (*pathRef)->fPointCnt = 0;
         (*pathRef)->fFreeSpace = (*pathRef)->currSize();
         (*pathRef)->fGenerationID = 0;
         (*pathRef)->fConicWeights.rewind();
         (*pathRef)->fSegmentMask = 0;
         (*pathRef)->fIsOval = false;
         SkDEBUGCODE((*pathRef)->validate();)
     } else {
@@ skipping 41 matching lines @@
     if (0 != memcmp(this->points(),
                     ref.points(),
                     ref.fPointCnt * sizeof(SkPoint))) {
         SkASSERT(!genIDMatch);
         return false;
     }
     if (fConicWeights != ref.fConicWeights) {
         SkASSERT(!genIDMatch);
         return false;
     }
-    // We've done the work to determine that these are equal. If either has a zero genID, copy
-    // the other's. If both are 0 then genID() will compute the next ID.
-    if (0 == fGenerationID) {
-        fGenerationID = ref.genID();
-    } else if (0 == ref.fGenerationID) {
-        ref.fGenerationID = this->genID();
-    }
     return true;
 }
 
 void SkPathRef::writeToBuffer(SkWBuffer* buffer) const {
     SkDEBUGCODE(this->validate();)
     SkDEBUGCODE(size_t beforePos = buffer->pos();)
 
     // Call getBounds() to ensure (as a side-effect) that fBounds
     // and fIsFinite are computed.
     const SkRect& bounds = this->getBounds();
@@ skipping 27 matching lines @@
 
 void SkPathRef::copy(const SkPathRef& ref,
                      int additionalReserveVerbs,
                      int additionalReservePoints) {
     SkDEBUGCODE(this->validate();)
     this->resetToSize(ref.fVerbCnt, ref.fPointCnt, ref.fConicWeights.count(),
                         additionalReserveVerbs, additionalReservePoints);
     memcpy(this->verbsMemWritable(), ref.verbsMemBegin(), ref.fVerbCnt * sizeof(uint8_t));
     memcpy(this->fPoints, ref.fPoints, ref.fPointCnt * sizeof(SkPoint));
     fConicWeights = ref.fConicWeights;
-    // We could call genID() here to force a real ID (instead of 0). However, if we're making
-    // a copy then presumably we intend to make a modification immediately afterwards.
-    fGenerationID = ref.fGenerationID;
     fBoundsIsDirty = ref.fBoundsIsDirty;
     if (!fBoundsIsDirty) {
         fBounds = ref.fBounds;
         fIsFinite = ref.fIsFinite;
     }
     fSegmentMask = ref.fSegmentMask;
     fIsOval = ref.fIsOval;
     SkDEBUGCODE(this->validate();)
 }
 
@@ skipping 144 matching lines @@
             // do a loop in case our global wraps around, as we never want to return a 0 or the
             // empty ID
             do {
                 fGenerationID = (sk_atomic_inc(&gPathRefGenerationID) + 1) & kMask;
             } while (fGenerationID <= kEmptyGenID);
         }
     }
     return fGenerationID;
 }
 
+void SkPathRef::addGenIDChangeListener(GenIDChangeListener* listener) {
+    if (NULL == listener || this == empty.get()) {
+        SkDELETE(listener);
+        return;
+    }
+    *fGenIDChangeListeners.append() = listener;
+}
+
+// we need to be called *before* the genID gets changed or zerod
+void SkPathRef::callGenIDChangeListeners() {
+    for (int i = 0; i < fGenIDChangeListeners.count(); i++) {
+        fGenIDChangeListeners[i]->onChange();
+    }
+
+    // Listeners get at most one shot, so whether these triggered or not, blow them away.
+    fGenIDChangeListeners.deleteAll();
+}
+
 #ifdef SK_DEBUG
 void SkPathRef::validate() const {
     this->INHERITED::validate();
     SkASSERT(static_cast<ptrdiff_t>(fFreeSpace) >= 0);
     SkASSERT(reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints) >= 0);
     SkASSERT((NULL == fPoints) == (NULL == fVerbs));
     SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
     SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
     SkASSERT(!(NULL == fPoints && fPointCnt));
     SkASSERT(!(NULL == fVerbs && fVerbCnt));
@@ skipping 53 matching lines @@
                 break;
             default:
                 SkDEBUGFAIL("Unknown Verb");
                 break;
         }
     }
     SkASSERT(mask == fSegmentMask);
 #endif // SK_DEBUG_PATH
 }
 #endif