Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/graphics

third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/gpu/WebGLImageConversion.h"
 
 #include <memory>
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/cpu/arm/WebGLImageConversionNEON.h"
 #include "platform/graphics/cpu/mips/WebGLImageConversionMSA.h"
@@ skipping 47 matching lines @@
           break;
         case GL_RGB:
         case GL_RGB_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGB8_S;
           break;
         case GL_RGBA:
         case GL_RGBA_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGBA8_S;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_BYTE:
       switch (destinationFormat) {
         case GL_RGB:
         case GL_RGB_INTEGER:
         case GL_SRGB_EXT:
           dstFormat = WebGLImageConversion::DataFormatRGB8;
           break;
         case GL_RGBA:
@@ skipping 10 matching lines @@
           dstFormat = WebGLImageConversion::DataFormatR8;
           break;
         case GL_RG:
         case GL_RG_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRG8;
           break;
         case GL_LUMINANCE_ALPHA:
           dstFormat = WebGLImageConversion::DataFormatRA8;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_SHORT:
       switch (destinationFormat) {
         case GL_RED_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatR16_S;
           break;
         case GL_RG_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRG16_S;
           break;
         case GL_RGB_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGB16_S;
         case GL_RGBA_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGBA16_S;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_SHORT:
       switch (destinationFormat) {
         case GL_RED_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatR16;
           break;
         case GL_DEPTH_COMPONENT:
           dstFormat = WebGLImageConversion::DataFormatD16;
           break;
         case GL_RG_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRG16;
           break;
         case GL_RGB_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGB16;
           break;
         case GL_RGBA_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGBA16;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_INT:
       switch (destinationFormat) {
         case GL_RED_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatR32_S;
           break;
         case GL_RG_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRG32_S;
           break;
         case GL_RGB_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGB32_S;
           break;
         case GL_RGBA_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGBA32_S;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_INT:
       switch (destinationFormat) {
         case GL_RED_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatR32;
           break;
         case GL_DEPTH_COMPONENT:
           dstFormat = WebGLImageConversion::DataFormatD32;
           break;
         case GL_RG_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRG32;
           break;
         case GL_RGB_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGB32;
           break;
         case GL_RGBA_INTEGER:
           dstFormat = WebGLImageConversion::DataFormatRGBA32;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_HALF_FLOAT_OES:  // OES_texture_half_float
     case GL_HALF_FLOAT:
       switch (destinationFormat) {
         case GL_RGBA:
           dstFormat = WebGLImageConversion::DataFormatRGBA16F;
           break;
         case GL_RGB:
           dstFormat = WebGLImageConversion::DataFormatRGB16F;
           break;
         case GL_RG:
           dstFormat = WebGLImageConversion::DataFormatRG16F;
           break;
         case GL_ALPHA:
           dstFormat = WebGLImageConversion::DataFormatA16F;
           break;
         case GL_LUMINANCE:
         case GL_RED:
           dstFormat = WebGLImageConversion::DataFormatR16F;
           break;
         case GL_LUMINANCE_ALPHA:
           dstFormat = WebGLImageConversion::DataFormatRA16F;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_FLOAT:  // OES_texture_float
       switch (destinationFormat) {
         case GL_RGBA:
           dstFormat = WebGLImageConversion::DataFormatRGBA32F;
           break;
         case GL_RGB:
           dstFormat = WebGLImageConversion::DataFormatRGB32F;
           break;
         case GL_RG:
           dstFormat = WebGLImageConversion::DataFormatRG32F;
           break;
         case GL_ALPHA:
           dstFormat = WebGLImageConversion::DataFormatA32F;
           break;
         case GL_LUMINANCE:
         case GL_RED:
           dstFormat = WebGLImageConversion::DataFormatR32F;
           break;
         case GL_DEPTH_COMPONENT:
           dstFormat = WebGLImageConversion::DataFormatD32F;
           break;
         case GL_LUMINANCE_ALPHA:
           dstFormat = WebGLImageConversion::DataFormatRA32F;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_SHORT_4_4_4_4:
       dstFormat = WebGLImageConversion::DataFormatRGBA4444;
       break;
     case GL_UNSIGNED_SHORT_5_5_5_1:
       dstFormat = WebGLImageConversion::DataFormatRGBA5551;
       break;
     case GL_UNSIGNED_SHORT_5_6_5:
       dstFormat = WebGLImageConversion::DataFormatRGB565;
       break;
     case GL_UNSIGNED_INT_5_9_9_9_REV:
       dstFormat = WebGLImageConversion::DataFormatRGB5999;
       break;
     case GL_UNSIGNED_INT_24_8:
       dstFormat = WebGLImageConversion::DataFormatDS24_8;
       break;
     case GL_UNSIGNED_INT_10F_11F_11F_REV:
       dstFormat = WebGLImageConversion::DataFormatRGB10F11F11F;
       break;
     case GL_UNSIGNED_INT_2_10_10_10_REV:
       dstFormat = WebGLImageConversion::DataFormatRGBA2_10_10_10;
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
   return dstFormat;
 }
 
 // The following Float to Half-Float conversion code is from the implementation
 // of ftp://www.fox-toolkit.org/pub/fasthalffloatconversion.pdf, "Fast Half
 // Float Conversions" by Jeroen van der Zijp, November 2008 (Revised September
 // 2010). Specially, the basetable[512] and shifttable[512] are generated as
 // follows:
 /*
@@ skipping 128 matching lines @@
 // The following packing and unpacking routines are expressed in terms of
 // function templates and inline functions to achieve generality and speedup.
 // Explicit template specializations correspond to the cases that would occur.
 // Some code are merged back from Mozilla code in
 // http://mxr.mozilla.org/mozilla-central/source/content/canvas/src/WebGLTexelConversions.h
 
 //----------------------------------------------------------------------
 // Pixel unpacking routines.
 template <int format, typename SourceType, typename DstType>
 void unpack(const SourceType*, DstType*, unsigned) {
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
 }
 
 template <>
 void unpack<WebGLImageConversion::DataFormatARGB8, uint8_t, uint8_t>(
     const uint8_t* source,
     uint8_t* destination,
     unsigned pixelsPerRow) {
   for (unsigned i = 0; i < pixelsPerRow; ++i) {
     destination[0] = source[1];
     destination[1] = source[2];
@@ skipping 234 matching lines @@
     destination += 4;
   }
 }
 
 //----------------------------------------------------------------------
 // Pixel packing routines.
 //
 
 template <int format, int alphaOp, typename SourceType, typename DstType>
 void pack(const SourceType*, DstType*, unsigned) {
-  ASSERT_NOT_REACHED();
+  NOTREACHED();
 }
 
 template <>
 void pack<WebGLImageConversion::DataFormatA8,
           WebGLImageConversion::AlphaDoNothing,
           uint8_t,
           uint8_t>(const uint8_t* source,
                    uint8_t* destination,
                    unsigned pixelsPerRow) {
   for (unsigned i = 0; i < pixelsPerRow; ++i) {
@@ skipping 1578 matching lines @@
         m_dstStart(dstStart),
         m_srcStride(srcStride),
         m_srcRowOffset(srcRowOffset),
         m_dstStride(dstStride),
         m_success(false) {
     const unsigned MaxNumberOfComponents = 4;
     const unsigned MaxBytesPerComponent = 4;
     m_unpackedIntermediateSrcData = wrapArrayUnique(
         new uint8_t[m_srcSubRectangle.width() * MaxNumberOfComponents *
                     MaxBytesPerComponent]);
-    ASSERT(m_unpackedIntermediateSrcData.get());
+    DCHECK(m_unpackedIntermediateSrcData.get());
   }
 
   void convert(WebGLImageConversion::DataFormat srcFormat,
                WebGLImageConversion::DataFormat dstFormat,
                WebGLImageConversion::AlphaOp);
   bool Success() const { return m_success; }
 
  private:
   template <WebGLImageConversion::DataFormat SrcFormat>
   void convert(WebGLImageConversion::DataFormat dstFormat,
@@ skipping 32 matching lines @@
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatARGB8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatABGR8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatAR8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatBGRA8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA5551)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA4444)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::DataFormatRGBA32F)
     FORMATCONVERTER_CASE_SRCFORMAT(
         WebGLImageConversion::DataFormatRGBA2_10_10_10)
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 #undef FORMATCONVERTER_CASE_SRCFORMAT
 }
 
 template <WebGLImageConversion::DataFormat SrcFormat>
 void FormatConverter::convert(WebGLImageConversion::DataFormat dstFormat,
                               WebGLImageConversion::AlphaOp alphaOp) {
 #define FORMATCONVERTER_CASE_DSTFORMAT(DstFormat) \
   case DstFormat:                                 \
     return convert<SrcFormat, DstFormat>(alphaOp);
@@ skipping 21 matching lines @@
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA16)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA16_S)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA32)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRGBA32_S)
     FORMATCONVERTER_CASE_DSTFORMAT(
         WebGLImageConversion::DataFormatRGBA2_10_10_10)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRG8)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRG16F)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::DataFormatRG32F)
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 
 #undef FORMATCONVERTER_CASE_DSTFORMAT
 }
 
 template <WebGLImageConversion::DataFormat SrcFormat,
           WebGLImageConversion::DataFormat DstFormat>
 void FormatConverter::convert(WebGLImageConversion::AlphaOp alphaOp) {
 #define FORMATCONVERTER_CASE_ALPHAOP(alphaOp) \
   case alphaOp:                               \
     return convert<SrcFormat, DstFormat, alphaOp>();
 
   switch (alphaOp) {
     FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::AlphaDoNothing)
     FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::AlphaDoPremultiply)
     FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::AlphaDoUnmultiply)
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 #undef FORMATCONVERTER_CASE_ALPHAOP
 }
 
 template <int Format>
 struct SupportsConversionFromDomElements {
   STATIC_ONLY(SupportsConversionFromDomElements);
   static const bool value =
       Format == WebGLImageConversion::DataFormatRGBA8 ||
       Format == WebGLImageConversion::DataFormatRGB8 ||
@@ skipping 16 matching lines @@
 };
 
 template <WebGLImageConversion::DataFormat SrcFormat,
           WebGLImageConversion::DataFormat DstFormat,
           WebGLImageConversion::AlphaOp alphaOp>
 void FormatConverter::convert() {
   // Many instantiations of this template function will never be entered, so we
   // try to return immediately in these cases to avoid generating useless code.
   if (SrcFormat == DstFormat &&
       alphaOp == WebGLImageConversion::AlphaDoNothing) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   if (!IsFloatFormat<DstFormat>::value && IsFloatFormat<SrcFormat>::value) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
 
   // Only textures uploaded from DOM elements or ImageData can allow DstFormat
   // != SrcFormat.
   const bool srcFormatComesFromDOMElementOrImageData =
       WebGLImageConversion::srcFormatComeFromDOMElementOrImageData(SrcFormat);
   if (!srcFormatComesFromDOMElementOrImageData && SrcFormat != DstFormat) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   // Likewise, only textures uploaded from DOM elements or ImageData can
   // possibly need to be unpremultiplied.
   if (!srcFormatComesFromDOMElementOrImageData &&
       alphaOp == WebGLImageConversion::AlphaDoUnmultiply) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   if (srcFormatComesFromDOMElementOrImageData &&
       alphaOp == WebGLImageConversion::AlphaDoUnmultiply &&
       !SupportsConversionFromDomElements<DstFormat>::value) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   if ((!HasAlpha(SrcFormat) || !HasColor(SrcFormat) || !HasColor(DstFormat)) &&
       alphaOp != WebGLImageConversion::AlphaDoNothing) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   // If converting DOM element data to UNSIGNED_INT_5_9_9_9_REV or
   // UNSIGNED_INT_10F_11F_11F_REV, we should always switch to FLOAT instead to
   // avoid unpacking/packing these two types.
   if (srcFormatComesFromDOMElementOrImageData && SrcFormat != DstFormat &&
       (DstFormat == WebGLImageConversion::DataFormatRGB5999 ||
        DstFormat == WebGLImageConversion::DataFormatRGB10F11F11F)) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
 
   typedef typename DataTypeForFormat<SrcFormat>::Type SrcType;
   typedef typename DataTypeForFormat<DstFormat>::Type DstType;
   const int IntermFormat = IntermediateFormat<DstFormat>::value;
   typedef typename DataTypeForFormat<IntermFormat>::Type IntermType;
   const ptrdiff_t srcStrideInElements = m_srcStride / sizeof(SrcType);
   const ptrdiff_t dstStrideInElements = m_dstStride / sizeof(DstType);
   const bool trivialUnpack = SrcFormat == IntermFormat;
   const bool trivialPack = DstFormat == IntermFormat &&
                            alphaOp == WebGLImageConversion::AlphaDoNothing;
-  ASSERT(!trivialUnpack || !trivialPack);
+  DCHECK(!trivialUnpack || !trivialPack);
 
   const SrcType* srcRowStart =
       static_cast<const SrcType*>(static_cast<const void*>(
           static_cast<const uint8_t*>(m_srcStart) +
           ((m_srcStride * m_srcSubRectangle.y()) + m_srcRowOffset)));
 
   // If packing multiple images into a 3D texture, and flipY is true,
   // then the sub-rectangle is pointing at the start of the
   // "bottommost" of those images. Since the source pointer strides in
   // the positive direction, we need to back it up to point at the
@@ skipping 140 matching lines @@
 GLenum WebGLImageConversion::computeImageSizeInBytes(
     GLenum format,
     GLenum type,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     const PixelStoreParams& params,
     unsigned* imageSizeInBytes,
     unsigned* paddingInBytes,
     unsigned* skipSizeInBytes) {
-  ASSERT(imageSizeInBytes);
-  ASSERT(params.alignment == 1 || params.alignment == 2 ||
+  DCHECK(imageSizeInBytes);
+  DCHECK(params.alignment == 1 || params.alignment == 2 ||
          params.alignment == 4 || params.alignment == 8);
-  ASSERT(params.rowLength >= 0 && params.imageHeight >= 0);
-  ASSERT(params.skipPixels >= 0 && params.skipRows >= 0 &&
+  DCHECK(params.rowLength >= 0 && params.imageHeight >= 0);

[tkent, 2017/04/09 23:17:27]

Split this into two DCHECKs.

[Hwanseung Lee, 2017/04/11 22:24:10]

Done.

+  DCHECK(params.skipPixels >= 0 && params.skipRows >= 0 &&

[tkent, 2017/04/09 23:17:27]

Split this into three DCHECKs.

[Hwanseung Lee, 2017/04/11 22:24:10]

Done.

          params.skipImages >= 0);
   if (width < 0 || height < 0 || depth < 0)
     return GL_INVALID_VALUE;
   if (!width || !height || !depth) {
     *imageSizeInBytes = 0;
     if (paddingInBytes)
       *paddingInBytes = 0;
     if (skipSizeInBytes)
       *skipSizeInBytes = 0;
     return GL_NO_ERROR;
@@ skipping 91 matching lines @@
     ImageHtmlDomSource imageHtmlDomSource,
     bool premultiplyAlpha,
     bool ignoreColorSpace) {
   m_image = image;
   m_imageHtmlDomSource = imageHtmlDomSource;
   extractImage(premultiplyAlpha, ignoreColorSpace);
 }
 
 void WebGLImageConversion::ImageExtractor::extractImage(bool premultiplyAlpha,
                                                         bool ignoreColorSpace) {
-  ASSERT(!m_imagePixelLocker);
+  DCHECK(!m_imagePixelLocker);
 
   if (!m_image)
     return;
 
   sk_sp<SkImage> skiaImage = m_image->imageForCurrentFrame();
   SkImageInfo info = skiaImage ? SkImageInfo::MakeN32Premul(m_image->width(),
                                                             m_image->height())
                                : SkImageInfo::MakeUnknown();
   m_alphaOp = AlphaDoNothing;
   bool hasAlpha = skiaImage ? !skiaImage->isOpaque() : true;
@@ skipping 35 matching lines @@
       m_alphaOp = AlphaDoUnmultiply;
   }
 
   if (!skiaImage)
     return;
 
   m_imageSourceFormat = SK_B32_SHIFT ? DataFormatRGBA8 : DataFormatBGRA8;
   m_imageSourceUnpackAlignment =
       0;  // FIXME: this seems to always be zero - why use at all?
 
-  ASSERT(skiaImage->width() && skiaImage->height());
+  DCHECK(skiaImage->width() && skiaImage->height());

[tkent, 2017/04/09 23:17:27]

Split this into two DCHECKs.

[Hwanseung Lee, 2017/04/11 22:24:10]

Done.

   m_imageWidth = skiaImage->width();
   m_imageHeight = skiaImage->height();
 
   // Fail if the image was downsampled because of memory limits.
   if (m_imageWidth != (unsigned)m_image->width() ||
       m_imageHeight != (unsigned)m_image->height())
     return;
 
   m_imagePixelLocker.emplace(std::move(skiaImage), info.alphaType(),
                              kN32_SkColorType);
@@ skipping 364 matching lines @@
       pack<WebGLImageConversion::DataFormatRGB565,
            WebGLImageConversion::AlphaDoNothing>(srcRowStart, dstRowStart,
                                                  pixelsPerRow);
     } break;
     default:
       break;
   }
 }
 
 }  // namespace blink