Style Change: NULL->nullptr

src/core/SkBitmap.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAtomics.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 38 matching lines @@
         memcpy(this, &src, sizeof(src));
 
         // inc src reference counts
         SkSafeRef(src.fPixelRef);
 
         // we reset our locks if we get blown away
         fPixelLockCount = 0;
 
         if (fPixelRef) {
             // ignore the values from the memcpy
-            fPixels = NULL;
-            fColorTable = NULL;
+            fPixels = nullptr;
+            fColorTable = nullptr;
             // Note that what to for genID is somewhat arbitrary. We have no
             // way to track changes to raw pixels across multiple SkBitmaps.
             // Would benefit from an SkRawPixelRef type created by
             // setPixels.
             // Just leave the memcpy'ed one but they'll get out of sync
             // as soon either is modified.
         }
     }
 
     SkDEBUGCODE(this->validate();)
@@ skipping 87 matching lines @@
             void* p = fPixelRef->pixels();
             if (p) {
                 p = (char*)p
                     + fPixelRefOrigin.fY * fRowBytes
                     + fPixelRefOrigin.fX * fInfo.bytesPerPixel();
             }
             fPixels = p;
             fColorTable = fPixelRef->colorTable();
         } else {
             SkASSERT(0 == fPixelLockCount);
-            fPixels = NULL;
-            fColorTable = NULL;
+            fPixels = nullptr;
+            fColorTable = nullptr;
         }
     }
 }
 
 SkPixelRef* SkBitmap::setPixelRef(SkPixelRef* pr, int dx, int dy) {
 #ifdef SK_DEBUG
     if (pr) {
         if (kUnknown_SkColorType != fInfo.colorType()) {
             const SkImageInfo& prInfo = pr->info();
             SkASSERT(fInfo.width() <= prInfo.width());
@@ skipping 20 matching lines @@
     if (pr) {
         const SkImageInfo& info = pr->info();
         fPixelRefOrigin.set(SkPin32(dx, 0, info.width()), SkPin32(dy, 0, info.height()));
     } else {
         // ignore dx,dy if there is no pixelref
         fPixelRefOrigin.setZero();
     }
 
     if (fPixelRef != pr) {
         this->freePixels();
-        SkASSERT(NULL == fPixelRef);
+        SkASSERT(nullptr == fPixelRef);
 
         SkSafeRef(pr);
         fPixelRef = pr;
         this->updatePixelsFromRef();
     }
 
     SkDEBUGCODE(this->validate();)
     return pr;
 }
 
 void SkBitmap::lockPixels() const {
     if (fPixelRef && 0 == sk_atomic_inc(&fPixelLockCount)) {
         fPixelRef->lockPixels();
         this->updatePixelsFromRef();
     }
     SkDEBUGCODE(this->validate();)
 }
 
 void SkBitmap::unlockPixels() const {
-    SkASSERT(NULL == fPixelRef || fPixelLockCount > 0);
+    SkASSERT(nullptr == fPixelRef || fPixelLockCount > 0);
 
     if (fPixelRef && 1 == sk_atomic_dec(&fPixelLockCount)) {
         fPixelRef->unlockPixels();
         this->updatePixelsFromRef();
     }
     SkDEBUGCODE(this->validate();)
 }
 
 bool SkBitmap::lockPixelsAreWritable() const {
     return (fPixelRef) ? fPixelRef->lockPixelsAreWritable() : false;
 }
 
 void SkBitmap::setPixels(void* p, SkColorTable* ctable) {
-    if (NULL == p) {
-        this->setPixelRef(NULL);
+    if (nullptr == p) {
+        this->setPixelRef(nullptr);
         return;
     }
 
     if (kUnknown_SkColorType == fInfo.colorType()) {
-        this->setPixelRef(NULL);
+        this->setPixelRef(nullptr);
         return;
     }
 
     SkPixelRef* pr = SkMallocPixelRef::NewDirect(fInfo, p, fRowBytes, ctable);
-    if (NULL == pr) {
-        this->setPixelRef(NULL);
+    if (nullptr == pr) {
+        this->setPixelRef(nullptr);
         return;
     }
 
     this->setPixelRef(pr)->unref();
 
     // since we're already allocated, we lockPixels right away
     this->lockPixels();
     SkDEBUGCODE(this->validate();)
 }
 
 bool SkBitmap::tryAllocPixels(Allocator* allocator, SkColorTable* ctable) {
     HeapAllocator stdalloc;
 
-    if (NULL == allocator) {
+    if (nullptr == allocator) {
         allocator = &stdalloc;
     }
     return allocator->allocPixelRef(this, ctable);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, size_t rowBytes) {
     if (kIndex_8_SkColorType == requestedInfo.colorType()) {
         return reset_return_false(this);
     }
     if (!this->setInfo(requestedInfo, rowBytes)) {
         return reset_return_false(this);
     }
 
     // setInfo may have corrected info (e.g. 565 is always opaque).
     const SkImageInfo& correctedInfo = this->info();
     // setInfo may have computed a valid rowbytes if 0 were passed in
     rowBytes = this->rowBytes();
 
     SkMallocPixelRef::PRFactory defaultFactory;
 
-    SkPixelRef* pr = defaultFactory.create(correctedInfo, rowBytes, NULL);
-    if (NULL == pr) {
+    SkPixelRef* pr = defaultFactory.create(correctedInfo, rowBytes, nullptr);
+    if (nullptr == pr) {
         return reset_return_false(this);
     }
     this->setPixelRef(pr)->unref();
 
-    // TODO: lockPixels could/should return bool or void*/NULL
+    // TODO: lockPixels could/should return bool or void*/nullptr
     this->lockPixels();
-    if (NULL == this->getPixels()) {
+    if (nullptr == this->getPixels()) {
         return reset_return_false(this);
     }
     return true;
 }
 
 bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, SkPixelRefFactory* factory,
                                 SkColorTable* ctable) {
-    if (kIndex_8_SkColorType == requestedInfo.colorType() && NULL == ctable) {
+    if (kIndex_8_SkColorType == requestedInfo.colorType() && nullptr == ctable) {
         return reset_return_false(this);
     }
     if (!this->setInfo(requestedInfo)) {
         return reset_return_false(this);
     }
 
     // setInfo may have corrected info (e.g. 565 is always opaque).
     const SkImageInfo& correctedInfo = this->info();
 
     SkMallocPixelRef::PRFactory defaultFactory;
-    if (NULL == factory) {
+    if (nullptr == factory) {
         factory = &defaultFactory;
     }
 
     SkPixelRef* pr = factory->create(correctedInfo, correctedInfo.minRowBytes(), ctable);
-    if (NULL == pr) {
+    if (nullptr == pr) {
         return reset_return_false(this);
     }
     this->setPixelRef(pr)->unref();
 
-    // TODO: lockPixels could/should return bool or void*/NULL
+    // TODO: lockPixels could/should return bool or void*/nullptr
     this->lockPixels();
-    if (NULL == this->getPixels()) {
+    if (nullptr == this->getPixels()) {
         return reset_return_false(this);
     }
     return true;
 }
 
 static void invoke_release_proc(void (*proc)(void* pixels, void* ctx), void* pixels, void* ctx) {
     if (proc) {
         proc(pixels, ctx);
     }
 }
 
 bool SkBitmap::installPixels(const SkImageInfo& requestedInfo, void* pixels, size_t rb,
                              SkColorTable* ct, void (*releaseProc)(void* addr, void* context),
                              void* context) {
     if (!this->setInfo(requestedInfo, rb)) {
         invoke_release_proc(releaseProc, pixels, context);
         this->reset();
         return false;
     }
-    if (NULL == pixels) {
+    if (nullptr == pixels) {
         invoke_release_proc(releaseProc, pixels, context);
         return true;    // we behaved as if they called setInfo()
     }
 
     // setInfo may have corrected info (e.g. 565 is always opaque).
     const SkImageInfo& correctedInfo = this->info();
 
     SkPixelRef* pr = SkMallocPixelRef::NewWithProc(correctedInfo, rb, ct, pixels, releaseProc,
                                                    context);
     if (!pr) {
@@ skipping 20 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkBitmap::freePixels() {
     if (fPixelRef) {
         if (fPixelLockCount > 0) {
             fPixelRef->unlockPixels();
         }
         fPixelRef->unref();
-        fPixelRef = NULL;
+        fPixelRef = nullptr;
         fPixelRefOrigin.setZero();
     }
     fPixelLockCount = 0;
-    fPixels = NULL;
-    fColorTable = NULL;
+    fPixels = nullptr;
+    fColorTable = nullptr;
 }
 
 uint32_t SkBitmap::getGenerationID() const {
     return (fPixelRef) ? fPixelRef->getGenerationID() : 0;
 }
 
 void SkBitmap::notifyPixelsChanged() const {
     SkASSERT(!this->isImmutable());
     if (fPixelRef) {
         fPixelRef->notifyPixelsChanged();
     }
 }
 
 GrTexture* SkBitmap::getTexture() const {
-    return fPixelRef ? fPixelRef->getTexture() : NULL;
+    return fPixelRef ? fPixelRef->getTexture() : nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /** We explicitly use the same allocator for our pixels that SkMask does,
  so that we can freely assign memory allocated by one class to the other.
  */
 bool SkBitmap::HeapAllocator::allocPixelRef(SkBitmap* dst,
                                             SkColorTable* ctable) {
     const SkImageInfo info = dst->info();
     if (kUnknown_SkColorType == info.colorType()) {
 //        SkDebugf("unsupported config for info %d\n", dst->config());
         return false;
     }
 
     SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, dst->rowBytes(), ctable);
-    if (NULL == pr) {
+    if (nullptr == pr) {
         return false;
     }
 
     dst->setPixelRef(pr)->unref();
     // since we're already allocated, we lockPixels right away
     dst->lockPixels();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 34 matching lines @@
                 srcP += src.rowBytes();
                 dstP += dstRowBytes;
             }
 
             return true;
         }
     }
 }
 
 bool SkBitmap::copyPixelsTo(void* dst, size_t dstSize, size_t dstRB, bool preserveDstPad) const {
-    if (NULL == dst) {
+    if (nullptr == dst) {
         return false;
     }
     SkAutoPixmapUnlock result;
     if (!this->requestLock(&result)) {
         return false;
     }
     return copy_pixels_to(result.pixmap(), dst, dstSize, dstRB, preserveDstPad);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 36 matching lines @@
             case kRGB_565_SkColorType:
                 base += x << 1;
                 break;
             case kAlpha_8_SkColorType:
             case kIndex_8_SkColorType:
             case kGray_8_SkColorType:
                 base += x;
                 break;
             default:
                 SkDEBUGFAIL("Can't return addr for config");
-                base = NULL;
+                base = nullptr;
                 break;
         }
     }
     return base;
 }
 
 SkColor SkBitmap::getColor(int x, int y) const {
     SkASSERT((unsigned)x < (unsigned)this->width());
     SkASSERT((unsigned)y < (unsigned)this->height());
 
@@ skipping 45 matching lines @@
                     a &= row[x];
                 }
                 if (0xFF != a) {
                     return false;
                 }
             }
             return true;
         } break;
         case kIndex_8_SkColorType: {
             const SkColorTable* ctable = pmap.ctable();
-            if (NULL == ctable) {
+            if (nullptr == ctable) {
                 return false;
             }
             const SkPMColor* table = ctable->readColors();
             SkPMColor c = (SkPMColor)~0;
             for (int i = ctable->count() - 1; i >= 0; --i) {
                 c &= table[i];
             }
             return 0xFF == SkGetPackedA32(c);
         } break;
         case kRGB_565_SkColorType:
@@ skipping 70 matching lines @@
 void SkBitmap::eraseColor(SkColor c) const {
     this->erase(c, SkIRect::MakeWH(this->width(), this->height()));
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////
 
 bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
     SkDEBUGCODE(this->validate();)
 
-    if (NULL == result || NULL == fPixelRef) {
+    if (nullptr == result || nullptr == fPixelRef) {
         return false;   // no src pixels
     }
 
     SkIRect srcRect, r;
     srcRect.set(0, 0, this->width(), this->height());
     if (!r.intersect(srcRect, subset)) {
         return false;   // r is empty (i.e. no intersection)
     }
 
-    if (fPixelRef->getTexture() != NULL) {
+    if (fPixelRef->getTexture() != nullptr) {
         // Do a deep copy
         SkPixelRef* pixelRef = fPixelRef->deepCopy(this->colorType(), this->profileType(), &subset);
-        if (pixelRef != NULL) {
+        if (pixelRef != nullptr) {
             SkBitmap dst;
             dst.setInfo(SkImageInfo::Make(subset.width(), subset.height(),
                                           this->colorType(), this->alphaType()));
             dst.setIsVolatile(this->isVolatile());
             dst.setPixelRef(pixelRef)->unref();
             SkDEBUGCODE(dst.validate());
             result->swap(dst);
             return true;
         }
     }
@@ skipping 86 matching lines @@
         if (fPixelRef->readPixels(&tmpSrc, &subset)) {
             if (fPixelRef->info().alphaType() == kUnpremul_SkAlphaType) {
                 // FIXME: The only meaningful implementation of readPixels
                 // (GrPixelRef) assumes premultiplied pixels.
                 return false;
             }
             SkASSERT(tmpSrc.width() == this->width());
             SkASSERT(tmpSrc.height() == this->height());
 
             // did we get lucky and we can just return tmpSrc?
-            if (tmpSrc.colorType() == dstColorType && NULL == alloc) {
+            if (tmpSrc.colorType() == dstColorType && nullptr == alloc) {
                 dst->swap(tmpSrc);
                 // If the result is an exact copy, clone the gen ID.
                 if (dst->pixelRef() && dst->pixelRef()->info() == fPixelRef->info()) {
                     dst->pixelRef()->cloneGenID(*fPixelRef);
                 }
                 return true;
             }
 
             // fall through to the raster case
             src = &tmpSrc;
@@ skipping 51 matching lines @@
     const SkColorType dstCT = this->colorType();
     const SkColorProfileType dstPT = this->profileType();
 
     if (!this->canCopyTo(dstCT)) {
         return false;
     }
 
     // If we have a PixelRef, and it supports deep copy, use it.
     // Currently supported only by texture-backed bitmaps.
     if (fPixelRef) {
-        SkPixelRef* pixelRef = fPixelRef->deepCopy(dstCT, dstPT, NULL);
+        SkPixelRef* pixelRef = fPixelRef->deepCopy(dstCT, dstPT, nullptr);
         if (pixelRef) {
             uint32_t rowBytes;
             if (this->colorType() == dstCT && this->profileType() == dstPT) {
                 // Since there is no subset to pass to deepCopy, and deepCopy
                 // succeeded, the new pixel ref must be identical.
                 SkASSERT(fPixelRef->info() == pixelRef->info());
                 pixelRef->cloneGenID(*fPixelRef);
                 // Use the same rowBytes as the original.
                 rowBytes = fRowBytes;
             } else {
                 // With the new config, an appropriate fRowBytes will be computed by setInfo.
                 rowBytes = 0;
             }
 
             const SkImageInfo info = fInfo.makeColorType(dstCT);
             if (!dst->setInfo(info, rowBytes)) {
                 return false;
             }
             dst->setPixelRef(pixelRef, fPixelRefOrigin)->unref();
             return true;
         }
     }
 
     if (this->getTexture()) {
         return false;
     } else {
-        return this->copyTo(dst, dstCT, NULL);
+        return this->copyTo(dst, dstCT, nullptr);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void rect_memset(uint8_t* array, U8CPU value, SkISize size, size_t rowBytes) {
     for (int y = 0; y < size.height(); ++y) {
         memset(array, value, size.width());
         array += rowBytes;
     }
@@ skipping 42 matching lines @@
                 s += rb;
                 alpha += alphaRowBytes;
             }
         }
     } else {    // src is opaque, so just fill alpha[] with 0xFF
         rect_memset(alpha, 0xFF, pmap.info().dimensions(), alphaRowBytes);
     }
 }
 
 static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha, int alphaRowBytes) {
-    SkASSERT(alpha != NULL);
+    SkASSERT(alpha != nullptr);
     SkASSERT(alphaRowBytes >= src.width());
 
     SkAutoPixmapUnlock apl;
     if (!src.requestLock(&apl)) {
         rect_memset(alpha, 0, src.info().dimensions(), alphaRowBytes);
         return false;
     }
     get_bitmap_alpha(apl.pixmap(), alpha, alphaRowBytes);
     return true;
 }
 
 #include "SkPaint.h"
 #include "SkMaskFilter.h"
 #include "SkMatrix.h"
 
 bool SkBitmap::extractAlpha(SkBitmap* dst, const SkPaint* paint,
                             Allocator *allocator, SkIPoint* offset) const {
     SkDEBUGCODE(this->validate();)
 
     SkBitmap    tmpBitmap;
     SkMatrix    identity;
     SkMask      srcM, dstM;
 
     srcM.fBounds.set(0, 0, this->width(), this->height());
     srcM.fRowBytes = SkAlign4(this->width());
     srcM.fFormat = SkMask::kA8_Format;
 
-    SkMaskFilter* filter = paint ? paint->getMaskFilter() : NULL;
+    SkMaskFilter* filter = paint ? paint->getMaskFilter() : nullptr;
 
     // compute our (larger?) dst bounds if we have a filter
     if (filter) {
         identity.reset();
-        srcM.fImage = NULL;
-        if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
+        srcM.fImage = nullptr;
+        if (!filter->filterMask(&dstM, srcM, identity, nullptr)) {
             goto NO_FILTER_CASE;
         }
         dstM.fRowBytes = SkAlign4(dstM.fBounds.width());
     } else {
     NO_FILTER_CASE:
         tmpBitmap.setInfo(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
-        if (!tmpBitmap.tryAllocPixels(allocator, NULL)) {
+        if (!tmpBitmap.tryAllocPixels(allocator, nullptr)) {
             // Allocation of pixels for alpha bitmap failed.
             SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                     tmpBitmap.width(), tmpBitmap.height());
             return false;
         }
         GetBitmapAlpha(*this, tmpBitmap.getAddr8(0, 0), srcM.fRowBytes);
         if (offset) {
             offset->set(0, 0);
         }
         tmpBitmap.swap(*dst);
         return true;
     }
     srcM.fImage = SkMask::AllocImage(srcM.computeImageSize());
     SkAutoMaskFreeImage srcCleanup(srcM.fImage);
 
     GetBitmapAlpha(*this, srcM.fImage, srcM.fRowBytes);
-    if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
+    if (!filter->filterMask(&dstM, srcM, identity, nullptr)) {
         goto NO_FILTER_CASE;
     }
     SkAutoMaskFreeImage dstCleanup(dstM.fImage);
 
     tmpBitmap.setInfo(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
                       dstM.fRowBytes);
-    if (!tmpBitmap.tryAllocPixels(allocator, NULL)) {
+    if (!tmpBitmap.tryAllocPixels(allocator, nullptr)) {
         // Allocation of pixels for alpha bitmap failed.
         SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                 tmpBitmap.width(), tmpBitmap.height());
         return false;
     }
     memcpy(tmpBitmap.getPixels(), dstM.fImage, dstM.computeImageSize());
     if (offset) {
         offset->set(dstM.fBounds.fLeft, dstM.fBounds.fTop);
     }
     SkDEBUGCODE(tmpBitmap.validate();)
@@ skipping 27 matching lines @@
     if (kIndex_8_SkColorType == info.colorType() && ct) {
         buffer->writeBool(true);
         ct->writeToBuffer(*buffer);
     } else {
         buffer->writeBool(false);
     }
 }
 
 void SkBitmap::WriteRawPixels(SkWriteBuffer* buffer, const SkBitmap& bitmap) {
     const SkImageInfo info = bitmap.info();
-    if (0 == info.width() || 0 == info.height() || NULL == bitmap.pixelRef()) {
+    if (0 == info.width() || 0 == info.height() || nullptr == bitmap.pixelRef()) {
         buffer->writeUInt(0); // instead of snugRB, signaling no pixels
         return;
     }
 
     SkAutoPixmapUnlock result;
     if (!bitmap.requestLock(&result)) {
         buffer->writeUInt(0); // instead of snugRB, signaling no pixels
         return;
     }
 
@@ skipping 98 matching lines @@
         SkASSERT(fPixelRef);
         SkASSERT(fPixelLockCount > 0);
         SkASSERT(fPixelRef->isLocked());
         SkASSERT(fPixelRef->rowBytes() == fRowBytes);
         SkASSERT(fPixelRefOrigin.fX >= 0);
         SkASSERT(fPixelRefOrigin.fY >= 0);
         SkASSERT(fPixelRef->info().width() >= (int)this->width() + fPixelRefOrigin.fX);
         SkASSERT(fPixelRef->info().height() >= (int)this->height() + fPixelRefOrigin.fY);
         SkASSERT(fPixelRef->rowBytes() >= fInfo.minRowBytes());
     } else {
-        SkASSERT(NULL == fColorTable);
+        SkASSERT(nullptr == fColorTable);
     }
 }
 #endif
 
 #ifndef SK_IGNORE_TO_STRING
 #include "SkString.h"
 void SkBitmap::toString(SkString* str) const {
 
     static const char* gColorTypeNames[kLastEnum_SkColorType + 1] = {
         "UNKNOWN", "A8", "565", "4444", "RGBA", "BGRA", "INDEX8",
     };
 
     str->appendf("bitmap: ((%d, %d) %s", this->width(), this->height(),
                  gColorTypeNames[this->colorType()]);
 
     str->append(" (");
     if (this->isOpaque()) {
         str->append("opaque");
     } else {
         str->append("transparent");
     }
     if (this->isImmutable()) {
         str->append(", immutable");
     } else {
         str->append(", not-immutable");
     }
     str->append(")");
 
     SkPixelRef* pr = this->pixelRef();
-    if (NULL == pr) {
+    if (nullptr == pr) {
         // show null or the explicit pixel address (rare)
         str->appendf(" pixels:%p", this->getPixels());
     } else {
         const char* uri = pr->getURI();
         if (uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkBitmap::requestLock(SkAutoPixmapUnlock* result) const {
     SkASSERT(result);
 
     SkPixelRef* pr = fPixelRef;
-    if (NULL == pr) {
+    if (nullptr == pr) {
         return false;
     }
 
     // We have to lock the whole thing (using the pixelref's dimensions) until the api supports
     // a partial lock (with offset/origin). Hence we can't use our fInfo.
     SkPixelRef::LockRequest req = { pr->info().dimensions(), kNone_SkFilterQuality };
     SkPixelRef::LockResult res;
     if (pr->requestLock(req, &res)) {
         SkASSERT(res.fPixels);
         // The bitmap may be a subset of the pixelref's dimensions
@@ skipping 24 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkImageInfo::validate() const {
     SkASSERT(fWidth >= 0);
     SkASSERT(fHeight >= 0);
     SkASSERT(SkColorTypeIsValid(fColorType));
     SkASSERT(SkAlphaTypeIsValid(fAlphaType));
 }
 #endif