Fix remaining cc files to compile with Clang

cc/CCDelayBasedTimeSource.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"
 
 #include "CCDelayBasedTimeSource.h"
 
 #include "TraceEvent.h"
 #include <algorithm>
@@ skipping 27 matching lines @@
     : m_client(0)
     , m_hasTickTarget(false)
     , m_currentParameters(interval, base::TimeTicks())
     , m_nextParameters(interval, base::TimeTicks())
     , m_state(STATE_INACTIVE)
     , m_timer(thread, this)
 {
     turnOffVerifier();
 }
 
+CCDelayBasedTimeSource::~CCDelayBasedTimeSource()
+{
+}
+
 void CCDelayBasedTimeSource::setActive(bool active)
 {
     TRACE_EVENT1("cc", "CCDelayBasedTimeSource::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
+{
+    return m_state != STATE_INACTIVE;
+}
+
 base::TimeTicks CCDelayBasedTimeSource::lastTickTime()
 {
     return m_lastTickTime;
 }
 
 base::TimeTicks CCDelayBasedTimeSource::nextTickTimeIfActivated()
 {
     return active() ? m_currentParameters.tickTarget : nextTickTarget(now());
 }
 
 void CCDelayBasedTimeSource::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)
+{
+    m_client = client;
+}
+
 void CCDelayBasedTimeSource::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 96 matching lines @@
     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;
 }
 
 }