cc: Switch to Chromium DCHECKs and LOGs

cc/CCRendererGL.cpp

 // Copyright 2010 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 "config.h"
 
 #if USE(ACCELERATED_COMPOSITING)
 #include "CCRendererGL.h"
 
 #include "CCDamageTracker.h"
 #include "CCLayerQuad.h"
 #include "CCMathUtil.h"
 #include "CCProxy.h"
 #include "CCRenderPass.h"
 #include "CCRenderSurfaceFilters.h"
 #include "CCScopedTexture.h"
 #include "CCSettings.h"
 #include "CCSingleThreadProxy.h"
 #include "CCVideoLayerImpl.h"
 #include "Extensions3D.h"
 #include "FloatQuad.h"
 #include "GeometryBinding.h"
 #include "GrTexture.h"
 #include "NotImplemented.h"
 #include "PlatformColor.h"
 #include "SkBitmap.h"
 #include "SkColor.h"
 #include "TraceEvent.h"
-#ifdef LOG
-#undef LOG
-#endif
+#include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include <public/WebGraphicsContext3D.h>
 #include <public/WebSharedGraphicsContext3D.h>
 #include <public/WebVideoFrame.h>
 #include <set>
 #include <string>
 #include <vector>
 #include <wtf/CurrentTime.h>
 #include <wtf/OwnArrayPtr.h>
@@ skipping 32 matching lines @@
                            CCResourceProvider* resourceProvider)
     : CCDirectRenderer(client, resourceProvider)
     , m_offscreenFramebufferId(0)
     , m_sharedGeometryQuad(FloatRect(-0.5f, -0.5f, 1.0f, 1.0f))
     , m_context(resourceProvider->graphicsContext3D())
     , m_isViewportChanged(false)
     , m_isFramebufferDiscarded(false)
     , m_isUsingBindUniform(false)
     , m_visible(true)
 {
-    ASSERT(m_context);
+    DCHECK(m_context);
 }
 
 bool CCRendererGL::initialize()
 {
     if (!m_context->makeContextCurrent())
         return false;
 
     m_context->setContextLostCallback(this);
     m_context->pushGroupMarkerEXT("CompositorContext");
 
@@ skipping 15 matching lines @@
 
     // Use the swapBuffers callback only with the threaded proxy.
     if (CCProxy::hasImplThread())
         m_capabilities.usingSwapCompleteCallback = extensions.count("GL_CHROMIUM_swapbuffers_complete_callback");
     if (m_capabilities.usingSwapCompleteCallback)
         m_context->setSwapBuffersCompleteCallbackCHROMIUM(this);
 
     m_capabilities.usingSetVisibility = extensions.count("GL_CHROMIUM_set_visibility");
 
     if (extensions.count("GL_CHROMIUM_iosurface"))
-        ASSERT(extensions.count("GL_ARB_texture_rectangle"));
+        DCHECK(extensions.count("GL_ARB_texture_rectangle"));
 
     m_capabilities.usingGpuMemoryManager = extensions.count("GL_CHROMIUM_gpu_memory_manager");
     if (m_capabilities.usingGpuMemoryManager)
         m_context->setMemoryAllocationChangedCallbackCHROMIUM(this);
 
     m_capabilities.usingDiscardFramebuffer = extensions.count("GL_CHROMIUM_discard_framebuffer");
 
     m_capabilities.usingEglImage = extensions.count("GL_OES_EGL_image_external");
 
     GLC(m_context, m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_capabilities.maxTextureSize));
     m_capabilities.bestTextureFormat = PlatformColor::bestTextureFormat(m_context, extensions.count("GL_EXT_texture_format_BGRA8888"));
 
     m_isUsingBindUniform = extensions.count("GL_CHROMIUM_bind_uniform_location");
 
     if (!initializeSharedObjects())
         return false;
 
     // Make sure the viewport and context gets initialized, even if it is to zero.
     viewportChanged();
     return true;
 }
 
 CCRendererGL::~CCRendererGL()
 {
-    ASSERT(CCProxy::isImplThread());
+    DCHECK(CCProxy::isImplThread());
     m_context->setSwapBuffersCompleteCallbackCHROMIUM(0);
     m_context->setMemoryAllocationChangedCallbackCHROMIUM(0);
     m_context->setContextLostCallback(0);
     cleanupSharedObjects();
 }
 
 const RendererCapabilities& CCRendererGL::capabilities() const
 {
     return m_capabilities;
 }
 
 WebGraphicsContext3D* CCRendererGL::context()
 {
     return m_context;
 }
 
 void CCRendererGL::debugGLCall(WebGraphicsContext3D* context, const char* command, const char* file, int line)
 {
     unsigned long error = context->getError();
     if (error != GraphicsContext3D::NO_ERROR)
-        LOG_ERROR("GL command failed: File: %s\n\tLine %d\n\tcommand: %s, error %x\n", file, line, command, static_cast<int>(error));
+        LOG(ERROR) << "GL command failed: File: " << file << "\n\tLine " << line << "\n\tcommand: " << command << ", error " << static_cast<int>(error) << "\n";
 }
 
 void CCRendererGL::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 
     // TODO: Replace setVisibilityCHROMIUM with an extension to explicitly manage front/backbuffers
     // crbug.com/116049
