Remove WebKit::Platform dependencies from cc

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 "cc/delay_based_time_source.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
+#include "base/message_loop.h"
+#include "cc/thread.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.
 const double doubleTickThreshold = 0.25;
 
 // 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<DelayBasedTimeSource> DelayBasedTimeSource::create(base::TimeDelta interval, Thread* thread)
 {
     return make_scoped_refptr(new DelayBasedTimeSource(interval, 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)
+    , m_thread(thread)
+    , m_weakFactory(ALLOW_THIS_IN_INITIALIZER_LIST(this))
 {
 }
 
 DelayBasedTimeSource::~DelayBasedTimeSource()
 {
 }
 
 void DelayBasedTimeSource::setActive(bool active)
 {
     TRACE_EVENT1("cc", "DelayBasedTimeSource::setActive", "active", active);
     if (!active) {
         m_state = STATE_INACTIVE;
-        m_timer.stop();
+        m_weakFactory.InvalidateWeakPtrs();
         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);
+        m_thread->postTask(base::Bind(&DelayBasedTimeSource::onTimerFired, m_weakFactory.GetWeakPtr()));
         return;
     }
 
     m_state = STATE_ACTIVE;
 
     postNextTickTask(now());
 }
 
 bool DelayBasedTimeSource::active() const
 {
@@ skipping 136 matching lines @@
 }
 
 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;
     DCHECK(delay.InMillisecondsF() <=
            m_nextParameters.interval.InMillisecondsF() * (1.0 + doubleTickThreshold));
-    m_timer.startOneShot(delay.InSecondsF());
+    m_thread->postDelayedTask(base::Bind(&DelayBasedTimeSource::onTimerFired,
+                                         m_weakFactory.GetWeakPtr()),
+                              delay.InMilliseconds());
 
     m_nextParameters.tickTarget = newTickTarget;
     m_currentParameters = m_nextParameters;
 }
 
 }  // namespace cc