Replace ASSERT with DCHECK in modules/

third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp

 // Copyright 2015 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 "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include <memory>
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 180 matching lines @@
 void WebGL2RenderingContextBase::DestroyContext() {
   for (auto& callback : get_buffer_sub_data_async_callbacks_) {
     callback->Destroy();
   }
   get_buffer_sub_data_async_callbacks_.clear();
 
   WebGLRenderingContextBase::DestroyContext();
 }
 
 void WebGL2RenderingContextBase::InitializeNewContext() {
-  ASSERT(!isContextLost());
-  ASSERT(GetDrawingBuffer());
+  DCHECK(!isContextLost());
+  DCHECK(GetDrawingBuffer());
 
   read_framebuffer_binding_ = nullptr;
 
   bound_copy_read_buffer_ = nullptr;
   bound_copy_write_buffer_ = nullptr;
   bound_pixel_pack_buffer_ = nullptr;
   bound_pixel_unpack_buffer_ = nullptr;
   bound_uniform_buffer_ = nullptr;
 
   current_boolean_occlusion_query_ = nullptr;
@@ skipping 475 matching lines @@
           mode <
               static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + MaxColorAttachments()))
         break;
       SynthesizeGLError(GL_INVALID_ENUM, "readBuffer", "invalid read buffer");
       return;
   }
 
   WebGLFramebuffer* read_framebuffer_binding =
       GetFramebufferBinding(GL_READ_FRAMEBUFFER);
   if (!read_framebuffer_binding) {
-    ASSERT(GetDrawingBuffer());
+    DCHECK(GetDrawingBuffer());
     if (mode != GL_BACK && mode != GL_NONE) {
       SynthesizeGLError(GL_INVALID_OPERATION, "readBuffer",
                         "invalid read buffer");
       return;
     }
     read_buffer_of_default_framebuffer_ = mode;
     // translate GL_BACK to GL_COLOR_ATTACHMENT0, because the default
     // framebuffer for WebGL is not fb 0, it is an internal fbo.
     if (mode == GL_BACK)
       mode = GL_COLOR_ATTACHMENT0;
@@ skipping 91 matching lines @@
                                             GLsizei width,
                                             GLsizei height,
                                             GLenum format,
                                             GLenum type,
                                             long long offset) {
   if (isContextLost())
     return;
 
   // Due to WebGL's same-origin restrictions, it is not possible to
   // taint the origin using the WebGL API.
-  ASSERT(canvas()->OriginClean());
+  DCHECK(canvas()->OriginClean());
 
   if (!ValidateValueFitNonNegInt32("readPixels", "offset", offset))
     return;
 
   WebGLBuffer* buffer = bound_pixel_pack_buffer_.Get();
   if (!buffer) {
     SynthesizeGLError(GL_INVALID_OPERATION, "readPixels",
                       "no PIXEL_PACK buffer bound");
     return;
   }
@@ skipping 3729 matching lines @@
     return 0;
 
   return ContextGL()->GetUniformBlockIndex(ObjectOrZero(program),
                                            uniform_block_name.Utf8().data());
 }
 
 bool WebGL2RenderingContextBase::ValidateUniformBlockIndex(
     const char* function_name,
     WebGLProgram* program,
     GLuint block_index) {
-  ASSERT(program);
+  DCHECK(program);
   if (!program->LinkStatus(this)) {
     SynthesizeGLError(GL_INVALID_OPERATION, function_name,
                       "program not linked");
     return false;
   }
   GLint active_uniform_blocks = 0;
   ContextGL()->GetProgramiv(ObjectOrZero(program), GL_ACTIVE_UNIFORM_BLOCKS,
                             &active_uniform_blocks);
   if (block_index >= static_cast<GLuint>(active_uniform_blocks)) {
     SynthesizeGLError(GL_INVALID_VALUE, function_name,
@@ skipping 389 matching lines @@
   switch (cap) {
     case GL_RASTERIZER_DISCARD:
       return true;
     default:
       return WebGLRenderingContextBase::ValidateCapability(function_name, cap);
   }
 }
 
 bool WebGL2RenderingContextBase::IsBufferBoundToTransformFeedback(
     WebGLBuffer* buffer) {
-  ASSERT(buffer);
+  DCHECK(buffer);
   return transform_feedback_binding_->IsBufferBoundToTransformFeedback(buffer);
 }
 
 bool WebGL2RenderingContextBase::IsBufferBoundToNonTransformFeedback(
     WebGLBuffer* buffer) {
-  ASSERT(buffer);
+  DCHECK(buffer);
 
   if (bound_array_buffer_ == buffer ||
       bound_vertex_array_object_->BoundElementArrayBuffer() == buffer ||
       bound_copy_read_buffer_ == buffer || bound_copy_write_buffer_ == buffer ||
       bound_pixel_pack_buffer_ == buffer ||
       bound_pixel_unpack_buffer_ == buffer || bound_uniform_buffer_ == buffer) {
     return true;
   }
 
   for (size_t i = 0; i <= max_bound_uniform_buffer_index_; ++i) {
     if (bound_indexed_uniform_buffers_[i] == buffer)
       return true;
   }
 
   return false;
 }
 
 bool WebGL2RenderingContextBase::ValidateBufferTargetCompatibility(
     const char* function_name,
     GLenum target,
     WebGLBuffer* buffer) {
-  ASSERT(buffer);
+  DCHECK(buffer);
 
   switch (buffer->GetInitialTarget()) {
     case GL_ELEMENT_ARRAY_BUFFER:
       switch (target) {
         case GL_ARRAY_BUFFER:
         case GL_PIXEL_PACK_BUFFER:
         case GL_PIXEL_UNPACK_BUFFER:
         case GL_TRANSFORM_FEEDBACK_BUFFER:
         case GL_UNIFORM_BUFFER:
           SynthesizeGLError(
@@ skipping 761 matching lines @@
 
 void WebGL2RenderingContextBase::
     DrawingBufferClientRestorePixelUnpackBufferBinding() {
   if (!ContextGL())
     return;
   ContextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER,
                           ObjectOrZero(bound_pixel_unpack_buffer_.Get()));
 }
 
 }  // namespace blink