media/cast/test/fake_single_thread_task_runner.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/cast/test/fake_single_thread_task_runner.h"
   6
   7 #include "base/logging.h"
   8 #include "base/time/tick_clock.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace media {
  12 namespace cast {
  13 namespace test {
  14
  15 FakeSingleThreadTaskRunner::FakeSingleThreadTaskRunner(
  16     base::SimpleTestTickClock* clock)
  17     : clock_(clock),
  18       fail_on_next_task_(false) {}
  19
  20 FakeSingleThreadTaskRunner::~FakeSingleThreadTaskRunner() {}
  21
  22 bool FakeSingleThreadTaskRunner::PostDelayedTask(
  23     const tracked_objects::Location& from_here,
  24     const base::Closure& task,
  25     base::TimeDelta delay) {
  26   if (fail_on_next_task_) {
  27     LOG(FATAL) << "Infinite task-add loop detected.";
  28   }
  29   CHECK(delay >= base::TimeDelta());
  30   EXPECT_GE(delay, base::TimeDelta());
  31   PostedTask posed_task(from_here,
  32                         task,
  33                         clock_->NowTicks(),
  34                         delay,
  35                         base::TestPendingTask::NESTABLE);
  36
  37   tasks_.insert(std::make_pair(posed_task.GetTimeToRun(), posed_task));
  38   return false;
  39 }
  40
  41 bool FakeSingleThreadTaskRunner::RunsTasksOnCurrentThread() const {
  42   return true;
  43 }
  44
  45 void FakeSingleThreadTaskRunner::RunTasks() {
  46   while (true) {
  47     // Run all tasks equal or older than current time.
  48     std::multimap<base::TimeTicks, PostedTask>::iterator it = tasks_.begin();
  49     if (it == tasks_.end())
  50       return;  // No more tasks.
  51
  52     PostedTask task = it->second;
  53     if (clock_->NowTicks() < task.GetTimeToRun())
  54       return;
  55
  56     tasks_.erase(it);
  57     task.task.Run();
  58   }
  59 }
  60
  61 void FakeSingleThreadTaskRunner::Sleep(base::TimeDelta t) {
  62   base::TimeTicks run_until = clock_->NowTicks() + t;
  63   while (1) {
  64     // If we run more than 100000 iterations, we've probably
  65     // hit some sort of case where a new task is posted every
  66     // time that we invoke a task, and we can't make progress
  67     // anymore. If that happens, set fail_on_next_task_ to true
  68     // and throw an error when the next task is posted.
  69     for (int i = 0; i < 100000; i++) {
  70       // Run all tasks equal or older than current time.
  71       std::multimap<base::TimeTicks, PostedTask>::iterator it = tasks_.begin();
  72       if (it == tasks_.end()) {
  73         clock_->Advance(run_until - clock_->NowTicks());
  74         return;
  75       }
  76
  77       PostedTask task = it->second;
  78       if (run_until < task.GetTimeToRun()) {
  79         clock_->Advance(run_until - clock_->NowTicks());
  80         return;
  81       }
  82
  83       clock_->Advance(task.GetTimeToRun() - clock_->NowTicks());
  84       tasks_.erase(it);
  85       task.task.Run();
  86     }
  87     // Instead of failing immediately, we fail when the next task is
  88     // added so that the backtrace will include the task that was added.
  89     fail_on_next_task_ = true;
  90   }
  91 }
  92
  93 bool FakeSingleThreadTaskRunner::PostNonNestableDelayedTask(
  94     const tracked_objects::Location& from_here,
  95     const base::Closure& task,
  96     base::TimeDelta delay) {
  97   NOTIMPLEMENTED();
  98   return false;
  99 }
 100
 101 }  // namespace test
 102 }  // namespace cast
 103 }  // namespace media