@@ skipping 12 matching lines @@
 }
 
 void CCRendererGL::clearFramebuffer(DrawingFrame& frame)
 {
     // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen.
     if (frame.currentRenderPass->hasTransparentBackground())
         GLC(m_context, m_context->clearColor(0, 0, 0, 0));
     else
         GLC(m_context, m_context->clearColor(0, 0, 1, 1));
 
-#if defined(NDEBUG)
-    if (frame.currentRenderPass->hasTransparentBackground())
-#endif
+    if (DCHECK_IS_ON() || frame.currentRenderPass->hasTransparentBackground())
         m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
 }
 
 void CCRendererGL::beginDrawingFrame(DrawingFrame& frame)
 {
     // FIXME: Remove this once framebuffer is automatically recreated on first use
     ensureFramebuffer();
 
     if (viewportSize().isEmpty())
         return;
@@ skipping 26 matching lines @@
 
 void CCRendererGL::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad)
 {
     if (quad->needsBlending())
         GLC(m_context, m_context->enable(GraphicsContext3D::BLEND));
     else
         GLC(m_context, m_context->disable(GraphicsContext3D::BLEND));
 
     switch (quad->material()) {
     case CCDrawQuad::Invalid:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         break;
     case CCDrawQuad::Checkerboard:
         drawCheckerboardQuad(frame, CCCheckerboardDrawQuad::materialCast(quad));
         break;
     case CCDrawQuad::DebugBorder:
         drawDebugBorderQuad(frame, CCDebugBorderDrawQuad::materialCast(quad));
         break;
     case CCDrawQuad::IOSurfaceContent:
         drawIOSurfaceQuad(frame, CCIOSurfaceDrawQuad::materialCast(quad));
         break;
@@ skipping 14 matching lines @@
         break;
     case CCDrawQuad::YUVVideoContent:
         drawYUVVideoQuad(frame, CCYUVVideoDrawQuad::materialCast(quad));
         break;
     }
 }
 
 void CCRendererGL::drawCheckerboardQuad(const DrawingFrame& frame, const CCCheckerboardDrawQuad* quad)
 {
     const TileCheckerboardProgram* program = tileCheckerboardProgram();
-    ASSERT(program && program->initialized());
+    DCHECK(program && program->initialized());
     GLC(context(), context()->useProgram(program->program()));
 
     SkColor color = quad->color();
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), SkColorGetR(color) / 255.0, SkColorGetG(color) / 255.0, SkColorGetB(color) / 255.0, 1));
 
     const int checkerboardWidth = 16;
     float frequency = 1.0 / checkerboardWidth;
 
     IntRect tileRect = quad->quadRect();
     float texOffsetX = tileRect.x() % checkerboardWidth;
     float texOffsetY = tileRect.y() % checkerboardWidth;
     float texScaleX = tileRect.width();
     float texScaleY = tileRect.height();
     GLC(context(), context()->uniform4f(program->fragmentShader().texTransformLocation(), texOffsetX, texOffsetY, texScaleX, texScaleY));
 
     GLC(context(), context()->uniform1f(program->fragmentShader().frequencyLocation(), frequency));
 
     setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation());
 }
 
 void CCRendererGL::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugBorderDrawQuad* quad)
 {
     static float glMatrix[16];
     const SolidColorProgram* program = solidColorProgram();
-    ASSERT(program && program->initialized());
+    DCHECK(program && program->initialized());
     GLC(context(), context()->useProgram(program->program()));
 
     // Use the full quadRect for debug quads to not move the edges based on partial swaps.
     const IntRect& layerRect = quad->quadRect();
     WebTransformationMatrix renderMatrix = quad->quadTransform();
     renderMatrix.translate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y());
     renderMatrix.scaleNonUniform(layerRect.width(), layerRect.height());
     CCRendererGL::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0]));
 
