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 premultipliedAlpha,
     bool wantAlphaChannel,
     bool wantDepthBuffer,
     bool wantStencilBuffer,
     bool wantAntialiasing,
     PreserveDrawingBuffer preserve,
     WebGLVersion webGLVersion,
     ChromiumImageUsage chromiumImageUsage) {
-  ASSERT(contextProvider);
+  DCHECK(contextProvider);
 
   if (shouldFailDrawingBufferCreationForTesting) {
     shouldFailDrawingBufferCreationForTesting = false;
     return nullptr;
   }
 
   std::unique_ptr<Extensions3DUtil> extensionsUtil =
       Extensions3DUtil::create(contextProvider->contextGL());
   if (!extensionsUtil->isValid()) {
     // This might be the first time we notice that the GL context is lost.
     return nullptr;
   }
-  ASSERT(extensionsUtil->supportsExtension("GL_OES_packed_depth_stencil"));
+  DCHECK(extensionsUtil->supportsExtension("GL_OES_packed_depth_stencil"));
   extensionsUtil->ensureExtensionEnabled("GL_OES_packed_depth_stencil");
   bool multisampleSupported =
       wantAntialiasing && (extensionsUtil->supportsExtension(
                                "GL_CHROMIUM_framebuffer_multisample") ||
                            extensionsUtil->supportsExtension(
                                "GL_EXT_multisampled_render_to_texture")) &&
       extensionsUtil->supportsExtension("GL_OES_rgb8_rgba8");
   if (multisampleSupported) {
     extensionsUtil->ensureExtensionEnabled("GL_OES_rgb8_rgba8");
     if (extensionsUtil->supportsExtension(
@@ skipping 73 matching lines @@
 }
 
 bool DrawingBuffer::bufferClearNeeded() const {
   return m_bufferClearNeeded;
 }
 
 void DrawingBuffer::setBufferClearNeeded(bool flag) {
   if (m_preserveDrawingBuffer == Discard) {
     m_bufferClearNeeded = flag;
   } else {
-    ASSERT(!m_bufferClearNeeded);
+    DCHECK(!m_bufferClearNeeded);
   }
 }
 
 gpu::gles2::GLES2Interface* DrawingBuffer::contextGL() {
   return m_gl;
 }
 
 WebGraphicsContext3DProvider* DrawingBuffer::contextProvider() {
   return m_contextProvider->contextProvider();
 }
@@ skipping 63 matching lines @@
     bool forceGpuResult) {
   DCHECK(m_stateRestorer);
   if (m_destructionInProgress) {
     // 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(!m_isHidden);
+  DCHECK(!m_isHidden);
   if (!m_contentsChanged)
     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 (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR)
     return false;
 
   TRACE_EVENT0("blink,rail", "DrawingBuffer::prepareMailbox");
@@ skipping 491 matching lines @@
 }
 
 void DrawingBuffer::clearPlatformLayer() {
   if (m_layer)
     m_layer->clearTexture();
 
   m_gl->Flush();
 }
 
 void DrawingBuffer::beginDestruction() {
-  ASSERT(!m_destructionInProgress);
+  DCHECK(!m_destructionInProgress);
   m_destructionInProgress = true;
 
   clearPlatformLayer();
   m_recycledColorBufferQueue.clear();
 
   if (m_multisampleFBO)
     m_gl->DeleteFramebuffers(1, &m_multisampleFBO);
 
   if (m_fbo)
     m_gl->DeleteFramebuffers(1, &m_fbo);
@@ skipping 244 matching lines @@
                         wantExplicitResolve() ? m_multisampleFBO : m_fbo);
 }
 
 bool DrawingBuffer::paintRenderingResultsToImageData(
     int& width,
     int& height,
     SourceDrawingBuffer sourceBuffer,
     WTF::ArrayBufferContents& contents) {
   ScopedStateRestorer scopedStateRestorer(this);
 
-  ASSERT(!m_premultipliedAlpha);
+  DCHECK(!m_premultipliedAlpha);
   width = size().width();
   height = size().height();
 
   CheckedNumeric<int> dataSize = 4;
   dataSize *= width;
   dataSize *= height;
   if (!dataSize.IsValid())
     return false;
 
   WTF::ArrayBufferContents pixels(width * height, 4,
@@ skipping 48 matching lines @@
 #endif
   }
 
   if (op == WebGLImageConversion::AlphaDoPremultiply) {
     for (size_t i = 0; i < bufferSize; 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::AlphaDoNothing) {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
   }
 }
 
 void DrawingBuffer::flipVertically(uint8_t* framebuffer,
                                    int width,
                                    int height) {
   std::vector<uint8_t> scanline(width * 4);
   unsigned rowBytes = width * 4;
   unsigned count = height / 2;
   for (unsigned i = 0; i < count; i++) {
@@ skipping 167 matching lines @@
   if (m_pixelUnpackBufferBindingDirty)
     client->DrawingBufferClientRestorePixelUnpackBufferBinding();
 }
 
 bool DrawingBuffer::shouldUseChromiumImage() {
   return RuntimeEnabledFeatures::webGLImageChromiumEnabled() &&
          m_chromiumImageUsage == AllowChromiumImage;
 }
 
 }  // namespace blink