Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in platform/graphics

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

 /*
  * Copyright (c) 2010, 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 60 matching lines @@
     Client* client,
     const IntSize& size,
     bool premultiplied_alpha,
     bool want_alpha_channel,
     bool want_depth_buffer,
     bool want_stencil_buffer,
     bool want_antialiasing,
     PreserveDrawingBuffer preserve,
     WebGLVersion web_gl_version,
     ChromiumImageUsage chromium_image_usage) {
-  ASSERT(context_provider);
+  DCHECK(context_provider);
 
   if (g_should_fail_drawing_buffer_creation_for_testing) {
     g_should_fail_drawing_buffer_creation_for_testing = false;
     return nullptr;
   }
 
   std::unique_ptr<Extensions3DUtil> extensions_util =
       Extensions3DUtil::Create(context_provider->ContextGL());
   if (!extensions_util->IsValid()) {
     // This might be the first time we notice that the GL context is lost.
     return nullptr;
   }
-  ASSERT(extensions_util->SupportsExtension("GL_OES_packed_depth_stencil"));
+  DCHECK(extensions_util->SupportsExtension("GL_OES_packed_depth_stencil"));
   extensions_util->EnsureExtensionEnabled("GL_OES_packed_depth_stencil");
   bool multisample_supported =
       want_antialiasing &&
       (extensions_util->SupportsExtension(
            "GL_CHROMIUM_framebuffer_multisample") ||
        extensions_util->SupportsExtension(
            "GL_EXT_multisampled_render_to_texture")) &&
       extensions_util->SupportsExtension("GL_OES_rgb8_rgba8");
   if (multisample_supported) {
     extensions_util->EnsureExtensionEnabled("GL_OES_rgb8_rgba8");
@@ skipping 74 matching lines @@
 }
 
 bool DrawingBuffer::BufferClearNeeded() const {
   return buffer_clear_needed_;
 }
 
 void DrawingBuffer::SetBufferClearNeeded(bool flag) {
   if (preserve_drawing_buffer_ == kDiscard) {
     buffer_clear_needed_ = flag;
   } else {
-    ASSERT(!buffer_clear_needed_);
+    DCHECK(!buffer_clear_needed_);
   }
 }
 
 gpu::gles2::GLES2Interface* DrawingBuffer::ContextGL() {
   return gl_;
 }
 
 WebGraphicsContext3DProvider* DrawingBuffer::ContextProvider() {
   return context_provider_->ContextProvider();
 }
@@ skipping 63 matching lines @@
     bool force_gpu_result) {
   DCHECK(state_restorer_);
   if (destruction_in_progress_) {
     // It can be hit in the following sequence.
     // 1. WebGL draws something.
     // 2. The compositor begins the frame.
     // 3. Javascript makes a context lost using WEBGL_lose_context extension.
     // 4. Here.
     return false;
   }
-  ASSERT(!is_hidden_);
+  DCHECK(!is_hidden_);
   if (!contents_changed_)
     return false;
 
   // If the context is lost, we don't know if we should be producing GPU or
   // software frames, until we get a new context, since the compositor will
   // be trying to get a new context and may change modes.
   if (gl_->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
     return false;
 
   TRACE_EVENT0("blink,rail", "DrawingBuffer::prepareMailbox");
@@ skipping 497 matching lines @@
 }
 
 void DrawingBuffer::ClearPlatformLayer() {
   if (layer_)
     layer_->ClearTexture();
 
   gl_->Flush();
 }
 
 void DrawingBuffer::BeginDestruction() {
-  ASSERT(!destruction_in_progress_);
+  DCHECK(!destruction_in_progress_);
   destruction_in_progress_ = true;
 
   ClearPlatformLayer();
   recycled_color_buffer_queue_.Clear();
 
   if (multisample_fbo_)
     gl_->DeleteFramebuffers(1, &multisample_fbo_);
 
   if (fbo_)
     gl_->DeleteFramebuffers(1, &fbo_);
@@ skipping 242 matching lines @@
   gl_->BindFramebuffer(target, WantExplicitResolve() ? multisample_fbo_ : fbo_);
 }
 
 bool DrawingBuffer::PaintRenderingResultsToImageData(
     int& width,
     int& height,
     SourceDrawingBuffer source_buffer,
     WTF::ArrayBufferContents& contents) {
   ScopedStateRestorer scoped_state_restorer(this);
 
-  ASSERT(!premultiplied_alpha_);
+  DCHECK(!premultiplied_alpha_);
   width = size().Width();
   height = size().Height();
 
   CheckedNumeric<int> data_size = 4;
   data_size *= width;
   data_size *= height;
   if (!data_size.IsValid())
     return false;
 
   WTF::ArrayBufferContents pixels(width * height, 4,
@@ skipping 48 matching lines @@
 #endif
   }
 
   if (op == WebGLImageConversion::kAlphaDoPremultiply) {
     for (size_t i = 0; i < buffer_size; i += 4) {
       pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255);
       pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255);
       pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255);
     }
   } else if (op != WebGLImageConversion::kAlphaDoNothing) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
   }
 }
 
 void DrawingBuffer::FlipVertically(uint8_t* framebuffer,
                                    int width,
                                    int height) {
   std::vector<uint8_t> scanline(width * 4);
   unsigned row_bytes = width * 4;
   unsigned count = height / 2;
   for (unsigned i = 0; i < count; i++) {
@@ skipping 167 matching lines @@
   if (pixel_unpack_buffer_binding_dirty_)
     client->DrawingBufferClientRestorePixelUnpackBufferBinding();
 }
 
 bool DrawingBuffer::ShouldUseChromiumImage() {
   return RuntimeEnabledFeatures::webGLImageChromiumEnabled() &&
          chromium_image_usage_ == kAllowChromiumImage;
 }
 
 }  // namespace blink