Replace ASSERT with DCHECK in core/

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 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 "core/frame/ImageBitmap.h"
 
 #include <memory>
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
@@ skipping 399 matching lines @@
 // The parameter imageFormat indicates whether the first parameter "image" is
 // unpremultiplied or not.  imageFormat = PremultiplyAlpha means the image is in
 // premuliplied format For example, if the image is already in unpremultiplied
 // format and we want the created ImageBitmap in the same format, then we don't
 // need to use the ImageDecoder to decode the image.
 static PassRefPtr<StaticBitmapImage> CropImageAndApplyColorSpaceConversion(
     Image* image,
     ParsedOptions& parsed_options,
     AlphaDisposition image_format,
     ColorBehavior color_behavior) {
-  ASSERT(image);
+  DCHECK(image);
   IntRect img_rect(IntPoint(), IntSize(image->width(), image->height()));
   const IntRect src_rect = Intersection(img_rect, parsed_options.crop_rect);
 
   // In the case when cropRect doesn't intersect the source image and it
   // requires a umpremul image We immediately return a transparent black image
   // with cropRect.size()
   if (src_rect.IsEmpty() && !parsed_options.premultiply_alpha) {
     SkImageInfo info = SkImageInfo::Make(
         parsed_options.resize_width, parsed_options.resize_height,
         kN32_SkColorType, kUnpremul_SkAlphaType);
@@ skipping 191 matching lines @@
     return;
   image_ = StaticBitmapImage::Create(std::move(skia_image));
   image_->SetOriginClean(
       !video->WouldTaintOrigin(document->GetSecurityOrigin()));
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(HTMLCanvasElement* canvas,
                          Optional<IntRect> crop_rect,
                          const ImageBitmapOptions& options) {
-  ASSERT(canvas->IsPaintable());
+  DCHECK(canvas->IsPaintable());
   RefPtr<Image> input;
   if (canvas->PlaceholderFrame()) {
     input = canvas->PlaceholderFrame();
   } else {
     input = canvas->CopiedImage(kBackBuffer, kPreferAcceleration,
                                 kSnapshotReasonCreateImageBitmap);
   }
   ParsedOptions parsed_options = ParseOptions(
       options, crop_rect, IntSize(input->width(), input->height()));
   if (DstBufferSizeHasOverflow(parsed_options))
@@ skipping 328 matching lines @@
 
   image_->SetOriginClean(origin_clean);
   image_->SetPremultiplied(parsed_options.premultiply_alpha);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image) {
   image_ = std::move(image);
 }
 
 PassRefPtr<StaticBitmapImage> ImageBitmap::Transfer() {
-  ASSERT(!IsNeutered());
+  DCHECK(!IsNeutered());
   is_neutered_ = true;
   image_->Transfer();
   return std::move(image_);
 }
 
 ImageBitmap::~ImageBitmap() {}
 
 ImageBitmap* ImageBitmap::Create(ImageElementBase* image,
                                  Optional<IntRect> crop_rect,
                                  Document* document,
@@ skipping 136 matching lines @@
 void ImageBitmap::AdjustDrawRects(FloatRect* src_rect,
                                   FloatRect* dst_rect) const {}
 
 FloatSize ImageBitmap::ElementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink