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:
           dst_format = WebGLImageConversion::kDataFormatRGB8_S;
           break;
         case GL_RGBA:
         case GL_RGBA_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGBA8_S;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_BYTE:
       switch (destination_format) {
         case GL_RGB:
         case GL_RGB_INTEGER:
         case GL_SRGB_EXT:
           dst_format = WebGLImageConversion::kDataFormatRGB8;
           break;
         case GL_RGBA:
@@ skipping 10 matching lines @@
           dst_format = WebGLImageConversion::kDataFormatR8;
           break;
         case GL_RG:
         case GL_RG_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRG8;
           break;
         case GL_LUMINANCE_ALPHA:
           dst_format = WebGLImageConversion::kDataFormatRA8;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_SHORT:
       switch (destination_format) {
         case GL_RED_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatR16_S;
           break;
         case GL_RG_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRG16_S;
           break;
         case GL_RGB_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGB16_S;
         case GL_RGBA_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGBA16_S;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_SHORT:
       switch (destination_format) {
         case GL_RED_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatR16;
           break;
         case GL_DEPTH_COMPONENT:
           dst_format = WebGLImageConversion::kDataFormatD16;
           break;
         case GL_RG_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRG16;
           break;
         case GL_RGB_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGB16;
           break;
         case GL_RGBA_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGBA16;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_INT:
       switch (destination_format) {
         case GL_RED_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatR32_S;
           break;
         case GL_RG_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRG32_S;
           break;
         case GL_RGB_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGB32_S;
           break;
         case GL_RGBA_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGBA32_S;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_INT:
       switch (destination_format) {
         case GL_RED_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatR32;
           break;
         case GL_DEPTH_COMPONENT:
           dst_format = WebGLImageConversion::kDataFormatD32;
           break;
         case GL_RG_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRG32;
           break;
         case GL_RGB_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGB32;
           break;
         case GL_RGBA_INTEGER:
           dst_format = WebGLImageConversion::kDataFormatRGBA32;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_HALF_FLOAT_OES:  // OES_texture_half_float
     case GL_HALF_FLOAT:
       switch (destination_format) {
         case GL_RGBA:
           dst_format = WebGLImageConversion::kDataFormatRGBA16F;
           break;
         case GL_RGB:
           dst_format = WebGLImageConversion::kDataFormatRGB16F;
           break;
         case GL_RG:
           dst_format = WebGLImageConversion::kDataFormatRG16F;
           break;
         case GL_ALPHA:
           dst_format = WebGLImageConversion::kDataFormatA16F;
           break;
         case GL_LUMINANCE:
         case GL_RED:
           dst_format = WebGLImageConversion::kDataFormatR16F;
           break;
         case GL_LUMINANCE_ALPHA:
           dst_format = WebGLImageConversion::kDataFormatRA16F;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_FLOAT:  // OES_texture_float
       switch (destination_format) {
         case GL_RGBA:
           dst_format = WebGLImageConversion::kDataFormatRGBA32F;
           break;
         case GL_RGB:
           dst_format = WebGLImageConversion::kDataFormatRGB32F;
           break;
         case GL_RG:
           dst_format = WebGLImageConversion::kDataFormatRG32F;
           break;
         case GL_ALPHA:
           dst_format = WebGLImageConversion::kDataFormatA32F;
           break;
         case GL_LUMINANCE:
         case GL_RED:
           dst_format = WebGLImageConversion::kDataFormatR32F;
           break;
         case GL_DEPTH_COMPONENT:
           dst_format = WebGLImageConversion::kDataFormatD32F;
           break;
         case GL_LUMINANCE_ALPHA:
           dst_format = WebGLImageConversion::kDataFormatRA32F;
           break;
         default:
-          ASSERT_NOT_REACHED();
+          NOTREACHED();
       }
       break;
     case GL_UNSIGNED_SHORT_4_4_4_4:
       dst_format = WebGLImageConversion::kDataFormatRGBA4444;
       break;
     case GL_UNSIGNED_SHORT_5_5_5_1:
       dst_format = WebGLImageConversion::kDataFormatRGBA5551;
       break;
     case GL_UNSIGNED_SHORT_5_6_5:
       dst_format = WebGLImageConversion::kDataFormatRGB565;
       break;
     case GL_UNSIGNED_INT_5_9_9_9_REV:
       dst_format = WebGLImageConversion::kDataFormatRGB5999;
       break;
     case GL_UNSIGNED_INT_24_8:
       dst_format = WebGLImageConversion::kDataFormatDS24_8;
       break;
     case GL_UNSIGNED_INT_10F_11F_11F_REV:
       dst_format = WebGLImageConversion::kDataFormatRGB10F11F11F;
       break;
     case GL_UNSIGNED_INT_2_10_10_10_REV:
       dst_format = WebGLImageConversion::kDataFormatRGBA2_10_10_10;
       break;
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
   return dst_format;
 }
 
 // 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 129 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::kDataFormatARGB8, uint8_t, uint8_t>(
     const uint8_t* source,
     uint8_t* destination,
     unsigned pixels_per_row) {
   for (unsigned i = 0; i < pixels_per_row; ++i) {
     destination[0] = source[1];
     destination[1] = source[2];
@@ skipping 238 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::kDataFormatA8,
           WebGLImageConversion::kAlphaDoNothing,
           uint8_t,
           uint8_t>(const uint8_t* source,
                    uint8_t* destination,
                    unsigned pixels_per_row) {
   for (unsigned i = 0; i < pixels_per_row; ++i) {
@@ skipping 1585 matching lines @@
         dst_start_(dst_start),
         src_stride_(src_stride),
         src_row_offset_(src_row_offset),
         dst_stride_(dst_stride),
         success_(false) {
     const unsigned kMaxNumberOfComponents = 4;
     const unsigned kMaxBytesPerComponent = 4;
     unpacked_intermediate_src_data_ = WrapArrayUnique(
         new uint8_t[src_sub_rectangle_.Width() * kMaxNumberOfComponents *
                     kMaxBytesPerComponent]);
-    ASSERT(unpacked_intermediate_src_data_.get());
+    DCHECK(unpacked_intermediate_src_data_.get());
   }
 
   void Convert(WebGLImageConversion::DataFormat src_format,
                WebGLImageConversion::DataFormat dst_format,
                WebGLImageConversion::AlphaOp);
   bool Success() const { return success_; }
 
  private:
   template <WebGLImageConversion::DataFormat SrcFormat>
   void Convert(WebGLImageConversion::DataFormat dst_format,
@@ skipping 32 matching lines @@
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::kDataFormatARGB8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::kDataFormatABGR8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::kDataFormatAR8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::kDataFormatBGRA8)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::kDataFormatRGBA5551)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::kDataFormatRGBA4444)
     FORMATCONVERTER_CASE_SRCFORMAT(WebGLImageConversion::kDataFormatRGBA32F)
     FORMATCONVERTER_CASE_SRCFORMAT(
         WebGLImageConversion::kDataFormatRGBA2_10_10_10)
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 #undef FORMATCONVERTER_CASE_SRCFORMAT
 }
 
 template <WebGLImageConversion::DataFormat SrcFormat>
 void FormatConverter::Convert(WebGLImageConversion::DataFormat dst_format,
                               WebGLImageConversion::AlphaOp alpha_op) {
 #define FORMATCONVERTER_CASE_DSTFORMAT(DstFormat) \
   case DstFormat:                                 \
     return Convert<SrcFormat, DstFormat>(alpha_op);
@@ skipping 21 matching lines @@
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::kDataFormatRGBA16)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::kDataFormatRGBA16_S)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::kDataFormatRGBA32)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::kDataFormatRGBA32_S)
     FORMATCONVERTER_CASE_DSTFORMAT(
         WebGLImageConversion::kDataFormatRGBA2_10_10_10)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::kDataFormatRG8)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::kDataFormatRG16F)
     FORMATCONVERTER_CASE_DSTFORMAT(WebGLImageConversion::kDataFormatRG32F)
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 
 #undef FORMATCONVERTER_CASE_DSTFORMAT
 }
 
 template <WebGLImageConversion::DataFormat SrcFormat,
           WebGLImageConversion::DataFormat DstFormat>
 void FormatConverter::Convert(WebGLImageConversion::AlphaOp alpha_op) {
 #define FORMATCONVERTER_CASE_ALPHAOP(alphaOp) \
   case alphaOp:                               \
     return Convert<SrcFormat, DstFormat, alphaOp>();
 
   switch (alpha_op) {
     FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::kAlphaDoNothing)
     FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::kAlphaDoPremultiply)
     FORMATCONVERTER_CASE_ALPHAOP(WebGLImageConversion::kAlphaDoUnmultiply)
     default:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
   }
 #undef FORMATCONVERTER_CASE_ALPHAOP
 }
 
 template <int Format>
 struct SupportsConversionFromDomElements {
   STATIC_ONLY(SupportsConversionFromDomElements);
   static const bool value =
       Format == WebGLImageConversion::kDataFormatRGBA8 ||
       Format == WebGLImageConversion::kDataFormatRGB8 ||
@@ 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::kAlphaDoNothing) {
-    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 src_format_comes_from_dom_element_or_image_data =
       WebGLImageConversion::SrcFormatComeFromDOMElementOrImageData(SrcFormat);
   if (!src_format_comes_from_dom_element_or_image_data &&
       SrcFormat != DstFormat) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   // Likewise, only textures uploaded from DOM elements or ImageData can
   // possibly need to be unpremultiplied.
   if (!src_format_comes_from_dom_element_or_image_data &&
       alphaOp == WebGLImageConversion::kAlphaDoUnmultiply) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   if (src_format_comes_from_dom_element_or_image_data &&
       alphaOp == WebGLImageConversion::kAlphaDoUnmultiply &&
       !SupportsConversionFromDomElements<DstFormat>::value) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
   if ((!HasAlpha(SrcFormat) || !HasColor(SrcFormat) || !HasColor(DstFormat)) &&
       alphaOp != WebGLImageConversion::kAlphaDoNothing) {
-    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 (src_format_comes_from_dom_element_or_image_data &&
       SrcFormat != DstFormat &&
       (DstFormat == WebGLImageConversion::kDataFormatRGB5999 ||
        DstFormat == WebGLImageConversion::kDataFormatRGB10F11F11F)) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return;
   }
 
   typedef typename DataTypeForFormat<SrcFormat>::Type SrcType;
   typedef typename DataTypeForFormat<DstFormat>::Type DstType;
   const int kIntermFormat = IntermediateFormat<DstFormat>::value;
   typedef typename DataTypeForFormat<kIntermFormat>::Type IntermType;
   const ptrdiff_t src_stride_in_elements = src_stride_ / sizeof(SrcType);
   const ptrdiff_t dst_stride_in_elements = dst_stride_ / sizeof(DstType);
   const bool kTrivialUnpack = SrcFormat == kIntermFormat;
   const bool kTrivialPack = DstFormat == kIntermFormat &&
                             alphaOp == WebGLImageConversion::kAlphaDoNothing;
-  ASSERT(!kTrivialUnpack || !kTrivialPack);
+  DCHECK(!kTrivialUnpack || !kTrivialPack);
 
   const SrcType* src_row_start =
       static_cast<const SrcType*>(static_cast<const void*>(
           static_cast<const uint8_t*>(src_start_) +
           ((src_stride_ * src_sub_rectangle_.Y()) + src_row_offset_)));
 
   // 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 143 matching lines @@
 GLenum WebGLImageConversion::ComputeImageSizeInBytes(
     GLenum format,
     GLenum type,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     const PixelStoreParams& params,
     unsigned* image_size_in_bytes,
     unsigned* padding_in_bytes,
     unsigned* skip_size_in_bytes) {
-  ASSERT(image_size_in_bytes);
-  ASSERT(params.alignment == 1 || params.alignment == 2 ||
+  DCHECK(image_size_in_bytes);
+  DCHECK(params.alignment == 1 || params.alignment == 2 ||
          params.alignment == 4 || params.alignment == 8);
-  ASSERT(params.row_length >= 0 && params.image_height >= 0);
-  ASSERT(params.skip_pixels >= 0 && params.skip_rows >= 0 &&
-         params.skip_images >= 0);
+  DCHECK_GE(params.row_length, 0);
+  DCHECK_GE(params.image_height, 0);
+  DCHECK_GE(params.skip_pixels, 0);
+  DCHECK_GE(params.skip_rows, 0);
+  DCHECK_GE(params.skip_images, 0);
   if (width < 0 || height < 0 || depth < 0)
     return GL_INVALID_VALUE;
   if (!width || !height || !depth) {
     *image_size_in_bytes = 0;
     if (padding_in_bytes)
       *padding_in_bytes = 0;
     if (skip_size_in_bytes)
       *skip_size_in_bytes = 0;
     return GL_NO_ERROR;
   }
@@ skipping 91 matching lines @@
     bool premultiply_alpha,
     bool ignore_color_space) {
   image_ = image;
   image_html_dom_source_ = image_html_dom_source;
   ExtractImage(premultiply_alpha, ignore_color_space);
 }
 
 void WebGLImageConversion::ImageExtractor::ExtractImage(
     bool premultiply_alpha,
     bool ignore_color_space) {
-  ASSERT(!image_pixel_locker_);
+  DCHECK(!image_pixel_locker_);
 
   if (!image_)
     return;
 
   sk_sp<SkImage> skia_image = image_->ImageForCurrentFrame();
   SkImageInfo info =
       skia_image ? SkImageInfo::MakeN32Premul(image_->width(), image_->height())
                  : SkImageInfo::MakeUnknown();
   alpha_op_ = kAlphaDoNothing;
   bool has_alpha = skia_image ? !skia_image->isOpaque() : true;
@@ skipping 36 matching lines @@
       alpha_op_ = kAlphaDoUnmultiply;
   }
 
   if (!skia_image)
     return;
 
   image_source_format_ = SK_B32_SHIFT ? kDataFormatRGBA8 : kDataFormatBGRA8;
   image_source_unpack_alignment_ =
       0;  // FIXME: this seems to always be zero - why use at all?
 
-  ASSERT(skia_image->width() && skia_image->height());
+  DCHECK(skia_image->width());
+  DCHECK(skia_image->height());
   image_width_ = skia_image->width();
   image_height_ = skia_image->height();
 
   // Fail if the image was downsampled because of memory limits.
   if (image_width_ != (unsigned)image_->width() ||
       image_height_ != (unsigned)image_->height())
     return;
 
   image_pixel_locker_.emplace(std::move(skia_image), info.alphaType(),
                               kN32_SkColorType);
@@ skipping 368 matching lines @@
       Pack<WebGLImageConversion::kDataFormatRGB565,
            WebGLImageConversion::kAlphaDoNothing>(src_row_start, dst_row_start,
                                                   pixels_per_row);
     } break;
     default:
       break;
   }
 }
 
 }  // namespace blink