cc: Switch to Chromium DCHECKs and LOGs

cc/CCRenderSurface.cpp

 // Copyright 2011 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 "CCRenderSurface.h"
 
+#include "base/logging.h"
 #include "base/stringprintf.h"
 #include "CCDamageTracker.h"
 #include "CCDebugBorderDrawQuad.h"
 #include "CCDelegatedRendererLayerImpl.h"
 #include "CCLayerImpl.h"
 #include "CCMathUtil.h"
 #include "CCQuadSink.h"
 #include "CCRenderPass.h"
 #include "CCRenderPassDrawQuad.h"
 #include "CCRenderPassSink.h"
@@ skipping 108 matching lines @@
 bool CCRenderSurface::surfacePropertyChanged() const
 {
     // Surface property changes are tracked as follows:
     //
     // - m_surfacePropertyChanged is flagged when the clipRect or contentRect change. As
     //   of now, these are the only two properties that can be affected by descendant layers.
     //
     // - all other property changes come from the owning layer (or some ancestor layer
     //   that propagates its change to the owning layer).
     //
-    ASSERT(m_owningLayer);
+    DCHECK(m_owningLayer);
     return m_surfacePropertyChanged || m_owningLayer->layerPropertyChanged();
 }
 
 bool CCRenderSurface::surfacePropertyChangedOnlyFromDescendant() const
 {
     return m_surfacePropertyChanged && !m_owningLayer->layerPropertyChanged();
 }
 
 void CCRenderSurface::addContributingDelegatedRenderPassLayer(CCLayerImpl* layer)
 {
-    ASSERT(std::find(m_layerList.begin(), m_layerList.end(), layer) != m_layerList.end());
+    DCHECK(std::find(m_layerList.begin(), m_layerList.end(), layer) != m_layerList.end());
     CCDelegatedRendererLayerImpl* delegatedRendererLayer = static_cast<CCDelegatedRendererLayerImpl*>(layer);
     m_contributingDelegatedRenderPassLayerList.push_back(delegatedRendererLayer);
 }
 
 void CCRenderSurface::clearLayerLists()
 {
     m_layerList.clear();
     m_contributingDelegatedRenderPassLayerList.clear();
 }
 
 static inline IntRect computeClippedRectInTarget(const CCLayerImpl* owningLayer)
 {
-    ASSERT(owningLayer->parent());
+    DCHECK(owningLayer->parent());
 
     const CCLayerImpl* renderTarget = owningLayer->parent()->renderTarget();
     const CCRenderSurface* self = owningLayer->renderSurface();
 
     IntRect clippedRectInTarget = self->clipRect();
     if (owningLayer->backgroundFilters().hasFilterThatMovesPixels()) {
         // If the layer has background filters that move pixels, we cannot scissor as tightly.
         // FIXME: this should be able to be a tighter scissor, perhaps expanded by the filter outsets?
         clippedRectInTarget = renderTarget->renderSurface()->contentRect();
     } else if (clippedRectInTarget.isEmpty()) {
         // For surfaces, empty clipRect means that the surface does not clip anything.
         clippedRectInTarget = enclosingIntRect(intersection(renderTarget->renderSurface()->contentRect(), self->drawableContentRect()));
     } else
         clippedRectInTarget.intersect(enclosingIntRect(self->drawableContentRect()));
     return clippedRectInTarget;
 }
 
 CCRenderPass::Id CCRenderSurface::renderPassId()
 {
     int layerId = m_owningLayer->id();
     int subId = 0;
-    ASSERT(layerId > 0);
+    DCHECK(layerId > 0);
     return CCRenderPass::Id(layerId, subId);
 }
 
 void CCRenderSurface::appendRenderPasses(CCRenderPassSink& passSink)
 {
     for (size_t i = 0; i < m_contributingDelegatedRenderPassLayerList.size(); ++i)
         m_contributingDelegatedRenderPassLayerList[i]->appendContributingRenderPasses(passSink);
 
     scoped_ptr<CCRenderPass> pass = CCRenderPass::create(renderPassId(), m_contentRect, m_screenSpaceTransform);
     pass->setDamageRect(m_damageTracker->currentDamageRect());
     pass->setFilters(m_owningLayer->filters());
     pass->setBackgroundFilters(m_owningLayer->backgroundFilters());
     passSink.appendRenderPass(pass.Pass());
 }
 
 void CCRenderSurface::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData, bool forReplica, CCRenderPass::Id renderPassId)
 {
-    ASSERT(!forReplica || m_owningLayer->hasReplica());
+    DCHECK(!forReplica || m_owningLayer->hasReplica());
 
     IntRect clippedRectInTarget = computeClippedRectInTarget(m_owningLayer);
     bool isOpaque = false;
     const WebTransformationMatrix& drawTransform = forReplica ? m_replicaDrawTransform : m_drawTransform;
     CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(CCSharedQuadState::create(drawTransform, m_contentRect, clippedRectInTarget, m_drawOpacity, isOpaque).Pass());
 
     if (m_owningLayer->hasDebugBorders()) {
         int red = forReplica ? debugReplicaBorderColorRed : debugSurfaceBorderColorRed;
         int green = forReplica ?  debugReplicaBorderColorGreen : debugSurfaceBorderColorGreen;
         int blue = forReplica ? debugReplicaBorderColorBlue : debugSurfaceBorderColorBlue;
@@ skipping 30 matching lines @@
 
     CCResourceProvider::ResourceId maskResourceId = maskLayer ? maskLayer->contentsResourceId() : 0;
     IntRect contentsChangedSinceLastFrame = contentsChanged() ? m_contentRect : IntRect();
 
     quadSink.append(CCRenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame,
                                                  maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY).PassAs<CCDrawQuad>(), appendQuadsData);
 }
 
 }
 #endif // USE(ACCELERATED_COMPOSITING)