cc: Switch to Chromium DCHECKs LOGs

cc/scheduler_state_machine.cc

 // 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"
 
 #include "CCSchedulerStateMachine.h"
+#include "base/logging.h"
 #include "base/stringprintf.h"
 
-
 namespace cc {
 
 CCSchedulerStateMachine::CCSchedulerStateMachine()
     : m_commitState(COMMIT_STATE_IDLE)
     , m_currentFrameNumber(0)
     , m_lastFrameNumberWhereDrawWasCalled(-1)
     , m_consecutiveFailedDraws(0)
     , m_maximumNumberOfFailedDrawsBeforeDrawIsForced(3)
     , m_needsRedraw(false)
     , m_needsForcedRedraw(false)
@@ skipping 75 matching lines @@
         return false;
     return true;
 }
 
 bool CCSchedulerStateMachine::shouldAcquireLayerTexturesForMainThread() const
 {
     if (!m_mainThreadNeedsLayerTextures)
         return false;
     if (m_textureState == LAYER_TEXTURE_STATE_UNLOCKED)
         return true;
-    ASSERT(m_textureState == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD);
+    DCHECK(m_textureState == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD);
     // Transfer the lock from impl thread to main thread immediately if the
     // impl thread is not even scheduled to draw. Guards against deadlocking.
     if (!scheduledToDraw())
         return true;
     if (!vsyncCallbackNeeded())
         return true;
     return false;
 }
 
 CCSchedulerStateMachine::Action CCSchedulerStateMachine::nextAction() const
@@ skipping 27 matching lines @@
     case COMMIT_STATE_WAITING_FOR_FIRST_DRAW:
         if (shouldDraw() || m_contextState == CONTEXT_LOST)
             return m_needsForcedRedraw ? ACTION_DRAW_FORCED : ACTION_DRAW_IF_POSSIBLE;
         // COMMIT_STATE_WAITING_FOR_FIRST_DRAW wants to enforce a draw. If m_canDraw is false
         // or textures are not available, proceed to the next step (similar as in COMMIT_STATE_IDLE).
         bool canCommit = m_visible || m_needsForcedCommit;
         if (m_needsCommit && canCommit && drawSuspendedUntilCommit())
             return ACTION_BEGIN_FRAME;
         return ACTION_NONE;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return ACTION_NONE;
 }
 
 void CCSchedulerStateMachine::updateState(Action action)
 {
     switch (action) {
     case ACTION_NONE:
         return;
 
     case ACTION_BEGIN_FRAME:
-        ASSERT(m_visible || m_needsForcedCommit);
+        DCHECK(m_visible || m_needsForcedCommit);
         m_commitState = COMMIT_STATE_FRAME_IN_PROGRESS;
         m_needsCommit = false;
         m_needsForcedCommit = false;
         return;
 
     case ACTION_COMMIT:
         m_commitState = COMMIT_STATE_WAITING_FOR_FIRST_DRAW;
         m_needsRedraw = true;
         if (m_drawIfPossibleFailed)
             m_lastFrameNumberWhereDrawWasCalled = -1;
@@ skipping 13 matching lines @@
         m_drawIfPossibleFailed = false;
         if (m_insideVSync)
             m_lastFrameNumberWhereDrawWasCalled = m_currentFrameNumber;
         if (m_commitState == COMMIT_STATE_WAITING_FOR_FIRST_DRAW)
             m_commitState = COMMIT_STATE_IDLE;
         if (m_textureState == LAYER_TEXTURE_STATE_ACQUIRED_BY_IMPL_THREAD)
             m_textureState = LAYER_TEXTURE_STATE_UNLOCKED;
         return;
 
     case ACTION_BEGIN_CONTEXT_RECREATION:
-        ASSERT(m_commitState == COMMIT_STATE_IDLE);
-        ASSERT(m_contextState == CONTEXT_LOST);
+        DCHECK(m_commitState == COMMIT_STATE_IDLE);
+        DCHECK(m_contextState == CONTEXT_LOST);
         m_contextState = CONTEXT_RECREATING;
         return;
 
     case ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
         m_textureState = LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD;
         m_mainThreadNeedsLayerTextures = false;
         if (m_commitState != COMMIT_STATE_FRAME_IN_PROGRESS)
             m_needsCommit = true;
         return;
     }
 }
 
 void CCSchedulerStateMachine::setMainThreadNeedsLayerTextures()
 {
-    ASSERT(!m_mainThreadNeedsLayerTextures);
-    ASSERT(m_textureState != LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
+    DCHECK(!m_mainThreadNeedsLayerTextures);
+    DCHECK(m_textureState != LAYER_TEXTURE_STATE_ACQUIRED_BY_MAIN_THREAD);
     m_mainThreadNeedsLayerTextures = true;
 }
 
 bool CCSchedulerStateMachine::vsyncCallbackNeeded() const
 {
     // If we can't draw, don't tick until we are notified that we can draw again.
     if (!m_canDraw)
         return false;
 
     if (m_needsForcedRedraw)
@@ skipping 50 matching lines @@
     m_needsCommit = true;
 }
 
 void CCSchedulerStateMachine::setNeedsForcedCommit()
 {
     m_needsForcedCommit = true;
 }
 
 void CCSchedulerStateMachine::beginFrameComplete()
 {
-    ASSERT(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
+    DCHECK(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
     m_commitState = COMMIT_STATE_READY_TO_COMMIT;
 }
 
 void CCSchedulerStateMachine::beginFrameAborted()
 {
-    ASSERT(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
+    DCHECK(m_commitState == COMMIT_STATE_FRAME_IN_PROGRESS);
     m_commitState = COMMIT_STATE_IDLE;
     setNeedsCommit();
 }
 
 void CCSchedulerStateMachine::didLoseContext()
 {
     if (m_contextState == CONTEXT_LOST || m_contextState == CONTEXT_RECREATING)
         return;
     m_contextState = CONTEXT_LOST;
 }
 
 void CCSchedulerStateMachine::didRecreateContext()
 {
-    ASSERT(m_contextState == CONTEXT_RECREATING);
+    DCHECK(m_contextState == CONTEXT_RECREATING);
     m_contextState = CONTEXT_ACTIVE;
     setNeedsCommit();
 }
 
 void CCSchedulerStateMachine::setMaximumNumberOfFailedDrawsBeforeDrawIsForced(int numDraws)
 {
     m_maximumNumberOfFailedDrawsBeforeDrawIsForced = numDraws;
 }
 
 }