Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/graphics

third_party/WebKit/Source/platform/graphics/ImageFrameGenerator.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 113 matching lines @@
                                          void* pixels,
                                          size_t rowBytes) {
   if (m_decodeFailed)
     return false;
 
   TRACE_EVENT1("blink", "ImageFrameGenerator::decodeAndScale", "frame index",
                static_cast<int>(index));
 
   // This implementation does not support scaling so check the requested size.
   SkISize scaledSize = SkISize::Make(info.width(), info.height());
-  ASSERT(m_fullSize == scaledSize);
+  DCHECK(m_fullSize == scaledSize);

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

Use DCHECK_EQ if it doesn't cause a compile failure.

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

it was cause a compile fail.

 
   // It is okay to allocate ref-counted ExternalMemoryAllocator on the stack,
   // because 1) it contains references to memory that will be invalid after
   // returning (i.e. a pointer to |pixels|) and therefore 2) should not live
   // longer than the call to the current method.
   ExternalMemoryAllocator externalAllocator(info, pixels, rowBytes);
   SkBitmap bitmap = tryToResumeDecode(data, allDataReceived, index, scaledSize,
                                       &externalAllocator);
   DCHECK(externalAllocator.unique());  // Verify we have the only ref-count.
 
   if (bitmap.isNull())
     return false;
 
   // Check to see if the decoder has written directly to the pixel memory
   // provided. If not, make a copy.
-  ASSERT(bitmap.width() == scaledSize.width());
-  ASSERT(bitmap.height() == scaledSize.height());
+  DCHECK_EQ(bitmap.width(), scaledSize.width());
+  DCHECK_EQ(bitmap.height(), scaledSize.height());
   SkAutoLockPixels bitmapLock(bitmap);
   if (bitmap.getPixels() != pixels)
     return bitmap.copyPixelsTo(pixels, rowBytes * info.height(), rowBytes);
   return true;
 }
 
 bool ImageFrameGenerator::decodeToYUV(SegmentReader* data,
                                       size_t index,
                                       const SkISize componentSizes[3],
                                       void* planes[3],
                                       const size_t rowBytes[3]) {
   // TODO (scroggo): The only interesting thing this uses from the
   // ImageFrameGenerator is m_decodeFailed. Move this into
   // DecodingImageGenerator, which is the only class that calls it.
   if (m_decodeFailed)
     return false;
 
   TRACE_EVENT1("blink", "ImageFrameGenerator::decodeToYUV", "frame index",
                static_cast<int>(index));
 
   if (!planes || !planes[0] || !planes[1] || !planes[2] || !rowBytes ||
       !rowBytes[0] || !rowBytes[1] || !rowBytes[2]) {
     return false;
   }
 
   std::unique_ptr<ImageDecoder> decoder = ImageDecoder::create(
       data, true, ImageDecoder::AlphaPremultiplied, m_decoderColorBehavior);
   // getYUVComponentSizes was already called and was successful, so
   // ImageDecoder::create must succeed.
-  ASSERT(decoder);
+  DCHECK(decoder);
 
   std::unique_ptr<ImagePlanes> imagePlanes =
       WTF::makeUnique<ImagePlanes>(planes, rowBytes);
   decoder->setImagePlanes(std::move(imagePlanes));
 
-  ASSERT(decoder->canDecodeToYUV());
+  DCHECK(decoder->canDecodeToYUV());
 
   if (decoder->decodeToYUV()) {
     setHasAlpha(0, false);  // YUV is always opaque
     return true;
   }
 
-  ASSERT(decoder->failed());
+  DCHECK(decoder->failed());
   m_yuvDecodingFailed = true;
   return false;
 }
 
 SkBitmap ImageFrameGenerator::tryToResumeDecode(
     SegmentReader* data,
     bool allDataReceived,
     size_t index,
     const SkISize& scaledSize,
     SkBitmap::Allocator* allocator) {
   TRACE_EVENT1("blink", "ImageFrameGenerator::tryToResumeDecode", "frame index",
                static_cast<int>(index));
 
   ImageDecoder* decoder = 0;
 
   // Lock the mutex, so only one thread can use the decoder at once.
   MutexLocker lock(m_decodeMutex);
   const bool resumeDecoding =
       ImageDecodingStore::instance().lockDecoder(this, m_fullSize, &decoder);
-  ASSERT(!resumeDecoding || decoder);
+  DCHECK(!resumeDecoding || decoder);
 
   SkBitmap fullSizeImage;
   bool complete =
       decode(data, allDataReceived, index, &decoder, &fullSizeImage, allocator);
 
   if (!decoder)
     return SkBitmap();
 
   // If we are not resuming decoding that means the decoder is freshly
   // created and we have ownership. If we are resuming decoding then
@@ skipping 49 matching lines @@
   }
   m_hasAlpha[index] = hasAlpha;
 }
 
 bool ImageFrameGenerator::decode(SegmentReader* data,
                                  bool allDataReceived,
                                  size_t index,
                                  ImageDecoder** decoder,
                                  SkBitmap* bitmap,
                                  SkBitmap::Allocator* allocator) {
-  ASSERT(m_decodeMutex.locked());
+#if DCHECK_IS_ON()
+  DCHECK(m_decodeMutex.locked());
+#endif
   TRACE_EVENT2("blink", "ImageFrameGenerator::decode", "width",
                m_fullSize.width(), "height", m_fullSize.height());
 
   // Try to create an ImageDecoder if we are not given one.
-  ASSERT(decoder);
+  DCHECK(decoder);
   bool newDecoder = false;
   bool shouldCallSetData = true;
   if (!*decoder) {
     newDecoder = true;
     if (m_imageDecoderFactory)
       *decoder = m_imageDecoderFactory->create().release();
 
     if (!*decoder) {
       *decoder = ImageDecoder::create(data, allDataReceived,
                                       ImageDecoder::AlphaPremultiplied,
@@ skipping 43 matching lines @@
     return false;
 
   // A cache object is considered complete if we can decode a complete frame.
   // Or we have received all data. The image might not be fully decoded in
   // the latter case.
   const bool isDecodeComplete =
       frame->getStatus() == ImageFrame::FrameComplete || allDataReceived;
 
   SkBitmap fullSizeBitmap = frame->bitmap();
   if (!fullSizeBitmap.isNull()) {
-    ASSERT(fullSizeBitmap.width() == m_fullSize.width() &&
+    DCHECK(fullSizeBitmap.width() == m_fullSize.width() &&

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

Split this into two DCHECK_EQs.

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

Done.

            fullSizeBitmap.height() == m_fullSize.height());
     setHasAlpha(index, !fullSizeBitmap.isOpaque());
   }
 
   *bitmap = fullSizeBitmap;
   return isDecodeComplete;
 }
 
 bool ImageFrameGenerator::hasAlpha(size_t index) {
   MutexLocker lock(m_alphaMutex);
@@ skipping 19 matching lines @@
   // do YUV decoding.
   std::unique_ptr<ImagePlanes> dummyImagePlanes =
       WTF::wrapUnique(new ImagePlanes);
   decoder->setImagePlanes(std::move(dummyImagePlanes));
 
   return updateYUVComponentSizes(decoder.get(), sizeInfo->fSizes,
                                  sizeInfo->fWidthBytes);
 }
 
 }  // namespace blink