@@ skipping 44 matching lines @@
 
     // FIXME: When this algorithm changes, update CCLayerTreeHost::prioritizeTextures() accordingly.
 
     if (filters.isEmpty())
         return nullptr;
 
     // FIXME: We only allow background filters on an opaque render surface because other surfaces may contain
     // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied.
     if (frame.currentRenderPass->hasTransparentBackground())
         return nullptr;
-    ASSERT(!frame.currentTexture);
+    DCHECK(!frame.currentTexture);
 
     // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused).
     IntRect deviceRect = enclosingIntRect(CCMathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox()));
 
     int top, right, bottom, left;
     filters.getOutsets(top, right, bottom, left);
     deviceRect.move(-left, -top);
     deviceRect.expand(left + right, top + bottom);
 
     deviceRect.intersect(frame.currentRenderPass->outputRect());
@@ skipping 32 matching lines @@
     return backgroundTexture.release();
 }
 
 void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDrawQuad* quad)
 {
     CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
     if (!contentsTexture || !contentsTexture->id())
         return;
 
     const CCRenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
-    ASSERT(renderPass);
+    DCHECK(renderPass);
     if (!renderPass)
         return;
 
     WebTransformationMatrix renderMatrix = quad->quadTransform();
     renderMatrix.translate(0.5 * quad->quadRect().width() + quad->quadRect().x(), 0.5 * quad->quadRect().height() + quad->quadRect().y());
     WebTransformationMatrix deviceMatrix = renderMatrix;
     deviceMatrix.scaleNonUniform(quad->quadRect().width(), quad->quadRect().height());
     WebTransformationMatrix contentsDeviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * deviceMatrix).to2dTransform();
 
     // Can only draw surface if device matrix is invertible.
@@ skipping 10 matching lines @@
     if (filterBitmap.getTexture()) {
         GrTexture* texture = reinterpret_cast<GrTexture*>(filterBitmap.getTexture());
         contentsTextureId = texture->getTextureHandle();
     } else {
         contentsResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id()));
         contentsTextureId = contentsResourceLock->textureId();
     }
 
     // Draw the background texture if there is one.
     if (backgroundTexture) {
-        ASSERT(backgroundTexture->size() == quad->quadRect().size());
+        DCHECK(backgroundTexture->size() == quad->quadRect().size());
         CCResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id());
         copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform());
     }
 
     bool clipped = false;
     FloatQuad deviceQuad = CCMathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped);
