cc: Switch to Chromium DCHECKs and LOGs

cc/thread_proxy.cc

Index: cc/thread_proxy.cc
diff --git a/cc/thread_proxy.cc b/cc/thread_proxy.cc
index 2e1e74d3bd4e3353c6b7d3007b7b60938afb1e10..dd3a22676aabc5e108ac1b0e07f997603d54803a 100644
--- a/cc/thread_proxy.cc
+++ b/cc/thread_proxy.cc
@@ -56,21 +56,21 @@ CCThreadProxy::CCThreadProxy(CCLayerTreeHost* layerTreeHost)
     , m_totalCommitCount(0)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::CCThreadProxy");
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
 }
 
 CCThreadProxy::~CCThreadProxy()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::~CCThreadProxy");
-    ASSERT(isMainThread());
-    ASSERT(!m_started);
+    CC_DCHECK(isMainThread());
+    CC_DCHECK(!m_started);
 }
 
 bool CCThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
 {
     TRACE_EVENT0("cc", "CCThreadPRoxy::compositeAndReadback");
-    ASSERT(isMainThread());
-    ASSERT(m_layerTreeHost);
+    CC_DCHECK(isMainThread());
+    CC_DCHECK(m_layerTreeHost);
 
     if (!m_layerTreeHost->initializeRendererIfNeeded()) {
         TRACE_EVENT0("cc", "compositeAndReadback_EarlyOut_LR_Uninitialized");
@@ -103,8 +103,8 @@ bool CCThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
 
 void CCThreadProxy::requestReadbackOnImplThread(ReadbackRequest* request)
 {
-    ASSERT(CCProxy::isImplThread());
-    ASSERT(!m_readbackRequestOnImplThread);
+    CC_DCHECK(CCProxy::isImplThread());
+    CC_DCHECK(!m_readbackRequestOnImplThread);
     if (!m_layerTreeHostImpl.get()) {
         request->success = false;
         request->completion.signal();
@@ -118,20 +118,20 @@ void CCThreadProxy::requestReadbackOnImplThread(ReadbackRequest* request)
 
 void CCThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration)
 {
-    ASSERT(CCProxy::isMainThread());
+    CC_DCHECK(CCProxy::isMainThread());
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::requestStartPageScaleAnimationOnImplThread, targetPosition, useAnchor, scale, duration));
 }
 
 void CCThreadProxy::requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double duration)
 {
-    ASSERT(CCProxy::isImplThread());
+    CC_DCHECK(CCProxy::isImplThread());
     if (m_layerTreeHostImpl.get())
         m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, monotonicallyIncreasingTime(), duration);
 }
 
 void CCThreadProxy::finishAllRendering()
 {
-    ASSERT(CCProxy::isMainThread());
+    CC_DCHECK(CCProxy::isMainThread());
 
     // Make sure all GL drawing is finished on the impl thread.
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
@@ -142,7 +142,7 @@ void CCThreadProxy::finishAllRendering()
 
 bool CCThreadProxy::isStarted() const
 {
-    ASSERT(CCProxy::isMainThread());
+    CC_DCHECK(CCProxy::isMainThread());
     return m_started;
 }
 
@@ -212,7 +212,7 @@ bool CCThreadProxy::initializeRenderer()
 bool CCThreadProxy::recreateContext()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::recreateContext");
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
 
     // Try to create the context.
     scoped_ptr<CCGraphicsContext> context = m_layerTreeHost->createContext();
@@ -243,7 +243,7 @@ bool CCThreadProxy::recreateContext()
 
 void CCThreadProxy::renderingStats(CCRenderingStats* stats)
 {
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
 
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
@@ -258,7 +258,7 @@ void CCThreadProxy::renderingStats(CCRenderingStats* stats)
 
 const RendererCapabilities& CCThreadProxy::rendererCapabilities() const
 {
-    ASSERT(m_rendererInitialized);
+    CC_DCHECK(m_rendererInitialized);
     return m_RendererCapabilitiesMainThreadCopy;
 }
 
@@ -269,7 +269,7 @@ void CCThreadProxy::loseContext()
 
 void CCThreadProxy::setNeedsAnimate()
 {
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     if (m_animateRequested)
         return;
 
@@ -284,7 +284,7 @@ void CCThreadProxy::setNeedsAnimate()
 
 void CCThreadProxy::setNeedsCommit()
 {
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     if (m_commitRequested)
         return;
     TRACE_EVENT0("cc", "CCThreadProxy::setNeedsCommit");
@@ -298,14 +298,14 @@ void CCThreadProxy::setNeedsCommit()
 
 void CCThreadProxy::didLoseContextOnImplThread()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT0("cc", "CCThreadProxy::didLoseContextOnImplThread");
     m_schedulerOnImplThread->didLoseContext();
 }
 
 void CCThreadProxy::onSwapBuffersCompleteOnImplThread()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT0("cc", "CCThreadProxy::onSwapBuffersCompleteOnImplThread");
     m_schedulerOnImplThread->didSwapBuffersComplete();
     m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::didCompleteSwapBuffers));
@@ -313,7 +313,7 @@ void CCThreadProxy::onSwapBuffersCompleteOnImplThread()
 
 void CCThreadProxy::onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds)
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT2("cc", "CCThreadProxy::onVSyncParametersChanged", "monotonicTimebase", monotonicTimebase, "intervalInSeconds", intervalInSeconds);
     base::TimeTicks timebase = base::TimeTicks::FromInternalValue(monotonicTimebase * base::Time::kMicrosecondsPerSecond);
     base::TimeDelta interval = base::TimeDelta::FromMicroseconds(intervalInSeconds * base::Time::kMicrosecondsPerSecond);
