cc: Switch to Chromium DCHECKs LOGs

cc/delay_based_time_source.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 "CCDelayBasedTimeSource.h"
 
 #include "base/debug/trace_event.h"
+#include "base/logging.h"
 #include <algorithm>
 #include <wtf/CurrentTime.h>
 #include <wtf/MathExtras.h>
 
 namespace cc {
 
 namespace {
 
 // doubleTickThreshold prevents ticks from running within the specified fraction of an interval.
 // This helps account for jitter in the timebase as well as quick timer reactivation.
@@ skipping 63 matching lines @@
     return m_lastTickTime;
 }
 
 base::TimeTicks CCDelayBasedTimeSource::nextTickTime()
 {
     return active() ? m_currentParameters.tickTarget : base::TimeTicks();
 }
 
 void CCDelayBasedTimeSource::onTimerFired()
 {
-    ASSERT(m_state != STATE_INACTIVE);
+    DCHECK(m_state != STATE_INACTIVE);
 
     base::TimeTicks now = this->now();
     m_lastTickTime = now;
 
     if (m_state == STATE_STARTING) {
         setTimebaseAndInterval(now, m_currentParameters.interval);
         m_state = STATE_ACTIVE;
     }
 
     postNextTickTask(now);
@@ skipping 91 matching lines @@
 // This brings us back to 18+15 = 33, which was where we would have been if the task hadn't been late.
 //
 // For the really late delay, we we move to the next logical tick. The timebase is not reset.
 //      now=37   tickTarget=16.667  newTarget=50.000  --> tick(), postDelayedTask(floor(50.000-37)) --> postDelayedTask(13)
 base::TimeTicks CCDelayBasedTimeSource::nextTickTarget(base::TimeTicks now)
 {
     base::TimeDelta newInterval = m_nextParameters.interval;
     int intervalsElapsed = static_cast<int>(floor((now - m_nextParameters.tickTarget).InSecondsF() / newInterval.InSecondsF()));
     base::TimeTicks lastEffectiveTick = m_nextParameters.tickTarget + newInterval * intervalsElapsed;
     base::TimeTicks newTickTarget = lastEffectiveTick + newInterval;
-    ASSERT(newTickTarget > now);
+    DCHECK(newTickTarget > now);
 
     // Avoid double ticks when:
     // 1) Turning off the timer and turning it right back on.
     // 2) Jittery data is passed to setTimebaseAndInterval().
     if (newTickTarget - m_lastTickTime <= newInterval / static_cast<int>(1.0 / doubleTickThreshold))
         newTickTarget += newInterval;
 
     return newTickTarget;
 }
 
 void CCDelayBasedTimeSource::postNextTickTask(base::TimeTicks now)
 {
     base::TimeTicks newTickTarget = nextTickTarget(now);
 
     // Post another task *before* the tick and update state
     base::TimeDelta delay = newTickTarget - now;
-    ASSERT(delay.InMillisecondsF() <=
+    DCHECK(delay.InMillisecondsF() <=
            m_nextParameters.interval.InMillisecondsF() * (1.0 + doubleTickThreshold));
     m_timer.startOneShot(delay.InSecondsF());
 
     m_nextParameters.tickTarget = newTickTarget;
     m_currentParameters = m_nextParameters;
 }
 
 }  // namespace cc