-    ASSERT(!clipped);
+    DCHECK(!clipped);
     CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceQuad.boundingBox()));
     CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceQuad);
 
     // Use anti-aliasing programs only when necessary.
     bool useAA = (!deviceQuad.isRectilinear() || !deviceQuad.boundingBox().isExpressibleAsIntRect());
     if (useAA) {
         deviceLayerBounds.inflateAntiAliasingDistance();
         deviceLayerEdges.inflateAntiAliasingDistance();
     }
 
@@ skipping 50 matching lines @@
     } else {
         const RenderPassProgram* program = renderPassProgram();
         GLC(context(), context()->useProgram(program->program()));
         GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
         shaderMatrixLocation = program->vertexShader().matrixLocation();
         shaderAlphaLocation = program->fragmentShader().alphaLocation();
     }
 
     if (shaderMaskSamplerLocation != -1) {
-        ASSERT(shaderMaskTexCoordScaleLocation != 1);
-        ASSERT(shaderMaskTexCoordOffsetLocation != 1);
+        DCHECK(shaderMaskTexCoordScaleLocation != 1);
+        DCHECK(shaderMaskTexCoordOffsetLocation != 1);
         GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE1));
         GLC(context(), context()->uniform1i(shaderMaskSamplerLocation, 1));
         GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->maskTexCoordScaleX(), quad->maskTexCoordScaleY()));
         GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->maskTexCoordOffsetX(), quad->maskTexCoordOffsetY()));
         context()->bindTexture(GraphicsContext3D::TEXTURE_2D, maskTextureId);
         GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
     }
 
     if (shaderEdgeLocation != -1) {
         float edge[24];
         deviceLayerEdges.toFloatArray(edge);
         deviceLayerBounds.toFloatArray(&edge[12]);
         GLC(context(), context()->uniform3fv(shaderEdgeLocation, 8, edge));
     }
 
     // Map device space quad to surface space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
     FloatQuad surfaceQuad = CCMathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped);
-    ASSERT(!clipped);
+    DCHECK(!clipped);
 
     setShaderOpacity(quad->opacity(), shaderAlphaLocation);
     setShaderFloatQuad(surfaceQuad, shaderQuadLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), shaderMatrixLocation);
 }
 
 void CCRendererGL::drawSolidColorQuad(const DrawingFrame& frame, const CCSolidColorDrawQuad* quad)
 {
     const SolidColorProgram* program = solidColorProgram();
     GLC(context(), context()->useProgram(program->program()));
@@ skipping 67 matching lines @@
     float fragmentTexScaleY = clampRect.height() / textureSize.height();
 
 
     FloatQuad localQuad;
     WebTransformationMatrix deviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform();
     if (!deviceTransform.isInvertible())
         return;
 
     bool clipped = false;
     FloatQuad deviceLayerQuad = CCMathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped);
-    ASSERT(!clipped);
+    DCHECK(!clipped);
 
     TileProgramUniforms uniforms;
     // For now, we simply skip anti-aliasing with the quad is clipped. This only happens
     // on perspective transformed layers that go partially behind the camera.
     if (quad->isAntialiased() && !clipped) {
         if (quad->swizzleContents())
             tileUniformLocation(tileProgramSwizzleAA(), uniforms);
         else
             tileUniformLocation(tileProgramAA(), uniforms);
     } else {
@@ skipping 34 matching lines @@
         GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY));
         GLC(context(), context()->uniform4f(uniforms.fragmentTexTransformLocation, fragmentTexTranslateX, fragmentTexTranslateY, fragmentTexScaleX, fragmentTexScaleY));
 
         FloatPoint bottomRight(tileRect.maxX(), tileRect.maxY());
         FloatPoint bottomLeft(tileRect.x(), tileRect.maxY());
         FloatPoint topLeft(tileRect.x(), tileRect.y());
         FloatPoint topRight(tileRect.maxX(), tileRect.y());
 
         // Map points to device space.
         bottomRight = CCMathUtil::mapPoint(deviceTransform, bottomRight, clipped);
-        ASSERT(!clipped);
+        DCHECK(!clipped);
         bottomLeft = CCMathUtil::mapPoint(deviceTransform, bottomLeft, clipped);