@@ -322,21 +322,21 @@ void CCThreadProxy::onVSyncParametersChanged(double monotonicTimebase, double in
 
 void CCThreadProxy::onCanDrawStateChanged(bool canDraw)
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT1("cc", "CCThreadProxy::onCanDrawStateChanged", "canDraw", canDraw);
     m_schedulerOnImplThread->setCanDraw(canDraw);
 }
 
 void CCThreadProxy::setNeedsCommitOnImplThread()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT0("cc", "CCThreadProxy::setNeedsCommitOnImplThread");
     m_schedulerOnImplThread->setNeedsCommit();
 }
 
 void CCThreadProxy::setNeedsForcedCommitOnImplThread()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT0("cc", "CCThreadProxy::setNeedsForcedCommitOnImplThread");
     m_schedulerOnImplThread->setNeedsCommit();
     m_schedulerOnImplThread->setNeedsForcedCommit();
@@ -344,14 +344,14 @@ void CCThreadProxy::setNeedsForcedCommitOnImplThread()
 
 void CCThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<CCAnimationEventsVector> events, double wallClockTime)
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT0("cc", "CCThreadProxy::postAnimationEventsToMainThreadOnImplThread");
     m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::setAnimationEvents, events.release(), wallClockTime));
 }
 
 void CCThreadProxy::releaseContentsTexturesOnImplThread()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
 
     if (m_layerTreeHost->contentsTextureManager()) 
         m_layerTreeHost->contentsTextureManager()->reduceMemoryOnImplThread(0, m_layerTreeHostImpl->resourceProvider());
