Proactive SkPixelRef invalidation

src/core/SkPixelRef.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkPixelRef.h"
 #include "SkFlattenableBuffers.h"
 #include "SkThread.h"
@@ skipping 67 matching lines @@
 void SkPixelRef::setMutex(SkBaseMutex* mutex) {
     if (NULL == mutex) {
         mutex = get_default_mutex();
     }
     fMutex = mutex;
 }
 
 // just need a > 0 value, so pick a funny one to aid in debugging
 #define SKPIXELREF_PRELOCKED_LOCKCOUNT     123456789
 
-SkPixelRef::SkPixelRef(SkBaseMutex* mutex) : fPreLocked(false) {
+SkPixelRef::SkPixelRef(SkBaseMutex* mutex) {
     this->setMutex(mutex);
     fPixels = NULL;
     fColorTable = NULL; // we do not track ownership of this
     fLockCount = 0;
-    fGenerationID = 0;  // signal to rebuild
+    this->needsNewGenID();
     fIsImmutable = false;
     fPreLocked = false;
 }
 
 SkPixelRef::SkPixelRef(SkFlattenableReadBuffer& buffer, SkBaseMutex* mutex)
         : INHERITED(buffer) {
     this->setMutex(mutex);
     fPixels = NULL;
     fColorTable = NULL; // we do not track ownership of this
     fLockCount = 0;
     fIsImmutable = buffer.readBool();
     fGenerationID = buffer.readUInt();
+    fUniqueGenerationID = false;  // Conservatively assuming the original still exists.
     fPreLocked = false;
 }
 
+SkPixelRef::~SkPixelRef() {
+    this->invalidate();
+}
+
+void SkPixelRef::needsNewGenID() {
+    fGenerationID = 0;
+    fUniqueGenerationID = false;
+}
+
+void SkPixelRef::cloneGenID(const SkPixelRef& that) {
+    // This is subtle.  We must call that.getGenerationID() to make sure it's genID isn't 0.

[scroggo, 2013/10/22 21:04:02]

its*

[mtklein, 2013/10/23 15:28:10]

Done.

+    this->fGenerationID = that.getGenerationID();
+    this->fUniqueGenerationID = false;
+    that.fUniqueGenerationID = false;
+}
+
 void SkPixelRef::setPreLocked(void* pixels, SkColorTable* ctable) {
 #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED
     // only call me in your constructor, otherwise fLockCount tracking can get
     // out of sync.
     fPixels = pixels;
     fColorTable = ctable;
     fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT;
     fPreLocked = true;
 #endif
 }
 
 void SkPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeBool(fIsImmutable);
     // We write the gen ID into the picture for within-process recording. This
     // is safe since the same genID will never refer to two different sets of
     // pixels (barring overflow). However, each process has its own "namespace"
     // of genIDs. So for cross-process recording we write a zero which will
     // trigger assignment of a new genID in playback.
     if (buffer.isCrossProcess()) {
         buffer.writeUInt(0);
     } else {
         buffer.writeUInt(fGenerationID);
+        fUniqueGenerationID = false;  // Conservative, a copy is probably about to exist.
     }
 }
 
 void SkPixelRef::lockPixels() {
     SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
 
     if (!fPreLocked) {
         SkAutoMutexAcquire  ac(*fMutex);
 
         if (1 == ++fLockCount) {
@@ skipping 29 matching lines @@
     return false;
 }
 
 bool SkPixelRef::onDecodeInto(int pow2, SkBitmap* bitmap) {
     return false;
 }
 
 uint32_t SkPixelRef::getGenerationID() const {
     if (0 == fGenerationID) {
         fGenerationID = SkNextPixelRefGenerationID();
+        fUniqueGenerationID = true;  // The only time we can be sure of this!
     }
     return fGenerationID;
 }
 
+void SkPixelRef::addInvalidationListener(InvalidationListener* listener) {
+    if (NULL == listener || !fUniqueGenerationID) {
+        // No point in tracking this if we're not going to call it.
+        SkDELETE(listener);
+        return;
+    }
+    *fInvalidationListeners.append() = listener;
+}
+
+void SkPixelRef::invalidate() {
+    // We don't invalidate ourselves if we think another SkPixelRef is sharing our genID.
+    if (fUniqueGenerationID) {
+        for (int i = 0; i < fInvalidationListeners.count(); i++) {
+            fInvalidationListeners[i]->onInvalidate();
+        }
+    }
+    // Listeners get at most one shot, so whether these triggered or not, blow them away.

[scroggo, 2013/10/22 21:04:02]

Should these comments go in the header file so a future user knows that the
invalidation listeners may not get called?

[mtklein, 2013/10/23 15:28:10]

See if the header makes more sense now?  Leaving these here as a reminder.

[scroggo, 2013/10/23 15:39:19]

Yes, the header makes more sense now.

+    fInvalidationListeners.deleteAll();
+}
+
 void SkPixelRef::notifyPixelsChanged() {
 #ifdef SK_DEBUG
     if (fIsImmutable) {
         SkDebugf("========== notifyPixelsChanged called on immutable pixelref");
     }
 #endif
-    // this signals us to recompute this next time around
-    fGenerationID = 0;
+    this->invalidate();
+    this->needsNewGenID();
 }
 
 void SkPixelRef::setImmutable() {
     fIsImmutable = true;
 }
 
 bool SkPixelRef::readPixels(SkBitmap* dst, const SkIRect* subset) {
     return this->onReadPixels(dst, subset);
 }
 
 bool SkPixelRef::onReadPixels(SkBitmap* dst, const SkIRect* subset) {
     return false;
 }
 
 SkData* SkPixelRef::onRefEncodedData() {
     return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_BUILD_FOR_ANDROID
 void SkPixelRef::globalRef(void* data) {
     this->ref();
 }
 
 void SkPixelRef::globalUnref() {
     this->unref();
 }
 #endif