-        ASSERT(!clipped);
+        DCHECK(!clipped);
         topLeft = CCMathUtil::mapPoint(deviceTransform, topLeft, clipped);
-        ASSERT(!clipped);
+        DCHECK(!clipped);
         topRight = CCMathUtil::mapPoint(deviceTransform, topRight, clipped);
-        ASSERT(!clipped);
+        DCHECK(!clipped);
 
         CCLayerQuad::Edge bottomEdge(bottomRight, bottomLeft);
         CCLayerQuad::Edge leftEdge(bottomLeft, topLeft);
         CCLayerQuad::Edge topEdge(topLeft, topRight);
         CCLayerQuad::Edge rightEdge(topRight, bottomRight);
 
         // Only apply anti-aliasing to edges not clipped by culling or scissoring.
         if (quad->topEdgeAA() && tileRect.y() == quad->quadRect().y())
             topEdge = deviceLayerEdges.top();
         if (quad->leftEdgeAA() && tileRect.x() == quad->quadRect().x())
             leftEdge = deviceLayerEdges.left();
         if (quad->rightEdgeAA() && tileRect.maxX() == quad->quadRect().maxX())
             rightEdge = deviceLayerEdges.right();
         if (quad->bottomEdgeAA() && tileRect.maxY() == quad->quadRect().maxY())
             bottomEdge = deviceLayerEdges.bottom();
 
         float sign = FloatQuad(tileRect).isCounterclockwise() ? -1 : 1;
         bottomEdge.scale(sign);
         leftEdge.scale(sign);
         topEdge.scale(sign);
         rightEdge.scale(sign);
 
         // Create device space quad.
         CCLayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge);
 
         // Map device space quad to local space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project.
         WebTransformationMatrix inverseDeviceTransform = deviceTransform.inverse();
         localQuad = CCMathUtil::mapQuad(inverseDeviceTransform, deviceQuad.floatQuad(), clipped);
 
-        // We should not ASSERT(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become
+        // We should not DCHECK(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become
         // clipped. To our knowledge this scenario does not need to be handled differently than the unclipped case.
     } else {
         // Move fragment shader transform to vertex shader. We can do this while
         // still producing correct results as fragmentTexTransformLocation
         // should always be non-negative when tiles are transformed in a way
         // that could result in sampling outside the layer.
         vertexTexScaleX *= fragmentTexScaleX;
         vertexTexScaleY *= fragmentTexScaleY;
         vertexTexTranslateX *= fragmentTexScaleX;
         vertexTexTranslateY *= fragmentTexScaleY;
@@ skipping 16 matching lines @@
     // un-antialiased quad should have and which vertex this is and the float
     // quad passed in via uniform is the actual geometry that gets used to draw
     // it. This is why this centered rect is used and not the original quadRect.
     FloatRect centeredRect(FloatPoint(-0.5 * tileRect.width(), -0.5 * tileRect.height()), tileRect.size());
     drawQuadGeometry(frame, quad->quadTransform(), centeredRect, uniforms.matrixLocation);
 }
 
 void CCRendererGL::drawYUVVideoQuad(const DrawingFrame& frame, const CCYUVVideoDrawQuad* quad)
 {
     const VideoYUVProgram* program = videoYUVProgram();
-    ASSERT(program && program->initialized());
+    DCHECK(program && program->initialized());
 
     const CCVideoLayerImpl::FramePlane& yPlane = quad->yPlane();
     const CCVideoLayerImpl::FramePlane& uPlane = quad->uPlane();
     const CCVideoLayerImpl::FramePlane& vPlane = quad->vPlane();
 
     CCResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);
     CCResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);
     CCResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId);
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE1));
     GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, yPlaneLock.textureId()));
