switch over to no lockPixels in pixelref

Bug: skia:6481
Change-Id: I7c32d2e6dcd4c9cd8aa761ac5c4794c916eb650a
Reviewed-on: https://skia-review.googlesource.com/13193
Reviewed-by: Florin Malita <fmalita@chromium.org>
Reviewed-by: Leon Scroggins <scroggo@google.com>
Reviewed-by: Matt Sarett <msarett@google.com>
Commit-Queue: Mike Reed <reed@google.com>

2 files changed, 53 insertions, 51 deletions

diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index e42a15db21..ed3a97b7e0 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -130,8 +130,7 @@ sk_sp<SkPixelRef> SkMallocPixelRef::MakeWithData(const SkImageInfo& info,
     if (!is_valid(info, ctable.get())) {
         return nullptr;
     }
-    if ((rowBytes < info.minRowBytes())
-        || (data->size() < info.getSafeSize(rowBytes))) {
+    if ((rowBytes < info.minRowBytes()) || (data->size() < info.getSafeSize(rowBytes))) {
         return nullptr;
     }
     // must get this address before we call release
@@ -144,69 +143,44 @@ sk_sp<SkPixelRef> SkMallocPixelRef::MakeWithData(const SkImageInfo& info,
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage,
-                                   size_t rowBytes, SkColorTable* ctable,
-                                   bool ownsPixels)
-    : INHERITED(info)
-    , fCTable(sk_ref_sp(ctable))
-    , fReleaseProc(ownsPixels ? sk_free_releaseproc : nullptr)
-    , fReleaseProcContext(nullptr) {
-    // This constructor is now DEPRICATED.
-    SkASSERT(is_valid(info, fCTable.get()));
-    SkASSERT(rowBytes >= info.minRowBytes());
-
-    if (kIndex_8_SkColorType != info.colorType()) {
-        fCTable = nullptr;
+static sk_sp<SkColorTable> sanitize(const SkImageInfo& info, sk_sp<SkColorTable> ctable) {
+    if (kIndex_8_SkColorType == info.colorType()) {
+        SkASSERT(ctable);
+    } else {
+        ctable.reset(nullptr);
     }
-
-    fStorage = storage;
-    fRB = rowBytes;
-
-    this->setPreLocked(fStorage, rowBytes, fCTable.get());
+    return ctable;
 }
 
 SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage,
                                    size_t rowBytes, sk_sp<SkColorTable> ctable,
                                    SkMallocPixelRef::ReleaseProc proc,
                                    void* context)
-    : INHERITED(info)
+    : INHERITED(info, storage, rowBytes, sanitize(info, std::move(ctable)))
     , fReleaseProc(proc)
     , fReleaseProcContext(context)
-{
-    SkASSERT(is_valid(info, ctable.get()));
-    SkASSERT(rowBytes >= info.minRowBytes());
-
-    if (kIndex_8_SkColorType != info.colorType()) {
-        ctable.reset(nullptr);
-    }
-
-    fStorage = storage;
-    fCTable = std::move(ctable);
-    fRB = rowBytes;
-
-    this->setPreLocked(fStorage, rowBytes, fCTable.get());
-}
+{}
 
 
 SkMallocPixelRef::~SkMallocPixelRef() {
     if (fReleaseProc != nullptr) {
-        fReleaseProc(fStorage, fReleaseProcContext);
+        fReleaseProc(this->pixels(), fReleaseProcContext);
     }
 }
 
+#ifdef SK_SUPPORT_LEGACY_NO_ADDR_PIXELREF
 bool SkMallocPixelRef::onNewLockPixels(LockRec* rec) {
-    rec->fPixels = fStorage;
-    rec->fRowBytes = fRB;
-    rec->fColorTable = fCTable.get();
+    sk_throw(); // should never get here
     return true;
 }
 
 void SkMallocPixelRef::onUnlockPixels() {
     // nothing to do
 }
+#endif
 
 size_t SkMallocPixelRef::getAllocatedSizeInBytes() const {
-    return this->info().getSafeSize(fRB);
+    return this->info().getSafeSize(this->rowBytes());
 }
 
 #ifdef SK_SUPPORT_LEGACY_PIXELREFFACTORY
diff --git a/src/core/SkPixelRef.cpp b/src/core/SkPixelRef.cpp
index 2dc0369f58..942f127ed3 100644
--- a/src/core/SkPixelRef.cpp
+++ b/src/core/SkPixelRef.cpp
@@ -36,10 +36,22 @@ static SkImageInfo validate_info(const SkImageInfo& info) {
     return info.makeAlphaType(newAlphaType);
 }
 
+static void validate_pixels_ctable(const SkImageInfo& info, const SkColorTable* ctable) {
+    if (info.isEmpty()) {
+        return; // can't require ctable if the dimensions are empty
+    }
+    if (kIndex_8_SkColorType == info.colorType()) {
+        SkASSERT(ctable);
+    } else {
+        SkASSERT(nullptr == ctable);
+    }
+}
+
 #ifdef SK_TRACE_PIXELREF_LIFETIME
     static int32_t gInstCounter;
 #endif
 
+#ifdef SK_SUPPORT_LEGACY_NO_ADDR_PIXELREF
 SkPixelRef::SkPixelRef(const SkImageInfo& info)
     : fInfo(validate_info(info))
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
@@ -57,6 +69,31 @@ SkPixelRef::SkPixelRef(const SkImageInfo& info)
     fPreLocked = false;
     fAddedToCache.store(false);
 }
+#endif
+
+SkPixelRef::SkPixelRef(const SkImageInfo& info, void* pixels, size_t rowBytes,
+                       sk_sp<SkColorTable> ctable)
+    : fInfo(validate_info(info))
+    , fCTable(std::move(ctable))
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+    , fStableID(SkNextID::ImageID())
+#endif
+{
+    validate_pixels_ctable(fInfo, fCTable.get());
+    SkASSERT(rowBytes >= info.minRowBytes());
+#ifdef SK_TRACE_PIXELREF_LIFETIME
+    SkDebugf(" pixelref %d\n", sk_atomic_inc(&gInstCounter));
+#endif
+    fRec.fPixels = pixels;
+    fRec.fRowBytes = rowBytes;
+    fRec.fColorTable = fCTable.get();
+
+    fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT;
+    this->needsNewGenID();
+    fMutability = kMutable;
+    fPreLocked = true;
+    fAddedToCache.store(false);
+}
 
 SkPixelRef::~SkPixelRef() {
 #ifndef SK_SUPPORT_LEGACY_UNBALANCED_PIXELREF_LOCKCOUNT
@@ -88,17 +125,7 @@ void SkPixelRef::cloneGenID(const SkPixelRef& that) {
     SkASSERT(!that. genIDIsUnique());
 }
 
-static void validate_pixels_ctable(const SkImageInfo& info, const SkColorTable* ctable) {
-    if (info.isEmpty()) {
-        return; // can't require ctable if the dimensions are empty
-    }
-    if (kIndex_8_SkColorType == info.colorType()) {
-        SkASSERT(ctable);
-    } else {
-        SkASSERT(nullptr == ctable);
-    }
-}
-
+#ifdef SK_SUPPORT_LEGACY_NO_ADDR_PIXELREF
 void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) {
     SkASSERT(pixels);
     validate_pixels_ctable(fInfo, ctable);
@@ -110,6 +137,7 @@ void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctabl
     fLockCount = SKPIXELREF_PRELOCKED_LOCKCOUNT;
     fPreLocked = true;
 }
+#endif
 
 // Increments fLockCount only on success
 bool SkPixelRef::lockPixelsInsideMutex() {