cc: Rename cc classes and members to match filenames

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 "TraceEvent.h"
 #include <algorithm>
@@ skipping 10 matching lines @@
 
 // intervalChangeThreshold is the fraction of the interval that will trigger an immediate interval change.
 // phaseChangeThreshold is the fraction of the interval that will trigger an immediate phase change.
 // If the changes are within the thresholds, the change will take place on the next tick.
 // If either change is outside the thresholds, the next tick will be canceled and reissued immediately.
 const double intervalChangeThreshold = 0.25;
 const double phaseChangeThreshold = 0.25;
 
 }  // namespace
 
-scoped_refptr<CCDelayBasedTimeSource> CCDelayBasedTimeSource::create(base::TimeDelta interval, CCThread* thread)
+scoped_refptr<DelayBasedTimeSource> DelayBasedTimeSource::create(base::TimeDelta interval, Thread* thread)
 {
-    return make_scoped_refptr(new CCDelayBasedTimeSource(interval, thread));
+    return make_scoped_refptr(new DelayBasedTimeSource(interval, thread));
 }
 
-CCDelayBasedTimeSource::CCDelayBasedTimeSource(base::TimeDelta interval, CCThread* thread)
+DelayBasedTimeSource::DelayBasedTimeSource(base::TimeDelta interval, Thread* thread)
     : m_client(0)
     , m_hasTickTarget(false)
     , m_currentParameters(interval, base::TimeTicks())
     , m_nextParameters(interval, base::TimeTicks())
     , m_state(STATE_INACTIVE)
     , m_timer(thread, this)
 {
 }
 
-CCDelayBasedTimeSource::~CCDelayBasedTimeSource()
+DelayBasedTimeSource::~DelayBasedTimeSource()
 {
 }
 
-void CCDelayBasedTimeSource::setActive(bool active)
+void DelayBasedTimeSource::setActive(bool active)
 {
-    TRACE_EVENT1("cc", "CCDelayBasedTimeSource::setActive", "active", active);
+    TRACE_EVENT1("cc", "DelayBasedTimeSource::setActive", "active", active);
     if (!active) {
         m_state = STATE_INACTIVE;
         m_timer.stop();
         return;
     }
 
     if (m_state == STATE_STARTING || m_state == STATE_ACTIVE)
         return;
 
     if (!m_hasTickTarget) {
         // Becoming active the first time is deferred: we post a 0-delay task. When
         // it runs, we use that to establish the timebase, become truly active, and
         // fire the first tick.
         m_state = STATE_STARTING;
         m_timer.startOneShot(0);
         return;
     }
 
     m_state = STATE_ACTIVE;
 
     postNextTickTask(now());
 }
 
-bool CCDelayBasedTimeSource::active() const
+bool DelayBasedTimeSource::active() const
 {
     return m_state != STATE_INACTIVE;
 }
 
-base::TimeTicks CCDelayBasedTimeSource::lastTickTime()
+base::TimeTicks DelayBasedTimeSource::lastTickTime()
 {
     return m_lastTickTime;
 }
 
-base::TimeTicks CCDelayBasedTimeSource::nextTickTime()
+base::TimeTicks DelayBasedTimeSource::nextTickTime()
 {
     return active() ? m_currentParameters.tickTarget : base::TimeTicks();
 }
 
-void CCDelayBasedTimeSource::onTimerFired()
+void DelayBasedTimeSource::onTimerFired()
 {
     ASSERT(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);
 
     // Fire the tick
     if (m_client)
         m_client->onTimerTick();
 }
 
-void CCDelayBasedTimeSource::setClient(CCTimeSourceClient* client)
+void DelayBasedTimeSource::setClient(TimeSourceClient* client)
 {
     m_client = client;
 }
 
-void CCDelayBasedTimeSource::setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval)
+void DelayBasedTimeSource::setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval)
 {
     m_nextParameters.interval = interval;
     m_nextParameters.tickTarget = timebase;
     m_hasTickTarget = true;
 
     if (m_state != STATE_ACTIVE) {
         // If we aren't active, there's no need to reset the timer.
         return;
     }
 
@@ skipping 15 matching lines @@
     // old clock and new clock just happen to line up.
     double targetDelta = std::abs((timebase - m_currentParameters.tickTarget).InSecondsF());
     double phaseChange = fmod(targetDelta, interval.InSecondsF()) / interval.InSecondsF();
     if (phaseChange > phaseChangeThreshold && phaseChange < (1.0 - phaseChangeThreshold)) {
         setActive(false);
         setActive(true);
         return;
     }
 }
 
-base::TimeTicks CCDelayBasedTimeSource::now() const
+base::TimeTicks DelayBasedTimeSource::now() const
 {
     return base::TimeTicks::Now();
 }
 
 // This code tries to achieve an average tick rate as close to m_interval as possible.
 // To do this, it has to deal with a few basic issues:
 //   1. postDelayedTask can delay only at a millisecond granularity. So, 16.666 has to
 //      posted as 16 or 17.
 //   2. A delayed task may come back a bit late (a few ms), or really late (frames later)
 //
@@ skipping 27 matching lines @@
 //   Case 2: so late we obviously missed the tick
 //      now=25.0 tickTarget=16.667
 //
 // We treat the first case as a tick anyway, and assume the delay was
 // unusual. Thus, we compute the newTarget based on the old timebase:
 //      now=18   tickTarget=16.667  newTarget=33.333   --> tick(), postDelayedTask(floor(33.333-18)) --> postDelayedTask(15)
 // 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::TimeTicks DelayBasedTimeSource::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);
 
     // 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)
+void DelayBasedTimeSource::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() <=
            m_nextParameters.interval.InMillisecondsF() * (1.0 + doubleTickThreshold));
     m_timer.startOneShot(delay.InSecondsF());
 
     m_nextParameters.tickTarget = newTickTarget;
     m_currentParameters = m_nextParameters;
 }
 
 }  // namespace cc