@@ skipping 40 matching lines @@
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation());
 
     // Reset active texture back to texture 0.
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
 }
 
 void CCRendererGL::drawStreamVideoQuad(const DrawingFrame& frame, const CCStreamVideoDrawQuad* quad)
 {
     static float glMatrix[16];
 
-    ASSERT(m_capabilities.usingEglImage);
+    DCHECK(m_capabilities.usingEglImage);
 
     const VideoStreamTextureProgram* program = videoStreamTextureProgram();
     GLC(context(), context()->useProgram(program->program()));
 
     toGLMatrix(&glMatrix[0], quad->matrix());
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().texMatrixLocation(), 1, false, glMatrix));
 
     GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0));
     GLC(context(), context()->bindTexture(Extensions3DChromium::GL_TEXTURE_EXTERNAL_OES, quad->textureId()));
 
     GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
     setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation());
 }
 
 struct TextureProgramBinding {
     template<class Program> void set(Program* program)
     {
-        ASSERT(program && program->initialized());
+        DCHECK(program && program->initialized());
         programId = program->program();
         samplerLocation = program->fragmentShader().samplerLocation();
         matrixLocation = program->vertexShader().matrixLocation();
         alphaLocation = program->fragmentShader().alphaLocation();
     }
     int programId;
     int samplerLocation;
     int matrixLocation;
     int alphaLocation;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
     template<class Program> void set(Program* program)
     {
         TextureProgramBinding::set(program);
         texTransformLocation = program->vertexShader().texTransformLocation();
     }
     int texTransformLocation;
 };
 
 void CCRendererGL::drawTextureQuad(const DrawingFrame& frame, const CCTextureDrawQuad* quad)
 {
-    ASSERT(CCProxy::isImplThread());
+    DCHECK(CCProxy::isImplThread());
 
     TexTransformTextureProgramBinding binding;
     if (quad->flipped())
         binding.set(textureProgramFlip());
     else
         binding.set(textureProgram());
     GLC(context(), context()->useProgram(binding.programId));
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
     const FloatRect& uvRect = quad->uvRect();
     GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()));
@@ skipping 23 matching lines @@
 
     setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), binding.matrixLocation);
 
     if (!quad->premultipliedAlpha())
         GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
 }
 
 void CCRendererGL::drawIOSurfaceQuad(const DrawingFrame& frame, const CCIOSurfaceDrawQuad* quad)
 {
-    ASSERT(CCProxy::isImplThread());
+    DCHECK(CCProxy::isImplThread());
     TexTransformTextureProgramBinding binding;
     binding.set(textureIOSurfaceProgram());
 
     GLC(context(), context()->useProgram(binding.programId));
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
     if (quad->orientation() == CCIOSurfaceDrawQuad::Flipped)
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->ioSurfaceSize().height(), quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height() * -1.0));
     else
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height()));
 
