cc: Switch to Chromium DCHECKs LOGs

cc/delegated_renderer_layer_impl.cc

 // Copyright 2012 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"
 
 #include "CCDelegatedRendererLayerImpl.h"
 
 #include "CCAppendQuadsData.h"
 #include "CCQuadSink.h"
@@ skipping 72 matching lines @@
 }
 
 CCRenderPass::Id CCDelegatedRendererLayerImpl::nextContributingRenderPassId(CCRenderPass::Id previous) const
 {
     return CCRenderPass::Id(previous.layerId, previous.index + 1);
 }
 
 CCRenderPass::Id CCDelegatedRendererLayerImpl::convertDelegatedRenderPassId(CCRenderPass::Id delegatedRenderPassId) const
 {
     base::hash_map<CCRenderPass::Id, int>::const_iterator it = m_renderPassesIndexById.find(delegatedRenderPassId);
-    ASSERT(it != m_renderPassesIndexById.end());
+    DCHECK(it != m_renderPassesIndexById.end());
     unsigned delegatedRenderPassIndex = it->second;
     return CCRenderPass::Id(id(), indexToId(delegatedRenderPassIndex));
 }
 
 void CCDelegatedRendererLayerImpl::appendContributingRenderPasses(CCRenderPassSink& renderPassSink)
 {
-    ASSERT(hasContributingDelegatedRenderPasses());
+    DCHECK(hasContributingDelegatedRenderPasses());
 
     for (size_t i = 0; i < m_renderPassesInDrawOrder.size() - 1; ++i) {
         CCRenderPass::Id outputRenderPassId = convertDelegatedRenderPassId(m_renderPassesInDrawOrder[i]->id());
 
         // Don't clash with the RenderPass we generate if we own a RenderSurface.
-        ASSERT(outputRenderPassId.index > 0);
+        DCHECK(outputRenderPassId.index > 0);
 
         renderPassSink.appendRenderPass(m_renderPassesInDrawOrder[i]->copy(outputRenderPassId));
     }
 }
 
 void CCDelegatedRendererLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData)
 {
     if (m_renderPassesInDrawOrder.isEmpty())
         return;
 
     CCRenderPass::Id targetRenderPassId = appendQuadsData.renderPassId;
 
     // If the index of the renderPassId is 0, then it is a renderPass generated for a layer
     // in this compositor, not the delegated renderer. Then we want to merge our root renderPass with
     // the target renderPass. Otherwise, it is some renderPass which we added from the delegated
     // renderer.
     bool shouldMergeRootRenderPassWithTarget = !targetRenderPassId.index;
     if (shouldMergeRootRenderPassWithTarget) {
         // Verify that the renderPass we are appending to is created our renderTarget.
-        ASSERT(targetRenderPassId.layerId == renderTarget()->id());
+        DCHECK(targetRenderPassId.layerId == renderTarget()->id());
 
         CCRenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.last();
         appendRenderPassQuads(quadSink, appendQuadsData, rootDelegatedRenderPass);
     } else {
         // Verify that the renderPass we are appending to was created by us.
-        ASSERT(targetRenderPassId.layerId == id());
+        DCHECK(targetRenderPassId.layerId == id());
 
         int renderPassIndex = idToIndex(targetRenderPassId.index);
         CCRenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex];
         appendRenderPassQuads(quadSink, appendQuadsData, delegatedRenderPass);
     }
 }
 
 void CCDelegatedRendererLayerImpl::appendRenderPassQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData, CCRenderPass* delegatedRenderPass) const
 {
     const CCSharedQuadState* currentSharedQuadState = 0;
     CCSharedQuadState* copiedSharedQuadState = 0;
     for (size_t i = 0; i < delegatedRenderPass->quadList().size(); ++i) {
         CCDrawQuad* quad = delegatedRenderPass->quadList()[i];
 
         if (quad->sharedQuadState() != currentSharedQuadState) {
             currentSharedQuadState = quad->sharedQuadState();
             copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->copy());
             bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id();
             if (!targetIsFromDelegatedRendererLayer) {
               // Should be the root render pass.
-              ASSERT(delegatedRenderPass == m_renderPassesInDrawOrder.last());
+              DCHECK(delegatedRenderPass == m_renderPassesInDrawOrder.last());
               // This layer must be drawing to a renderTarget other than itself.
-              ASSERT(renderTarget() != this);
+              DCHECK(renderTarget() != this);
 
               copiedSharedQuadState->clippedRectInTarget = CCMathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clippedRectInTarget);
               copiedSharedQuadState->quadTransform = copiedSharedQuadState->quadTransform * drawTransform();
               copiedSharedQuadState->opacity *= drawOpacity();
             }
         }
-        ASSERT(copiedSharedQuadState);
+        DCHECK(copiedSharedQuadState);
 
         scoped_ptr<CCDrawQuad> copyQuad;
         if (quad->material() != CCDrawQuad::RenderPass)
             copyQuad = quad->copy(copiedSharedQuadState);
         else {
             CCRenderPass::Id contributingDelegatedRenderPassId = CCRenderPassDrawQuad::materialCast(quad)->renderPassId();
             CCRenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId);
-            ASSERT(contributingRenderPassId != appendQuadsData.renderPassId);
+            DCHECK(contributingRenderPassId != appendQuadsData.renderPassId);
 
             copyQuad = CCRenderPassDrawQuad::materialCast(quad)->copy(copiedSharedQuadState, contributingRenderPassId).PassAs<CCDrawQuad>();
         }
-        ASSERT(copyQuad.get());
+        DCHECK(copyQuad.get());
 
         quadSink.append(copyQuad.Pass(), appendQuadsData);
     }
 }
 
 const char* CCDelegatedRendererLayerImpl::layerTypeAsString() const
 {
     return "DelegatedRendererLayer";
 }
 
 }