remove pixel assert from ctable validator

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 "SkMutex.h"
 #include "SkPixelRef.h"
@@ skipping 142 matching lines @@
     // Neither ID is unique any more.
     // (These & ~1u are actually redundant.  that.getGenerationID() just did it for us.)
     this->fTaggedGenID.store(genID & ~1u);
     that. fTaggedGenID.store(genID & ~1u);
 
     // This method isn't threadsafe, so these asserts should be fine.
     SkASSERT(!this->genIDIsUnique());
     SkASSERT(!that. genIDIsUnique());
 }
 
-static void validate_pixels_ctable(const SkImageInfo& info, const void* pixels,
-                                   const SkColorTable* ctable) {
+static void validate_pixels_ctable(const SkImageInfo& info, const SkColorTable* ctable) {
     if (info.isEmpty()) {
-        return; // can't require pixels if the dimensions are empty
+        return; // can't require ctable if the dimensions are empty
     }
-    SkASSERT(pixels);
     if (kIndex_8_SkColorType == info.colorType()) {
         SkASSERT(ctable);
     } else {
         SkASSERT(NULL == ctable);
     }
 }
 
 void SkPixelRef::setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable) {
 #ifndef SK_IGNORE_PIXELREF_SETPRELOCKED
-    validate_pixels_ctable(fInfo, pixels, ctable);
+    SkASSERT(pixels);
+    validate_pixels_ctable(fInfo, ctable);
     // 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;
     fPreLocked = true;
 #endif
 }
 
 // Increments fLockCount only on success
 bool SkPixelRef::lockPixelsInsideMutex() {
     fMutex->assertHeld();
 
     if (1 == ++fLockCount) {
         SkASSERT(fRec.isZero());
         if (!this->onNewLockPixels(&fRec)) {
             fRec.zero();
             fLockCount -= 1;    // we return fLockCount unchanged if we fail.
             return false;
         }
     }
-    validate_pixels_ctable(fInfo, fRec.fPixels, fRec.fColorTable);
-    return fRec.fPixels != NULL;
+    if (fRec.fPixels) {
+        validate_pixels_ctable(fInfo, fRec.fColorTable);
+        return true;
+    }
+    return false;
 }
 
 // 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() {
     SkASSERT(!fPreLocked || SKPIXELREF_PRELOCKED_LOCKCOUNT == fLockCount);
 
     if (!fPreLocked) {
         TRACE_EVENT_BEGIN0("skia", "SkPixelRef::lockPixelsMutex");
         SkAutoMutexAcquire  ac(*fMutex);
         TRACE_EVENT_END0("skia", "SkPixelRef::lockPixelsMutex");
         SkDEBUGCODE(int oldCount = fLockCount;)
         bool success = this->lockPixelsInsideMutex();
         // lockPixelsInsideMutex only increments the count if it succeeds.
         SkASSERT(oldCount + (int)success == fLockCount);
 
         if (!success) {
             // 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;
         }
     }
-    validate_pixels_ctable(fInfo, fRec.fPixels, fRec.fColorTable);
-    return fRec.fPixels != NULL;
+    if (fRec.fPixels) {
+        validate_pixels_ctable(fInfo, fRec.fColorTable);
+        return true;
+    }
+    return false;
 }
 
 bool SkPixelRef::lockPixels(LockRec* rec) {
     if (this->lockPixels()) {
         *rec = fRec;
         return true;
     }
     return false;
 }
 
@@ skipping 32 matching lines @@
         result->fCTable = fRec.fColorTable;
         result->fPixels = fRec.fPixels;
         result->fRowBytes = fRec.fRowBytes;
         result->fSize.set(fInfo.width(), fInfo.height());
     } else {
         SkAutoMutexAcquire  ac(*fMutex);
         if (!this->onRequestLock(request, result)) {
             return false;
         }
     }
-    validate_pixels_ctable(fInfo, result->fPixels, result->fCTable);
-    return result->fPixels != NULL;
+    if (result->fPixels) {
+        validate_pixels_ctable(fInfo, result->fCTable);
+        return true;
+    }
+    return false;
 }
 
 bool SkPixelRef::lockPixelsAreWritable() const {
     return this->onLockPixelsAreWritable();
 }
 
 bool SkPixelRef::onLockPixelsAreWritable() const {
     return true;
 }
 
@@ skipping 95 matching lines @@
     }
 
     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->fSize.set(fInfo.width(), fInfo.height());
     return true;
 }