@@ skipping 92 matching lines @@
 }
 
 void CCRendererGL::finish()
 {
     TRACE_EVENT0("cc", "CCRendererGL::finish");
     m_context->finish();
 }
 
 bool CCRendererGL::swapBuffers()
 {
-    ASSERT(m_visible);
-    ASSERT(!m_isFramebufferDiscarded);
+    DCHECK(m_visible);
+    DCHECK(!m_isFramebufferDiscarded);
 
     TRACE_EVENT0("cc", "CCRendererGL::swapBuffers");
     // We're done! Time to swapbuffers!
 
     if (m_capabilities.usingPartialSwap) {
         // If supported, we can save significant bandwidth by only swapping the damaged/scissored region (clamped to the viewport)
         m_swapBufferRect.intersect(IntRect(IntPoint(), viewportSize()));
         int flippedYPosOfRectBottom = viewportHeight() - m_swapBufferRect.y() - m_swapBufferRect.height();
         m_context->postSubBufferCHROMIUM(m_swapBufferRect.x(), flippedYPosOfRectBottom, m_swapBufferRect.width(), m_swapBufferRect.height());
     } else {
         // Note that currently this has the same effect as swapBuffers; we should
         // consider exposing a different entry point on WebGraphicsContext3D.
         m_context->prepareTexture();
     }
 
     m_swapBufferRect = IntRect();
 
     return true;
 }
 
 void CCRendererGL::onSwapBuffersComplete()
 {
     m_client->onSwapBuffersComplete();
 }
 
 void CCRendererGL::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation)
 {
     // FIXME: This is called on the main thread in single threaded mode, but we expect it on the impl thread.
     if (!CCProxy::hasImplThread()) {
-      ASSERT(CCProxy::isMainThread());
+      DCHECK(CCProxy::isMainThread());
       DebugScopedSetImplThread impl;
       onMemoryAllocationChangedOnImplThread(allocation);
     } else {
-      ASSERT(CCProxy::isImplThread());
+      DCHECK(CCProxy::isImplThread());
       onMemoryAllocationChangedOnImplThread(allocation);
     }
 }
 
 void CCRendererGL::onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation allocation)
 {
     if (m_visible && !allocation.gpuResourceSizeInBytes)
         return;
 
     if (!allocation.suggestHaveBackbuffer && !m_visible)
@@ skipping 36 matching lines @@
 }
 
 void CCRendererGL::onContextLost()
 {
     m_client->didLoseContext();
 }
 
 
 void CCRendererGL::getFramebufferPixels(void *pixels, const IntRect& rect)
 {
-    ASSERT(rect.maxX() <= viewportWidth() && rect.maxY() <= viewportHeight());
+    DCHECK(rect.maxX() <= viewportWidth());
+    DCHECK(rect.maxY() <= viewportHeight());
 
     if (!pixels)
         return;
 
     makeContextCurrent();
 
     bool doWorkaround = needsIOSurfaceReadbackWorkaround();
 
     Platform3DObject temporaryTexture = 0;
     Platform3DObject temporaryFBO = 0;
@@ skipping 10 matching lines @@
         GLC(m_context, m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR));
         GLC(m_context, m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE));
         GLC(m_context, m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE));
         // Copy the contents of the current (IOSurface-backed) framebuffer into a temporary texture.
         GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 0, 0, viewportSize().width(), viewportSize().height(), 0));
         temporaryFBO = m_context->createFramebuffer();
         // Attach this texture to an FBO, and perform the readback from that FBO.
         GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, temporaryFBO));
         GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, temporaryTexture, 0));
 
-        ASSERT(m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) == GraphicsContext3D::FRAMEBUFFER_COMPLETE);
+        DCHECK(m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) == GraphicsContext3D::FRAMEBUFFER_COMPLETE);
     }
 
     OwnArrayPtr<uint8_t> srcPixels = adoptArrayPtr(new uint8_t[rect.width() * rect.height() * 4]);
     GLC(m_context, m_context->readPixels(rect.x(), viewportSize().height() - rect.maxY(), rect.width(), rect.height(),
                                      GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, srcPixels.get()));
 
     uint8_t* destPixels = static_cast<uint8_t*>(pixels);
     size_t rowBytes = rect.width() * 4;
     int numRows = rect.height();
     size_t totalBytes = numRows * rowBytes;