@@ -364,7 +364,7 @@ void CCThreadProxy::releaseContentsTexturesOnImplThread()
 
 void CCThreadProxy::setNeedsRedraw()
 {
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     TRACE_EVENT0("cc", "CCThreadProxy::setNeedsRedraw");
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setFullRootLayerDamageOnImplThread));
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::setNeedsRedrawOnImplThread));
@@ -372,21 +372,21 @@ void CCThreadProxy::setNeedsRedraw()
 
 bool CCThreadProxy::commitRequested() const
 {
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     return m_commitRequested;
 }
 
 void CCThreadProxy::setNeedsRedrawOnImplThread()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     TRACE_EVENT0("cc", "CCThreadProxy::setNeedsRedrawOnImplThread");
     m_schedulerOnImplThread->setNeedsRedraw();
 }
 
 void CCThreadProxy::start()
 {
-    ASSERT(isMainThread());
-    ASSERT(CCProxy::implThread());
+    CC_DCHECK(isMainThread());
+    CC_DCHECK(CCProxy::implThread());
     // Create LayerTreeHostImpl.
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
@@ -400,8 +400,8 @@ void CCThreadProxy::start()
 void CCThreadProxy::stop()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::stop");
-    ASSERT(isMainThread());
-    ASSERT(m_started);
+    CC_DCHECK(isMainThread());
+    CC_DCHECK(m_started);
 
     // Synchronously deletes the impl.
     {
@@ -414,7 +414,7 @@ void CCThreadProxy::stop()
 
     m_mainThreadProxy->shutdown(); // Stop running tasks posted to us.
 
-    ASSERT(!m_layerTreeHostImpl.get()); // verify that the impl deleted.
+    CC_DCHECK(!m_layerTreeHostImpl.get()); // verify that the impl deleted.
     m_layerTreeHost = 0;
     m_started = false;
 }
@@ -438,7 +438,7 @@ void CCThreadProxy::forceSerializeOnSwapBuffersOnImplThread(CCCompletionEvent* c
 void CCThreadProxy::finishAllRenderingOnImplThread(CCCompletionEvent* completion)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::finishAllRenderingOnImplThread");
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_layerTreeHostImpl->finishAllRendering();
     completion->signal();
 }
@@ -446,7 +446,7 @@ void CCThreadProxy::finishAllRenderingOnImplThread(CCCompletionEvent* completion
 void CCThreadProxy::forceBeginFrameOnImplThread(CCCompletionEvent* completion)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::forceBeginFrameOnImplThread");
-    ASSERT(!m_beginFrameCompletionEventOnImplThread);
+    CC_DCHECK(!m_beginFrameCompletionEventOnImplThread);
 
     if (m_schedulerOnImplThread->commitPending()) {
         completion->signal();
@@ -460,7 +460,7 @@ void CCThreadProxy::forceBeginFrameOnImplThread(CCCompletionEvent* completion)
 void CCThreadProxy::scheduledActionBeginFrame()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionBeginFrame");
-    ASSERT(!m_pendingBeginFrameRequest);
+    CC_DCHECK(!m_pendingBeginFrameRequest);
     m_pendingBeginFrameRequest = make_scoped_ptr(new BeginFrameAndCommitState());
     m_pendingBeginFrameRequest->monotonicFrameBeginTime = monotonicallyIncreasingTime();
     m_pendingBeginFrameRequest->scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
@@ -480,7 +480,7 @@ void CCThreadProxy::scheduledActionBeginFrame()
 void CCThreadProxy::beginFrame()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::beginFrame");
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     if (!m_layerTreeHost)
         return;
 
@@ -588,10 +588,10 @@ void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion
     scoped_ptr<CCTextureUpdateQueue> queue(rawQueue);
 
     TRACE_EVENT0("cc", "CCThreadProxy::beginFrameCompleteOnImplThread");
-    ASSERT(!m_commitCompletionEventOnImplThread);
-    ASSERT(isImplThread() && isMainThreadBlocked());
-    ASSERT(m_schedulerOnImplThread);
-    ASSERT(m_schedulerOnImplThread->commitPending());
+    CC_DCHECK(!m_commitCompletionEventOnImplThread);
+    CC_DCHECK(isImplThread() && isMainThreadBlocked());
+    CC_DCHECK(m_schedulerOnImplThread);
+    CC_DCHECK(m_schedulerOnImplThread->commitPending());
 
     if (!m_layerTreeHostImpl.get()) {
         TRACE_EVENT0("cc", "EarlyOut_NoLayerTree");
@@ -620,9 +620,9 @@ void CCThreadProxy::beginFrameCompleteOnImplThread(CCCompletionEvent* completion
 void CCThreadProxy::beginFrameAbortedOnImplThread()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::beginFrameAbortedOnImplThread");
-    ASSERT(isImplThread());
-    ASSERT(m_schedulerOnImplThread);
-    ASSERT(m_schedulerOnImplThread->commitPending());
+    CC_DCHECK(isImplThread());
+    CC_DCHECK(m_schedulerOnImplThread);
+    CC_DCHECK(m_schedulerOnImplThread->commitPending());
 
     m_schedulerOnImplThread->beginFrameAborted();
 }
@@ -630,9 +630,9 @@ void CCThreadProxy::beginFrameAbortedOnImplThread()
 void CCThreadProxy::scheduledActionCommit()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::scheduledActionCommit");
-    ASSERT(isImplThread());
-    ASSERT(m_commitCompletionEventOnImplThread);
-    ASSERT(m_currentTextureUpdateControllerOnImplThread);
+    CC_DCHECK(isImplThread());
+    CC_DCHECK(m_commitCompletionEventOnImplThread);
+    CC_DCHECK(m_currentTextureUpdateControllerOnImplThread);
 
     // Complete all remaining texture updates.
     m_currentTextureUpdateControllerOnImplThread->finalize();
@@ -664,7 +664,7 @@ void CCThreadProxy::scheduledActionCommit()
 
 void CCThreadProxy::scheduledActionBeginContextRecreation()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_mainThreadProxy->postTask(createCCThreadTask(this, &CCThreadProxy::beginContextRecreation));
 }
 
@@ -674,12 +674,12 @@ CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapInte
     CCScheduledActionDrawAndSwapResult result;
     result.didDraw = false;
     result.didSwap = false;
-    ASSERT(isImplThread());
-    ASSERT(m_layerTreeHostImpl.get());
+    CC_DCHECK(isImplThread());
+    CC_DCHECK(m_layerTreeHostImpl.get());
     if (!m_layerTreeHostImpl.get())
         return result;
 
-    ASSERT(m_layerTreeHostImpl->renderer());
+    CC_DCHECK(m_layerTreeHostImpl->renderer());
     if (!m_layerTreeHostImpl->renderer())
         return result;
 
@@ -736,7 +736,7 @@ void CCThreadProxy::acquireLayerTextures()
     // This method will block until the next compositor draw if there is a
     // previously committed frame that is still undrawn. This is necessary to
     // ensure that the main thread does not monopolize access to the textures.
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
 
     if (m_texturesAcquired)
         return;
@@ -752,8 +752,8 @@ void CCThreadProxy::acquireLayerTextures()
 
 void CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEvent* completion)
 {
-    ASSERT(isImplThread());
-    ASSERT(!m_textureAcquisitionCompletionEventOnImplThread);
+    CC_DCHECK(isImplThread());
+    CC_DCHECK(!m_textureAcquisitionCompletionEventOnImplThread);
 
     m_textureAcquisitionCompletionEventOnImplThread = completion;
     m_schedulerOnImplThread->setMainThreadNeedsLayerTextures();
@@ -761,7 +761,7 @@ void CCThreadProxy::acquireLayerTexturesForMainThreadOnImplThread(CCCompletionEv
 
 void CCThreadProxy::scheduledActionAcquireLayerTexturesForMainThread()
 {
-    ASSERT(m_textureAcquisitionCompletionEventOnImplThread);
+    CC_DCHECK(m_textureAcquisitionCompletionEventOnImplThread);
     m_textureAcquisitionCompletionEventOnImplThread->signal();
     m_textureAcquisitionCompletionEventOnImplThread = 0;
 }
@@ -786,13 +786,13 @@ void CCThreadProxy::didAnticipatedDrawTimeChange(base::TimeTicks time)
 
 void CCThreadProxy::readyToFinalizeTextureUpdates()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_schedulerOnImplThread->beginFrameComplete();
 }
 
 void CCThreadProxy::didCommitAndDrawFrame()
 {
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     if (!m_layerTreeHost)
         return;
     m_layerTreeHost->didCommitAndDrawFrame();
@@ -800,7 +800,7 @@ void CCThreadProxy::didCommitAndDrawFrame()
 
 void CCThreadProxy::didCompleteSwapBuffers()
 {
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     if (!m_layerTreeHost)
         return;
     m_layerTreeHost->didCompleteSwapBuffers();
@@ -811,7 +811,7 @@ void CCThreadProxy::setAnimationEvents(CCAnimationEventsVector* passed_events, d
     scoped_ptr<CCAnimationEventsVector> events(make_scoped_ptr(passed_events));
 
     TRACE_EVENT0("cc", "CCThreadProxy::setAnimationEvents");
-    ASSERT(isMainThread());
+    CC_DCHECK(isMainThread());
     if (!m_layerTreeHost)
         return;
     m_layerTreeHost->setAnimationEvents(events.Pass(), wallClockTime);
@@ -839,8 +839,8 @@ private:
 void CCThreadProxy::beginContextRecreation()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::beginContextRecreation");
-    ASSERT(isMainThread());
-    ASSERT(!m_contextRecreationTimer);
+    CC_DCHECK(isMainThread());
+    CC_DCHECK(!m_contextRecreationTimer);
     m_contextRecreationTimer = CCThreadProxyContextRecreationTimer::create(this);
     m_layerTreeHost->didLoseContext();
     m_contextRecreationTimer->startOneShot(contextRecreationTickRate);
@@ -848,8 +848,8 @@ void CCThreadProxy::beginContextRecreation()
 
 void CCThreadProxy::tryToRecreateContext()
 {
-    ASSERT(isMainThread());
-    ASSERT(m_layerTreeHost);
+    CC_DCHECK(isMainThread());
+    CC_DCHECK(m_layerTreeHost);
     CCLayerTreeHost::RecreateResult result = m_layerTreeHost->recreateContext();
     if (result == CCLayerTreeHost::RecreateFailedButTryAgain)
         m_contextRecreationTimer->startOneShot(contextRecreationTickRate);
@@ -860,7 +860,7 @@ void CCThreadProxy::tryToRecreateContext()
 void CCThreadProxy::initializeImplOnImplThread(CCCompletionEvent* completion, CCInputHandler* handler)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeImplOnImplThread");
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl(this);
     const base::TimeDelta displayRefreshInterval = base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond / 60);
     scoped_ptr<CCFrameRateController> frameRateController;
@@ -881,15 +881,15 @@ void CCThreadProxy::initializeImplOnImplThread(CCCompletionEvent* completion, CC
 void CCThreadProxy::initializeContextOnImplThread(CCGraphicsContext* context)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeContextOnImplThread");
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_contextBeforeInitializationOnImplThread = scoped_ptr<CCGraphicsContext>(context).Pass();
 }
 
 void CCThreadProxy::initializeRendererOnImplThread(CCCompletionEvent* completion, bool* initializeSucceeded, RendererCapabilities* capabilities)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeRendererOnImplThread");
-    ASSERT(isImplThread());
-    ASSERT(m_contextBeforeInitializationOnImplThread.get());
+    CC_DCHECK(isImplThread());
+    CC_DCHECK(m_contextBeforeInitializationOnImplThread.get());
     *initializeSucceeded = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitializationOnImplThread.Pass());
     if (*initializeSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
@@ -903,7 +903,7 @@ void CCThreadProxy::initializeRendererOnImplThread(CCCompletionEvent* completion
 void CCThreadProxy::layerTreeHostClosedOnImplThread(CCCompletionEvent* completion)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::layerTreeHostClosedOnImplThread");
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     m_inputHandlerOnImplThread.reset();
     m_layerTreeHostImpl.reset();
@@ -913,7 +913,7 @@ void CCThreadProxy::layerTreeHostClosedOnImplThread(CCCompletionEvent* completio
 
 void CCThreadProxy::setFullRootLayerDamageOnImplThread()
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_layerTreeHostImpl->setFullRootLayerDamage();
 }
 
@@ -925,7 +925,7 @@ size_t CCThreadProxy::maxPartialTextureUpdates() const
 void CCThreadProxy::recreateContextOnImplThread(CCCompletionEvent* completion, CCGraphicsContext* contextPtr, bool* recreateSucceeded, RendererCapabilities* capabilities)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::recreateContextOnImplThread");
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(scoped_ptr<CCGraphicsContext>(contextPtr).Pass());
     if (*recreateSucceeded) {
@@ -937,7 +937,7 @@ void CCThreadProxy::recreateContextOnImplThread(CCCompletionEvent* completion, C
 
 void CCThreadProxy::renderingStatsOnImplThread(CCCompletionEvent* completion, CCRenderingStats* stats)
 {
-    ASSERT(isImplThread());
+    CC_DCHECK(isImplThread());
     m_layerTreeHostImpl->renderingStats(stats);
     completion->signal();
 }