SkTRacy<T> -> SkAtomic<T>

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 "SkBitmapCache.h"
 #include "SkPixelRef.h"
 #include "SkThread.h"
@@ skipping 104 matching lines @@
     this->needsNewGenID();
     fIsImmutable = false;
     fPreLocked = false;
 }
 
 SkPixelRef::~SkPixelRef() {
     this->callGenIDChangeListeners();
 }
 
 void SkPixelRef::needsNewGenID() {
-    fGenerationID = 0;
-    fUniqueGenerationID = false;
+    fGenerationID.store(0);

[Alexander Potapenko, 2015/03/10 09:55:20]

Perhaps the sk_memory_order_acquire and sk_memory_order_release should be enough
here.
Agreed this isn't necessary if the performance impact is minor.

[mtklein, 2015/03/10 13:33:11]

Yep, I think acquire-release is enough too.  So far this hasn't seemed hot
enough to worry yet, but we'll keep it in mind.  Thanks for thinking about it!

+    fUniqueGenerationID.store(false);
 }
 
 void SkPixelRef::cloneGenID(const SkPixelRef& that) {
     // This is subtle.  We must call that.getGenerationID() to make sure its genID isn't 0.
-    this->fGenerationID = that.getGenerationID();
-    this->fUniqueGenerationID = false;
-    that.fUniqueGenerationID = false;
+    this->fGenerationID.store(that.getGenerationID());
+    this->fUniqueGenerationID.store(false);
+    that.fUniqueGenerationID.store(false);
 }
 
 void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) {
 #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED
     // only call me in your constructor, otherwise fLockCount tracking can get
     // out of sync.
     fRec.fPixels = pixels;
     fRec.fColorTable = ctable;
     fRec.fRowBytes = rowBytes;
     fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT;
@@ skipping 48 matching lines @@
 
 bool SkPixelRef::lockPixelsAreWritable() const {
     return this->onLockPixelsAreWritable();
 }
 
 bool SkPixelRef::onLockPixelsAreWritable() const {
     return true;
 }
 
 uint32_t SkPixelRef::getGenerationID() const {
-    if (0 == fGenerationID) {
-        fGenerationID = SkNextPixelRefGenerationID();
-        fUniqueGenerationID = true;  // The only time we can be sure of this!
+    uint32_t id = fGenerationID.load();
+    if (0 == id) {
+        id = SkNextPixelRefGenerationID();
+        fGenerationID.store(id);
+        fUniqueGenerationID.store(true);  // The only time we can be sure of this!
     }
-    return fGenerationID;
+    return id;
 }
 
 void SkPixelRef::addGenIDChangeListener(GenIDChangeListener* listener) {
-    if (NULL == listener || !fUniqueGenerationID) {
+    if (NULL == listener || !fUniqueGenerationID.load()) {
         // No point in tracking this if we're not going to call it.
         SkDELETE(listener);
         return;
     }
     *fGenIDChangeListeners.append() = listener;
 }
 
 // we need to be called *before* the genID gets changed or zerod
 void SkPixelRef::callGenIDChangeListeners() {
     // We don't invalidate ourselves if we think another SkPixelRef is sharing our genID.
-    if (fUniqueGenerationID) {
+    if (fUniqueGenerationID.load()) {
         for (int i = 0; i < fGenIDChangeListeners.count(); i++) {
             fGenIDChangeListeners[i]->onChange();
         }
 
         // If we can flag the pixelref somehow whenever it was actually added to the cache,
         // perhaps it would be nice to only call this notifier in that case. For now we always
         // call it, since we don't know if it was cached or not.
-        SkNotifyBitmapGenIDIsStale(fGenerationID);
+        SkNotifyBitmapGenIDIsStale(this->getGenerationID());
     }
     // Listeners get at most one shot, so whether these triggered or not, blow them away.
     fGenIDChangeListeners.deleteAll();
 }
 
 void SkPixelRef::notifyPixelsChanged() {
 #ifdef SK_DEBUG
     if (fIsImmutable) {
         SkDebugf("========== notifyPixelsChanged called on immutable pixelref");
     }
@@ skipping 24 matching lines @@
 
 bool SkPixelRef::onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
                                  SkYUVColorSpace* colorSpace) {
     return false;
 }
 
 size_t SkPixelRef::getAllocatedSizeInBytes() const {
     return 0;
 }