@@ skipping 21 matching lines @@
         TRACE_EVENT0("cc", "CCRendererGL::getFramebufferPixels dropping resources after readback");
         discardFramebuffer();
         releaseRenderPassTextures();
         m_client->releaseContentsTextures();
         GLC(m_context, m_context->flush());
     }
 }
 
 bool CCRendererGL::getFramebufferTexture(CCScopedTexture* texture, const IntRect& deviceRect)
 {
-    ASSERT(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GraphicsContext3D::RGB));
+    DCHECK(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GraphicsContext3D::RGB));
 
     if (!texture->id() && !texture->allocate(CCRenderer::ImplPool, deviceRect.size(), GraphicsContext3D::RGB, CCResourceProvider::TextureUsageAny))
         return false;
 
     CCResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());
     GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId()));
     GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(),
                                              deviceRect.x(), deviceRect.y(), deviceRect.width(), deviceRect.height(), 0));
     return true;
 }
 
 bool CCRendererGL::useScopedTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& viewportRect)
 {
-    ASSERT(texture->id());
+    DCHECK(texture->id());
     frame.currentRenderPass = 0;
     frame.currentTexture = texture;
 
     return bindFramebufferToTexture(frame, texture, viewportRect);
 }
 
 void CCRendererGL::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.clear();
     GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0));
 }
 
 bool CCRendererGL::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& framebufferRect)
 {
-    ASSERT(texture->id());
+    DCHECK(texture->id());
 
     GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_offscreenFramebufferId));
     m_currentFramebufferLock = adoptPtr(new CCResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id()));
     unsigned textureId = m_currentFramebufferLock->textureId();
     GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, textureId, 0));
 
-#if !defined ( NDEBUG )
-    if (m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {
-        ASSERT_NOT_REACHED();
-        return false;
-    }
-#endif
+    DCHECK(m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) == GraphicsContext3D::FRAMEBUFFER_COMPLETE);
 
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
 
     return true;
 }
 
 void CCRendererGL::enableScissorTestRect(const IntRect& scissorRect)
 {
     GLC(m_context, m_context->enable(GraphicsContext3D::SCISSOR_TEST));
@@ skipping 52 matching lines @@
         m_solidColorProgram = adoptPtr(new SolidColorProgram(m_context));
     if (!m_solidColorProgram->initialized()) {
         TRACE_EVENT0("cc", "CCRendererGL::solidColorProgram::initialize");
         m_solidColorProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_solidColorProgram.get();
 }
 
 const CCRendererGL::RenderPassProgram* CCRendererGL::renderPassProgram()
 {
-    ASSERT(m_renderPassProgram);
+    DCHECK(m_renderPassProgram);
     if (!m_renderPassProgram->initialized()) {
         TRACE_EVENT0("cc", "CCRendererGL::renderPassProgram::initialize");
         m_renderPassProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_renderPassProgram.get();
 }
 
 const CCRendererGL::RenderPassProgramAA* CCRendererGL::renderPassProgramAA()
 {
     if (!m_renderPassProgramAA)
@@ skipping 22 matching lines @@
         m_renderPassMaskProgramAA = adoptPtr(new RenderPassMaskProgramAA(m_context));
     if (!m_renderPassMaskProgramAA->initialized()) {
         TRACE_EVENT0("cc", "CCRendererGL::renderPassMaskProgramAA::initialize");
         m_renderPassMaskProgramAA->initialize(m_context, m_isUsingBindUniform);
     }
     return m_renderPassMaskProgramAA.get();
 }
 
 const CCRendererGL::TileProgram* CCRendererGL::tileProgram()
 {
-    ASSERT(m_tileProgram);
+    DCHECK(m_tileProgram);
     if (!m_tileProgram->initialized()) {
         TRACE_EVENT0("cc", "CCRendererGL::tileProgram::initialize");
         m_tileProgram->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgram.get();
 }
 
 const CCRendererGL::TileProgramOpaque* CCRendererGL::tileProgramOpaque()
 {
-    ASSERT(m_tileProgramOpaque);
+    DCHECK(m_tileProgramOpaque);
     if (!m_tileProgramOpaque->initialized()) {
         TRACE_EVENT0("cc", "CCRendererGL::tileProgramOpaque::initialize");
         m_tileProgramOpaque->initialize(m_context, m_isUsingBindUniform);
     }
     return m_tileProgramOpaque.get();
 }
 
 const CCRendererGL::TileProgramAA* CCRendererGL::tileProgramAA()
 {
     if (!m_tileProgramAA)
@@ skipping 145 matching lines @@
 }
 
 bool CCRendererGL::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR);
 }
 
 } // namespace cc
 
 #endif // USE(ACCELERATED_COMPOSITING)