Keeping asserts in release.

src/image/SkImage_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <cstddef>
 #include <cstring>
 #include <type_traits>
@@ skipping 565 matching lines @@
     FILL_MEMBER(dtiBufferFiller, fWidth, &width);
     int height = info.height();
     FILL_MEMBER(dtiBufferFiller, fHeight, &height);
     SkColorType colorType = info.colorType();
     FILL_MEMBER(dtiBufferFiller, fColorType, &colorType);
     SkAlphaType alphaType = info.alphaType();
     FILL_MEMBER(dtiBufferFiller, fAlphaType, &alphaType);
     FILL_MEMBER(dtiBufferFiller, fColorTableCnt, &ctCount);
     FILL_MEMBER(dtiBufferFiller, fColorTableData, &ct);
     FILL_MEMBER(dtiBufferFiller, fMipMapLevelCount, &mipMapLevelCount);
-//    FILL_MEMBER(dtiBufferFiller, fMipMapLevelCount[0].fPixelData, &pixels);
     memcpy(reinterpret_cast<void*>(bufferAsInt +
                                   offsetof(DeferredTextureImage, fMipMapLevelData[0].fPixelData)),
            &pixels, sizeof(pixels));
     memcpy(reinterpret_cast<void*>(bufferAsInt +
                                   offsetof(DeferredTextureImage, fMipMapLevelData[0].fRowBytes)),
            &rowBytes, sizeof(rowBytes));
     if (colorSpaceSize) {
         void* colorSpace = reinterpret_cast<void*>(bufferAsInt + colorSpaceOffset);
         FILL_MEMBER(dtiBufferFiller, fColorSpace, &colorSpace);
         FILL_MEMBER(dtiBufferFiller, fColorSpaceSize, &colorSpaceSize);
         info.colorSpace()->writeToMemory(reinterpret_cast<void*>(bufferAsInt + colorSpaceOffset));
     } else {
         memset(reinterpret_cast<void*>(bufferAsInt +
                                        offsetof(DeferredTextureImage, fColorSpace)),
                0, sizeof(DeferredTextureImage::fColorSpace));
         memset(reinterpret_cast<void*>(bufferAsInt +
                                        offsetof(DeferredTextureImage, fColorSpaceSize)),
                0, sizeof(DeferredTextureImage::fColorSpaceSize));
     }
 
     // Fill in the mipmap levels if they exist
-    intptr_t mipLevelPtr = bufferAsInt + pixelOffset + SkAlign8(pixmap.getSafeSize());
+    intptr_t mipLevelPtr = pixelsAsInt + SkAlign8(pixmap.getSafeSize());
 
     if (useMipMaps) {
-        // offsetof, which we use below, requires the type have standard layout
-        SkASSERT(std::is_standard_layout<MipMapLevelData>::value);
+        static_assert(std::is_standard_layout<MipMapLevelData>::value,
+                      "offsetof, which we use below, requires the type have a standard layout");
 
         SkAutoTDelete<SkMipMap> mipmaps(SkMipMap::Build(pixmap, gammaTreatment, nullptr));
         // SkMipMap holds only the mipmap levels it generates.
         // A programmer can use the data they provided to SkMipMap::Build as level 0.
         // So the SkMipMap provides levels 1-x but it stores them in its own
         // range 0-(x-1).
         for (int generatedMipLevelIndex = 0; generatedMipLevelIndex < mipMapLevelCount - 1;
              generatedMipLevelIndex++) {
             SkISize mipSize = SkMipMap::ComputeLevelSize(scaledSize.width(), scaledSize.height(),
                                                          generatedMipLevelIndex);
 
             SkImageInfo mipInfo = SkImageInfo::MakeN32(mipSize.fWidth, mipSize.fHeight, at);
             SkMipMap::Level mipLevel;
             mipmaps->getLevel(generatedMipLevelIndex, &mipLevel);
 
             // Make sure the mipmap data is after the start of the buffer
-            SkASSERT(mipLevelPtr > bufferAsInt);
+            SkASSERT_RELEASE(mipLevelPtr > bufferAsInt);
             // Make sure the mipmap data starts before the end of the buffer
-            SkASSERT(static_cast<size_t>(mipLevelPtr) < bufferAsInt + pixelOffset + pixelSize);
+            SkASSERT_RELEASE(static_cast<size_t>(mipLevelPtr) < bufferAsInt + pixelOffset + pixelSize);
             // Make sure the mipmap data ends before the end of the buffer
-            SkASSERT(mipLevelPtr + mipLevel.fPixmap.getSafeSize() <=
+            SkASSERT_RELEASE(mipLevelPtr + mipLevel.fPixmap.getSafeSize() <=
                      bufferAsInt + pixelOffset + pixelSize);
 
             // getSafeSize includes rowbyte padding except for the last row,
             // right?
 
             memcpy(reinterpret_cast<void*>(mipLevelPtr), mipLevel.fPixmap.addr(),
                        mipLevel.fPixmap.getSafeSize());
 
             memcpy(reinterpret_cast<void*>(bufferAsInt +
                 offsetof(DeferredTextureImage, fMipMapLevelData) +
@@ skipping 65 matching lines @@
     }
     SkAutoTUnref<GrTexture> texture(GrUploadMipMapToTexture(ctx, info, texels, mipLevelCount));
     if (!texture) {
         return nullptr;
     }
     texture->texturePriv().setGammaTreatment(gammaTreatment);
     return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), kNeedNewImageUniqueID,
                                    info.alphaType(), texture, sk_ref_sp(info.colorSpace()),
                                    budgeted);
 }