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 126 matching lines @@
                                          void* pixels,
                                          size_t row_bytes) {
   if (decode_failed_)
     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 scaled_size = SkISize::Make(info.width(), info.height());
-  ASSERT(full_size_ == scaled_size);
+  DCHECK(full_size_ == scaled_size);
 
   // 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 external_allocator(info, pixels, row_bytes);
   SkBitmap bitmap = TryToResumeDecode(data, all_data_received, index,
                                       scaled_size, &external_allocator);
   DCHECK(external_allocator.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() == scaled_size.width());
-  ASSERT(bitmap.height() == scaled_size.height());
+  DCHECK_EQ(bitmap.width(), scaled_size.width());
+  DCHECK_EQ(bitmap.height(), scaled_size.height());
   SkAutoLockPixels bitmap_lock(bitmap);
   if (bitmap.getPixels() != pixels)
     CopyPixels(pixels, row_bytes, bitmap.getPixels(), bitmap.rowBytes(), info);
   return true;
 }
 
 bool ImageFrameGenerator::DecodeToYUV(SegmentReader* data,
                                       size_t index,
                                       const SkISize component_sizes[3],
                                       void* planes[3],
                                       const size_t row_bytes[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 (decode_failed_)
     return false;
 
   TRACE_EVENT1("blink", "ImageFrameGenerator::decodeToYUV", "frame index",
                static_cast<int>(index));
 
   if (!planes || !planes[0] || !planes[1] || !planes[2] || !row_bytes ||
       !row_bytes[0] || !row_bytes[1] || !row_bytes[2]) {
     return false;
   }
 
   std::unique_ptr<ImageDecoder> decoder = ImageDecoder::Create(
       data, true, ImageDecoder::kAlphaPremultiplied, decoder_color_behavior_);
   // getYUVComponentSizes was already called and was successful, so
   // ImageDecoder::create must succeed.
-  ASSERT(decoder);
+  DCHECK(decoder);
 
   std::unique_ptr<ImagePlanes> image_planes =
       WTF::MakeUnique<ImagePlanes>(planes, row_bytes);
   decoder->SetImagePlanes(std::move(image_planes));
 
-  ASSERT(decoder->CanDecodeToYUV());
+  DCHECK(decoder->CanDecodeToYUV());
 
   if (decoder->DecodeToYUV()) {
     SetHasAlpha(0, false);  // YUV is always opaque
     return true;
   }
 
-  ASSERT(decoder->Failed());
+  DCHECK(decoder->Failed());
   yuv_decoding_failed_ = true;
   return false;
 }
 
 SkBitmap ImageFrameGenerator::TryToResumeDecode(
     SegmentReader* data,
     bool all_data_received,
     size_t index,
     const SkISize& scaled_size,
     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(decode_mutex_);
   const bool resume_decoding =
       ImageDecodingStore::Instance().LockDecoder(this, full_size_, &decoder);
-  ASSERT(!resume_decoding || decoder);
+  DCHECK(!resume_decoding || decoder);
 
   SkBitmap full_size_image;
   bool complete = Decode(data, all_data_received, index, &decoder,
                          &full_size_image, 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 @@
   }
   has_alpha_[index] = has_alpha;
 }
 
 bool ImageFrameGenerator::Decode(SegmentReader* data,
                                  bool all_data_received,
                                  size_t index,
                                  ImageDecoder** decoder,
                                  SkBitmap* bitmap,
                                  SkBitmap::Allocator* allocator) {
-  ASSERT(decode_mutex_.Locked());
+#if DCHECK_IS_ON()
+  DCHECK(decode_mutex_.Locked());
+#endif
   TRACE_EVENT2("blink", "ImageFrameGenerator::decode", "width",
                full_size_.width(), "height", full_size_.height());
 
   // Try to create an ImageDecoder if we are not given one.
-  ASSERT(decoder);
+  DCHECK(decoder);
   bool new_decoder = false;
   bool should_call_set_data = true;
   if (!*decoder) {
     new_decoder = true;
     if (image_decoder_factory_)
       *decoder = image_decoder_factory_->Create().release();
 
     if (!*decoder) {
       *decoder = ImageDecoder::Create(data, all_data_received,
                                       ImageDecoder::kAlphaPremultiplied,
@@ skipping 42 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 is_decode_complete =
       frame->GetStatus() == ImageFrame::kFrameComplete || all_data_received;
 
   SkBitmap full_size_bitmap = frame->Bitmap();
   if (!full_size_bitmap.isNull()) {
-    ASSERT(full_size_bitmap.width() == full_size_.width() &&
-           full_size_bitmap.height() == full_size_.height());
+    DCHECK_EQ(full_size_bitmap.width(), full_size_.width());
+    DCHECK_EQ(full_size_bitmap.height(), full_size_.height());
     SetHasAlpha(index, !full_size_bitmap.isOpaque());
   }
 
   *bitmap = full_size_bitmap;
   return is_decode_complete;
 }
 
 bool ImageFrameGenerator::HasAlpha(size_t index) {
   MutexLocker lock(alpha_mutex_);
   if (index < has_alpha_.size())
@@ skipping 18 matching lines @@
   // do YUV decoding.
   std::unique_ptr<ImagePlanes> dummy_image_planes =
       WTF::WrapUnique(new ImagePlanes);
   decoder->SetImagePlanes(std::move(dummy_image_planes));
 
   return UpdateYUVComponentSizes(decoder.get(), size_info->fSizes,
                                  size_info->fWidthBytes);
 }
 
 }  // namespace blink