Revert of add asserts around results from requestLock (patchset #3 id:40001 of https...

Reason for revert:
asserts in ui/gfx unittests (need to investigate why)

[ RUN      ] RenderTextTest.SelectionKeepsLigatures
[14602:14602:0529/134016:16779526944:INFO:SkPixelRef.cpp(164)] ../../third_party/skia/src/core/SkPixelRef.cpp:164: failed assertion "pixels"

Original issue's description:
> add asserts around results from requestLock and lockPixels, ensuring that true always means we have non-null pixels (and non-null colortable if that matches the colortype)
>
> BUG= 491975
> TBR=
>
> Committed: https://skia.googlesource.com/skia/+/f941a68126d8fe647eaea902c244c466568b7809

TBR=scroggo@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG= 491975

Review URL: https://codereview.chromium.org/1159013006

diff --git a/include/core/SkPixelRef.h b/include/core/SkPixelRef.h
index 3898269..7c3156e 100644 (file)
--- a/include/core/SkPixelRef.h
+++ b/include/core/SkPixelRef.h
@@ -75,8 +75,6 @@ public:
      *  Calling lockPixels returns a LockRec struct (on success).
      */
     struct LockRec {
-        LockRec() : fPixels(NULL), fColorTable(NULL) {}
-
         void*           fPixels;
         SkColorTable*   fColorTable;
         size_t          fRowBytes;
@@ -201,13 +199,11 @@ public:
     };
 
     struct LockResult {
-        LockResult() : fPixels(NULL), fCTable(NULL) {}
-
         void        (*fUnlockProc)(void* ctx);
         void*       fUnlockContext;
 
-        const void* fPixels;
         SkColorTable* fCTable;  // should be NULL unless colortype is kIndex8
+        const void* fPixels;
         size_t      fRowBytes;
         SkISize     fSize;
 
@@ -349,7 +345,7 @@ private:
     LockRec         fRec;
     int             fLockCount;
 
-    bool lockPixelsInsideMutex();
+    bool lockPixelsInsideMutex(LockRec* rec);
 
     // Bottom bit indicates the Gen ID is unique.
     bool genIDIsUnique() const { return SkToBool(fTaggedGenID.load() & 1); }

diff --git a/src/core/SkPixelRef.cpp b/src/core/SkPixelRef.cpp
index 1fda14b..90e2a40 100644 (file)
--- a/src/core/SkPixelRef.cpp
+++ b/src/core/SkPixelRef.cpp
@@ -160,18 +160,8 @@ void SkPixelRef::cloneGenID(const SkPixelRef& that) {
     SkASSERT(!that. genIDIsUnique());
 }
 
-static void validate_pixels_ctable(const void* pixels, const SkColorTable* ctable, SkColorType ct) {
-    SkASSERT(pixels);
-    if (kIndex_8_SkColorType == ct) {
-        SkASSERT(ctable);
-    } else {
-        SkASSERT(NULL == ctable);
-    }
-}
-
 void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) {
 #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED
-    validate_pixels_ctable(pixels, ctable, fInfo.colorType());
     // only call me in your constructor, otherwise fLockCount tracking can get
     // out of sync.
     fRec.fPixels = pixels;
@@ -182,33 +172,38 @@ void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctabl
 #endif
 }
 
-// Increments fLockCount only on success
-bool SkPixelRef::lockPixelsInsideMutex() {
+bool SkPixelRef::lockPixelsInsideMutex(LockRec* rec) {
     fMutex->assertHeld();
 
+    // For historical reasons, we always inc fLockCount, even if we return false.
+    // It would be nice to change this (it seems), and only inc if we actually succeed...
     if (1 == ++fLockCount) {
         SkASSERT(fRec.isZero());
-        if (!this->onNewLockPixels(&fRec)) {
-            fRec.zero();
+
+        LockRec rec;
+        if (!this->onNewLockPixels(&rec)) {
             fLockCount -= 1;    // we return fLockCount unchanged if we fail.
             return false;
         }
+        SkASSERT(!rec.isZero());    // else why did onNewLock return true?
+        fRec = rec;
     }
-    validate_pixels_ctable(fRec.fPixels, fRec.fColorTable, fInfo.colorType());
+    *rec = fRec;
     return true;
 }
 
-// For historical reasons, we always inc fLockCount, even if we return false.
-// It would be nice to change this (it seems), and only inc if we actually succeed...
-bool SkPixelRef::lockPixels() {
+bool SkPixelRef::lockPixels(LockRec* rec) {
     SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
 
-    if (!fPreLocked) {
+    if (fPreLocked) {
+        *rec = fRec;
+        return true;
+    } else {
         TRACE_EVENT_BEGIN0("skia", "SkPixelRef::lockPixelsMutex");
         SkAutoMutexAcquire  ac(*fMutex);
         TRACE_EVENT_END0("skia", "SkPixelRef::lockPixelsMutex");
         SkDEBUGCODE(int oldCount = fLockCount;)
-        bool success = this->lockPixelsInsideMutex();
+        bool success = this->lockPixelsInsideMutex(rec);
         // lockPixelsInsideMutex only increments the count if it succeeds.
         SkASSERT(oldCount + (int)success == fLockCount);
 
@@ -216,19 +211,14 @@ bool SkPixelRef::lockPixels() {
             // For compatibility with SkBitmap calling lockPixels, we still want to increment
             // fLockCount even if we failed. If we updated SkBitmap we could remove this oddity.
             fLockCount += 1;
-            return false;
         }
+        return success;
     }
-    validate_pixels_ctable(fRec.fPixels, fRec.fColorTable, fInfo.colorType());
-    return true;
 }
 
-bool SkPixelRef::lockPixels(LockRec* rec) {
-    if (this->lockPixels()) {
-        *rec = fRec;
-        return true;
-    }
-    return false;
+bool SkPixelRef::lockPixels() {
+    LockRec rec;
+    return this->lockPixels(&rec);
 }
 
 void SkPixelRef::unlockPixels() {
@@ -263,14 +253,11 @@ bool SkPixelRef::requestLock(const LockRequest& request, LockResult* result) {
         result->fPixels = fRec.fPixels;
         result->fRowBytes = fRec.fRowBytes;
         result->fSize.set(fInfo.width(), fInfo.height());
+        return true;
     } else {
         SkAutoMutexAcquire  ac(*fMutex);
-        if (!this->onRequestLock(request, result)) {
-            return false;
-        }
+        return this->onRequestLock(request, result);
     }
-    validate_pixels_ctable(result->fPixels, result->fCTable, fInfo.colorType());
-    return true;
 }
 
 bool SkPixelRef::lockPixelsAreWritable() const {
@@ -371,15 +358,16 @@ static void unlock_legacy_result(void* ctx) {
 }
 
 bool SkPixelRef::onRequestLock(const LockRequest& request, LockResult* result) {
-    if (!this->lockPixelsInsideMutex()) {
+    LockRec rec;
+    if (!this->lockPixelsInsideMutex(&rec)) {
         return false;
     }
 
     result->fUnlockProc = unlock_legacy_result;
     result->fUnlockContext = SkRef(this);   // this is balanced in our fUnlockProc
-    result->fCTable = fRec.fColorTable;
-    result->fPixels = fRec.fPixels;
-    result->fRowBytes = fRec.fRowBytes;
+    result->fCTable = rec.fColorTable;
+    result->fPixels = rec.fPixels;
+    result->fRowBytes = rec.fRowBytes;
     result->fSize.set(fInfo.width(), fInfo.height());
     return true;
 }