cc: Remove FakeThread, use SingleThreadTaskRunner in scheduling classes.

cc/scheduler/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 "cc/scheduler/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/base/thread.h"
+#include "base/single_thread_task_runner.h"
 
 namespace cc {
 
 namespace {
 
 // kDoubleTickThreshold 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.
 static const double kDoubleTickThreshold = 0.25;
 
 // kIntervalChangeThreshold is the fraction of the interval that will trigger an
 // immediate interval change.  kPhaseChangeThreshold 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.
 static const double kIntervalChangeThreshold = 0.25;
 static const double kPhaseChangeThreshold = 0.25;
 
 }  // namespace
 
 scoped_refptr<DelayBasedTimeSource> DelayBasedTimeSource::Create(
     base::TimeDelta interval,
-    Thread* thread) {
-  return make_scoped_refptr(new DelayBasedTimeSource(interval, thread));
+    base::SingleThreadTaskRunner* task_runner) {
+  return make_scoped_refptr(new DelayBasedTimeSource(interval, task_runner));
 }
 
-DelayBasedTimeSource::DelayBasedTimeSource(base::TimeDelta interval,
-                                           Thread* thread)
+DelayBasedTimeSource::DelayBasedTimeSource(
+    base::TimeDelta interval, base::SingleThreadTaskRunner* task_runner)
     : client_(NULL),
       has_tick_target_(false),
       current_parameters_(interval, base::TimeTicks()),
       next_parameters_(interval, base::TimeTicks()),
       state_(STATE_INACTIVE),
-      thread_(thread),
+      task_runner_(task_runner),
       weak_factory_(this) {}
 
 DelayBasedTimeSource::~DelayBasedTimeSource() {}
 
 void DelayBasedTimeSource::SetActive(bool active) {
   TRACE_EVENT1("cc", "DelayBasedTimeSource::SetActive", "active", active);
   if (!active) {
     state_ = STATE_INACTIVE;
     weak_factory_.InvalidateWeakPtrs();
     return;
   }
 
   if (state_ == STATE_STARTING || state_ == STATE_ACTIVE)
     return;
 
   if (!has_tick_target_) {
     // 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.
     state_ = STATE_STARTING;
-    thread_->PostTask(base::Bind(&DelayBasedTimeSource::OnTimerFired,
-                                 weak_factory_.GetWeakPtr()));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&DelayBasedTimeSource::OnTimerFired,
+                                      weak_factory_.GetWeakPtr()));
     return;
   }
 
   state_ = STATE_ACTIVE;
 
   PostNextTickTask(Now());
 }
 
 bool DelayBasedTimeSource::Active() const { return state_ != STATE_INACTIVE; }
 
@@ skipping 150 matching lines @@
 }
 
 void DelayBasedTimeSource::PostNextTickTask(base::TimeTicks now) {
   base::TimeTicks new_tick_target = NextTickTarget(now);
 
   // Post another task *before* the tick and update state
   base::TimeDelta delay = new_tick_target - now;
   DCHECK(delay.InMillisecondsF() <=
          next_parameters_.interval.InMillisecondsF() *
          (1.0 + kDoubleTickThreshold));
-  thread_->PostDelayedTask(base::Bind(&DelayBasedTimeSource::OnTimerFired,
-                                      weak_factory_.GetWeakPtr()),
-                           delay);
+  task_runner_->PostDelayedTask(FROM_HERE,
+                                base::Bind(&DelayBasedTimeSource::OnTimerFired,
+                                           weak_factory_.GetWeakPtr()),
+                                delay);
 
   next_parameters_.tick_target = new_tick_target;
   current_parameters_ = next_parameters_;
 }
 
 }  // namespace cc