Replace ASSERT with DCHECK in modules/

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

 /*
  * Copyright (C) 2009 Apple 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 173 matching lines @@
   // This will call deactivateContext once the context has actually been lost.
   candidate->ForceLostContext(WebGLRenderingContextBase::kSyntheticLostContext,
                               WebGLRenderingContextBase::kWhenAvailable);
 }
 
 WebGLRenderingContextBase* WebGLRenderingContextBase::OldestContext() {
   if (ActiveContexts().IsEmpty())
     return nullptr;
 
   WebGLRenderingContextBase* candidate = *(ActiveContexts().begin());
-  ASSERT(!candidate->isContextLost());
+  DCHECK(!candidate->isContextLost());
   for (WebGLRenderingContextBase* context : ActiveContexts()) {
-    ASSERT(!context->isContextLost());
+    DCHECK(!context->isContextLost());
     if (context->ContextGL()->GetLastFlushIdCHROMIUM() <
         candidate->ContextGL()->GetLastFlushIdCHROMIUM()) {
       candidate = context;
     }
   }
 
   return candidate;
 }
 
 WebGLRenderingContextBase* WebGLRenderingContextBase::OldestEvictedContext() {
@@ skipping 17 matching lines @@
   unsigned max_gl_contexts = CurrentMaxGLContexts();
   unsigned removed_contexts = 0;
   while (ActiveContexts().size() >= max_gl_contexts &&
          removed_contexts < max_gl_contexts) {
     ForciblyLoseOldestContext(
         "WARNING: Too many active WebGL contexts. Oldest context will be "
         "lost.");
     removed_contexts++;
   }
 
-  ASSERT(!context->isContextLost());
+  DCHECK(!context->isContextLost());
   ActiveContexts().insert(context);
 }
 
 void WebGLRenderingContextBase::DeactivateContext(
     WebGLRenderingContextBase* context) {
   ActiveContexts().erase(context);
 }
 
 void WebGLRenderingContextBase::AddToEvictedList(
     WebGLRenderingContextBase* context) {
   static int generation = 0;
   ForciblyEvictedContexts().Set(context, generation++);
 }
 
 void WebGLRenderingContextBase::RemoveFromEvictedList(
     WebGLRenderingContextBase* context) {
   ForciblyEvictedContexts().erase(context);
 }
 
 void WebGLRenderingContextBase::RestoreEvictedContext(
     WebGLRenderingContextBase* context) {
   // These two sets keep weak references to their contexts;
   // verify that the GC already removed the |context| entries.
-  ASSERT(!ForciblyEvictedContexts().Contains(context));
-  ASSERT(!ActiveContexts().Contains(context));
+  DCHECK(!ForciblyEvictedContexts().Contains(context));
+  DCHECK(!ActiveContexts().Contains(context));
 
   unsigned max_gl_contexts = CurrentMaxGLContexts();
   // Try to re-enable the oldest inactive contexts.
   while (ActiveContexts().size() < max_gl_contexts &&
          ForciblyEvictedContexts().size()) {
     WebGLRenderingContextBase* evicted_context = OldestEvictedContext();
     if (!evicted_context->restore_allowed_) {
       ForciblyEvictedContexts().erase(evicted_context);
       continue;
     }
@@ skipping 314 matching lines @@
   Platform::ContextAttributes context_attributes;
   Platform::GraphicsInfo* gl_info;
   KURL url;
   // Outputs.
   std::unique_ptr<WebGraphicsContext3DProvider> created_context_provider;
 };
 
 static void CreateContextProviderOnMainThread(
     ContextProviderCreationInfo* creation_info,
     WaitableEvent* waitable_event) {
-  ASSERT(IsMainThread());
+  DCHECK(IsMainThread());
   creation_info->created_context_provider =
       Platform::Current()->CreateOffscreenGraphicsContext3DProvider(
           creation_info->context_attributes, creation_info->url, 0,
           creation_info->gl_info);
   waitable_event->Signal();
 }
 
 static std::unique_ptr<WebGraphicsContext3DProvider>
 CreateContextProviderOnWorkerThread(
     Platform::ContextAttributes context_attributes,
@@ skipping 426 matching lines @@
       one_plus_max_non_default_texture_unit_(0),
       is_web_gl2_formats_types_added_(false),
       is_web_gl2_tex_image_source_formats_types_added_(false),
       is_web_gl2_internal_formats_copy_tex_image_added_(false),
       is_oes_texture_float_formats_types_added_(false),
       is_oes_texture_half_float_formats_types_added_(false),
       is_web_gl_depth_texture_formats_types_added_(false),
       is_ext_srgb_formats_types_added_(false),
       is_ext_color_buffer_float_formats_added_(false),
       version_(version) {
-  ASSERT(context_provider);
+  DCHECK(context_provider);
 
   context_group_->AddContext(this);
 
   max_viewport_dims_[0] = max_viewport_dims_[1] = 0;
   context_provider->ContextGL()->GetIntegerv(GL_MAX_VIEWPORT_DIMS,
                                              max_viewport_dims_);
 
   RefPtr<DrawingBuffer> buffer;
   buffer = CreateDrawingBuffer(std::move(context_provider));
   if (!buffer) {
@@ skipping 56 matching lines @@
                                   : DrawingBuffer::kAllowChromiumImage;
 
   return DrawingBuffer::Create(
       std::move(context_provider), this, ClampedCanvasSize(),
       premultiplied_alpha, want_alpha_channel, want_depth_buffer,
       want_stencil_buffer, want_antialiasing, preserve, web_gl_version,
       chromium_image_usage, color_params());
 }
 
 void WebGLRenderingContextBase::InitializeNewContext() {
-  ASSERT(!isContextLost());
-  ASSERT(GetDrawingBuffer());
+  DCHECK(!isContextLost());
+  DCHECK(GetDrawingBuffer());
 
   marked_canvas_dirty_ = false;
   animation_frame_in_progress_ = false;
   active_texture_unit_ = 0;
   pack_alignment_ = 4;
   unpack_alignment_ = 4;
   unpack_flip_y_ = false;
   unpack_premultiply_alpha_ = false;
   unpack_colorspace_conversion_ = GC3D_BROWSER_DEFAULT_WEBGL;
   bound_array_buffer_ = nullptr;
@@ skipping 119 matching lines @@
   supported_tex_image_source_types_.clear();
   ADD_VALUES_TO_SET(supported_tex_image_source_types_, kSupportedTypesES2);
 
   // The DrawingBuffer was unable to store the state that dirtied when it was
   // initialized. Restore it now.
   GetDrawingBuffer()->RestoreAllState();
   ActivateContext(this);
 }
 
 void WebGLRenderingContextBase::SetupFlags() {
-  ASSERT(GetDrawingBuffer());
+  DCHECK(GetDrawingBuffer());
   if (canvas()) {
     if (Page* p = canvas()->GetDocument().GetPage()) {
       synthesized_errors_to_console_ =
           p->GetSettings().GetWebGLErrorsToConsoleEnabled();
     }
   }
 
   is_depth_stencil_supported_ =
       ExtensionsUtil()->IsExtensionEnabled("GL_OES_packed_depth_stencil");
 }
@@ skipping 42 matching lines @@
   extensions_util_.reset();
 
   std::unique_ptr<WTF::Closure> null_closure;
   std::unique_ptr<WTF::Function<void(const char*, int32_t)>> null_function;
   GetDrawingBuffer()->ContextProvider()->SetLostContextCallback(
       ConvertToBaseCallback(std::move(null_closure)));
   GetDrawingBuffer()->ContextProvider()->SetErrorMessageCallback(
       ConvertToBaseCallback(std::move(null_function)));
   GetDrawingBuffer()->AddNewMailboxCallback(nullptr);
 
-  ASSERT(GetDrawingBuffer());
+  DCHECK(GetDrawingBuffer());
   drawing_buffer_->BeginDestruction();
   drawing_buffer_.Clear();
 }
 
 void WebGLRenderingContextBase::MarkContextChanged(
     ContentChangeType change_type) {
   if (framebuffer_binding_ || isContextLost())
     return;
 
   if (!GetDrawingBuffer()->MarkContentsChanged() && marked_canvas_dirty_) {
@@ skipping 143 matching lines @@
     GetDrawingBuffer()->SetBufferClearNeeded(true);
 }
 
 void WebGLRenderingContextBase::SetIsHidden(bool hidden) {
   is_hidden_ = hidden;
   if (GetDrawingBuffer())
     GetDrawingBuffer()->SetIsHidden(hidden);
 
   if (!hidden && isContextLost() && restore_allowed_ &&
       auto_recovery_method_ == kAuto) {
-    ASSERT(!restore_timer_.IsActive());
+    DCHECK(!restore_timer_.IsActive());
     restore_timer_.StartOneShot(0, BLINK_FROM_HERE);
   }
 }
 
 bool WebGLRenderingContextBase::PaintRenderingResultsToCanvas(
     SourceDrawingBuffer source_buffer) {
   if (isContextLost())
     return false;
 
   bool must_clear_now = ClearIfComposited() != kSkipped;
@@ skipping 2475 matching lines @@
   if (read_framebuffer_binding) {
     const char* reason = "framebuffer incomplete";
     if (read_framebuffer_binding->CheckDepthStencilStatus(&reason) !=
         GL_FRAMEBUFFER_COMPLETE) {
       SynthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, function_name,
                         reason);
       return false;
     }
   } else {
     if (read_buffer_of_default_framebuffer_ == GL_NONE) {
-      ASSERT(IsWebGL2OrHigher());
+      DCHECK(IsWebGL2OrHigher());
       SynthesizeGLError(GL_INVALID_OPERATION, function_name,
                         "no image to read from");
       return false;
     }
   }
   return true;
 }
 
 bool WebGLRenderingContextBase::ValidateReadPixelsFormatAndType(
     GLenum format,
@@ skipping 165 matching lines @@
   }
 }
 
 void WebGLRenderingContextBase::RenderbufferStorageImpl(
     GLenum target,
     GLsizei samples,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     const char* function_name) {
-  ASSERT(!samples);             // |samples| > 0 is only valid in WebGL2's
+  DCHECK(!samples);             // |samples| > 0 is only valid in WebGL2's
                                 // renderbufferStorageMultisample().
-  ASSERT(!IsWebGL2OrHigher());  // Make sure this is overridden in WebGL 2.
+  DCHECK(!IsWebGL2OrHigher());  // Make sure this is overridden in WebGL 2.
   switch (internalformat) {
     case GL_DEPTH_COMPONENT16:
     case GL_RGBA4:
     case GL_RGB5_A1:
     case GL_RGB565:
     case GL_STENCIL_INDEX8:
       ContextGL()->RenderbufferStorage(target, internalformat, width, height);
       renderbuffer_binding_->SetInternalFormat(internalformat);
       renderbuffer_binding_->SetSize(width, height);
       break;
     case GL_SRGB8_ALPHA8_EXT:
       if (!ExtensionEnabled(kEXTsRGBName)) {
         SynthesizeGLError(GL_INVALID_ENUM, function_name, "sRGB not enabled");
         break;
       }
       ContextGL()->RenderbufferStorage(target, internalformat, width, height);
       renderbuffer_binding_->SetInternalFormat(internalformat);
       renderbuffer_binding_->SetSize(width, height);
       break;
     case GL_DEPTH_STENCIL_OES:
-      ASSERT(IsDepthStencilSupported());
+      DCHECK(IsDepthStencilSupported());
       ContextGL()->RenderbufferStorage(target, GL_DEPTH24_STENCIL8_OES, width,
                                        height);
       renderbuffer_binding_->SetSize(width, height);
       renderbuffer_binding_->SetInternalFormat(internalformat);
       break;
     default:
       SynthesizeGLError(GL_INVALID_ENUM, function_name,
                         "invalid internalformat");
       break;
   }
@@ skipping 350 matching lines @@
 }
 
 // TODO(fmalita): figure why WebGLImageConversion::ImageExtractor can't handle
 // SVG-backed images, and get rid of this intermediate step.
 PassRefPtr<Image> WebGLRenderingContextBase::DrawImageIntoBuffer(
     PassRefPtr<Image> pass_image,
     int width,
     int height,
     const char* function_name) {
   RefPtr<Image> image(std::move(pass_image));
-  ASSERT(image);
+  DCHECK(image);
 
   IntSize size(width, height);
   ImageBuffer* buf = generated_image_cache_.GetImageBuffer(size);
   if (!buf) {
     SynthesizeGLError(GL_OUT_OF_MEMORY, function_name, "out of memory");
     return nullptr;
   }
 
   if (!image->CurrentFrameKnownToBeOpaque())
     buf->Canvas()->clear(SK_ColorTRANSPARENT);
@@ skipping 825 matching lines @@
     function_type = kTexImage;
   else
     function_type = kTexSubImage;
 
   GLsizei width = source_sub_rect.Width();
   GLsizei height = source_sub_rect.Height();
   if (!ValidateTexFunc(func_name, function_type, kSourceImageBitmap, target,
                        level, internalformat, width, height, depth, 0, format,
                        type, xoffset, yoffset, zoffset))
     return;
-  ASSERT(bitmap->BitmapImage());
+  DCHECK(bitmap->BitmapImage());
 
   // TODO(kbr): make this work for sub-rectangles of ImageBitmaps.
   if (function_id != kTexSubImage3D && function_id != kTexImage3D &&
       bitmap->IsAccelerated() && CanUseTexImageByGPU(format, type) &&
       !selecting_sub_rectangle) {
     if (function_id == kTexImage2D) {
       TexImage2DBase(target, level, internalformat, width, height, 0, format,
                      type, 0);
       TexImageByGPU(function_id, texture, target, level, 0, 0, 0, bitmap,
                     source_sub_rect);
@@ skipping 2036 matching lines @@
       EventTypeNames::webglcontextlost, false, true, "");
   host()->HostDispatchEvent(event);
   restore_allowed_ = event->defaultPrevented();
   if (restore_allowed_ && !is_hidden_) {
     if (auto_recovery_method_ == kAuto)
       restore_timer_.StartOneShot(0, BLINK_FROM_HERE);
   }
 }
 
 void WebGLRenderingContextBase::MaybeRestoreContext(TimerBase*) {
-  ASSERT(isContextLost());
+  DCHECK(isContextLost());
 
   // The rendering context is not restored unless the default behavior of the
   // webglcontextlost event was prevented earlier.
   //
   // Because of the way m_restoreTimer is set up for real vs. synthetic lost
   // context events, we don't have to worry about this test short-circuiting
   // the retry loop for real context lost events.
   if (!restore_allowed_)
     return;
 
@@ skipping 350 matching lines @@
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas()) {
     result.setHTMLCanvasElement(static_cast<HTMLCanvasElement*>(host()));
   } else {
     result.setOffscreenCanvas(static_cast<OffscreenCanvas*>(host()));
   }
 }
 
 }  // namespace blink