OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/task_scheduler/delayed_task_manager.h" | 5 #include "base/task_scheduler/delayed_task_manager.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/bind.h" | 10 #include "base/bind.h" |
(...skipping 24 matching lines...) Expand all Loading... |
35 DoPostTaskNowCallback(task.get()); | 35 DoPostTaskNowCallback(task.get()); |
36 } | 36 } |
37 | 37 |
38 private: | 38 private: |
39 DISALLOW_COPY_AND_ASSIGN(MockTaskTarget); | 39 DISALLOW_COPY_AND_ASSIGN(MockTaskTarget); |
40 }; | 40 }; |
41 | 41 |
42 class TaskSchedulerDelayedTaskManagerTest : public testing::Test { | 42 class TaskSchedulerDelayedTaskManagerTest : public testing::Test { |
43 public: | 43 public: |
44 TaskSchedulerDelayedTaskManagerTest() | 44 TaskSchedulerDelayedTaskManagerTest() |
45 : service_thread_task_runner_(new TestMockTimeTaskRunner), | 45 : delayed_task_manager_(service_thread_task_runner_->GetMockTickClock()) { |
46 delayed_task_manager_(service_thread_task_runner_) {} | 46 } |
47 ~TaskSchedulerDelayedTaskManagerTest() override = default; | 47 ~TaskSchedulerDelayedTaskManagerTest() override = default; |
48 | 48 |
49 protected: | 49 protected: |
50 scoped_refptr<TestMockTimeTaskRunner> service_thread_task_runner_; | 50 std::unique_ptr<Task> CreateTask(TimeDelta delay) { |
| 51 auto task = |
| 52 MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(), delay); |
| 53 |
| 54 // The constructor of Task computes |delayed_run_time| by adding |delay| to |
| 55 // the real time. Recompute it by adding |delay| to the mock time. |
| 56 task->delayed_run_time = |
| 57 service_thread_task_runner_->GetMockTickClock()->NowTicks() + delay; |
| 58 |
| 59 return task; |
| 60 } |
| 61 |
| 62 testing::StrictMock<MockTaskTarget> task_target_; |
| 63 const scoped_refptr<TestMockTimeTaskRunner> service_thread_task_runner_ = |
| 64 make_scoped_refptr(new TestMockTimeTaskRunner); |
51 DelayedTaskManager delayed_task_manager_; | 65 DelayedTaskManager delayed_task_manager_; |
| 66 std::unique_ptr<Task> task_ = CreateTask(kLongDelay); |
| 67 Task* const task_raw_ = task_.get(); |
52 | 68 |
53 private: | 69 private: |
54 DISALLOW_COPY_AND_ASSIGN(TaskSchedulerDelayedTaskManagerTest); | 70 DISALLOW_COPY_AND_ASSIGN(TaskSchedulerDelayedTaskManagerTest); |
55 }; | 71 }; |
56 | 72 |
57 } // namespace | 73 } // namespace |
58 | 74 |
59 // Verify that a delayed task isn't forwarded before it is ripe for execution. | 75 // Verify that a delayed task isn't forwarded before Start(). |
| 76 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskDoesNotRunBeforeStart) { |
| 77 // Send |task| to the DelayedTaskManager. |
| 78 delayed_task_manager_.AddDelayedTask( |
| 79 std::move(task_), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
| 80 Unretained(&task_target_))); |
| 81 |
| 82 // Fast-forward time until the task is ripe for execution. Since Start() has |
| 83 // not been called, the task should be forwarded to |task_target_| |
| 84 // (|task_target_| is a StrictMock without expectations, so the test will fail |
| 85 // if the task is forwarded to it). |
| 86 service_thread_task_runner_->FastForwardBy(kLongDelay); |
| 87 } |
| 88 |
| 89 // Verify that a delayed task added before Start() and whose delay expires after |
| 90 // Start() is forwarded when its delay expires. |
| 91 TEST_F(TaskSchedulerDelayedTaskManagerTest, |
| 92 DelayedTaskPostedBeforeStartExpiresAfterStartRunsOnExpire) { |
| 93 // Send |task| to the DelayedTaskManager. |
| 94 delayed_task_manager_.AddDelayedTask( |
| 95 std::move(task_), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
| 96 Unretained(&task_target_))); |
| 97 |
| 98 delayed_task_manager_.Start(service_thread_task_runner_); |
| 99 |
| 100 // Run tasks on the service thread. Don't expect any forwarding to |
| 101 // |task_target_| since the task isn't ripe for execution. |
| 102 service_thread_task_runner_->RunUntilIdle(); |
| 103 |
| 104 // Fast-forward time until the task is ripe for execution. Expect the task to |
| 105 // be forwarded to |task_target_|. |
| 106 EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_raw_)); |
| 107 service_thread_task_runner_->FastForwardBy(kLongDelay); |
| 108 } |
| 109 |
| 110 // Verify that a delayed task added before Start() and whose delay expires |
| 111 // before Start() is forwarded when Start() is called. |
| 112 TEST_F(TaskSchedulerDelayedTaskManagerTest, |
| 113 DelayedTaskPostedBeforeStartExpiresBeforeStartRunsOnStart) { |
| 114 // Send |task| to the DelayedTaskManager. |
| 115 delayed_task_manager_.AddDelayedTask( |
| 116 std::move(task_), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
| 117 Unretained(&task_target_))); |
| 118 |
| 119 // Run tasks on the service thread. Don't expect any forwarding to |
| 120 // |task_target_| since the task isn't ripe for execution. |
| 121 service_thread_task_runner_->RunUntilIdle(); |
| 122 |
| 123 // Fast-forward time until the task is ripe for execution. Don't expect the |
| 124 // task to be forwarded since Start() hasn't been called yet. |
| 125 service_thread_task_runner_->FastForwardBy(kLongDelay); |
| 126 |
| 127 // Start the DelayedTaskManager. Expect the task to be forwarded to |
| 128 // |task_target_|. |
| 129 EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_raw_)); |
| 130 delayed_task_manager_.Start(service_thread_task_runner_); |
| 131 service_thread_task_runner_->RunUntilIdle(); |
| 132 } |
| 133 |
| 134 // Verify that a delayed task added after Start() isn't forwarded before it is |
| 135 // ripe for execution. |
60 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskDoesNotRunTooEarly) { | 136 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskDoesNotRunTooEarly) { |
61 auto task = | 137 delayed_task_manager_.Start(service_thread_task_runner_); |
62 MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), TaskTraits(), kLongDelay); | |
63 | |
64 testing::StrictMock<MockTaskTarget> task_target; | |
65 | 138 |
66 // Send |task| to the DelayedTaskManager. | 139 // Send |task| to the DelayedTaskManager. |
67 delayed_task_manager_.AddDelayedTask( | 140 delayed_task_manager_.AddDelayedTask( |
68 std::move(task), | 141 std::move(task_), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
69 Bind(&MockTaskTarget::PostTaskNowCallback, Unretained(&task_target))); | 142 Unretained(&task_target_))); |
70 | 143 |
71 // Run tasks that are ripe for execution. Don't expect any forwarding to | 144 // Run tasks that are ripe for execution. Don't expect any forwarding to |
72 // |task_target|. | 145 // |task_target_|. |
73 service_thread_task_runner_->RunUntilIdle(); | 146 service_thread_task_runner_->RunUntilIdle(); |
74 } | 147 } |
75 | 148 |
76 // Verify that a delayed task is forwarded when it is ripe for execution. | 149 // Verify that a delayed task added after Start() is forwarded when it is ripe |
| 150 // for execution. |
77 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskRunsAfterDelay) { | 151 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTaskRunsAfterDelay) { |
78 auto task = | 152 delayed_task_manager_.Start(service_thread_task_runner_); |
79 MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), TaskTraits(), kLongDelay); | |
80 const Task* task_raw = task.get(); | |
81 | |
82 testing::StrictMock<MockTaskTarget> task_target; | |
83 | 153 |
84 // Send |task| to the DelayedTaskManager. | 154 // Send |task| to the DelayedTaskManager. |
85 delayed_task_manager_.AddDelayedTask( | 155 delayed_task_manager_.AddDelayedTask( |
86 std::move(task), | 156 std::move(task_), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
87 Bind(&MockTaskTarget::PostTaskNowCallback, Unretained(&task_target))); | 157 Unretained(&task_target_))); |
88 | 158 |
89 // Fast-forward time. Expect the task is forwarded to |task_target|. | 159 // Fast-forward time. Expect the task is forwarded to |task_target_|. |
90 EXPECT_CALL(task_target, DoPostTaskNowCallback(task_raw)); | 160 EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_raw_)); |
91 service_thread_task_runner_->FastForwardBy(kLongDelay); | 161 service_thread_task_runner_->FastForwardBy(kLongDelay); |
92 } | 162 } |
93 | 163 |
94 // Verify that multiple delayed tasks are forwarded when they are ripe for | 164 // Verify that multiple delayed tasks added after Start() are forwarded when |
95 // execution. | 165 // they are ripe for execution. |
96 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTasksRunAfterDelay) { | 166 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTasksRunAfterDelay) { |
97 auto task_a = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), TaskTraits(), | 167 delayed_task_manager_.Start(service_thread_task_runner_); |
| 168 auto task_a = MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(), |
98 TimeDelta::FromHours(1)); | 169 TimeDelta::FromHours(1)); |
99 const Task* task_a_raw = task_a.get(); | 170 const Task* task_a_raw = task_a.get(); |
100 | 171 |
101 auto task_b = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), TaskTraits(), | 172 auto task_b = MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(), |
102 TimeDelta::FromHours(2)); | 173 TimeDelta::FromHours(2)); |
103 const Task* task_b_raw = task_b.get(); | 174 const Task* task_b_raw = task_b.get(); |
104 | 175 |
105 auto task_c = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), TaskTraits(), | 176 auto task_c = MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(), |
106 TimeDelta::FromHours(1)); | 177 TimeDelta::FromHours(1)); |
107 const Task* task_c_raw = task_c.get(); | 178 const Task* task_c_raw = task_c.get(); |
108 | 179 |
109 testing::StrictMock<MockTaskTarget> task_target; | |
110 | |
111 // Send tasks to the DelayedTaskManager. | 180 // Send tasks to the DelayedTaskManager. |
112 delayed_task_manager_.AddDelayedTask( | 181 delayed_task_manager_.AddDelayedTask( |
113 std::move(task_a), | 182 std::move(task_a), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
114 Bind(&MockTaskTarget::PostTaskNowCallback, Unretained(&task_target))); | 183 Unretained(&task_target_))); |
115 delayed_task_manager_.AddDelayedTask( | 184 delayed_task_manager_.AddDelayedTask( |
116 std::move(task_b), | 185 std::move(task_b), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
117 Bind(&MockTaskTarget::PostTaskNowCallback, Unretained(&task_target))); | 186 Unretained(&task_target_))); |
118 delayed_task_manager_.AddDelayedTask( | 187 delayed_task_manager_.AddDelayedTask( |
119 std::move(task_c), | 188 std::move(task_c), BindOnce(&MockTaskTarget::PostTaskNowCallback, |
120 Bind(&MockTaskTarget::PostTaskNowCallback, Unretained(&task_target))); | 189 Unretained(&task_target_))); |
121 | 190 |
122 // Run tasks that are ripe for execution on the service thread. Don't expect | 191 // Run tasks that are ripe for execution on the service thread. Don't expect |
123 // any call to |task_target|. | 192 // any call to |task_target_|. |
124 service_thread_task_runner_->RunUntilIdle(); | 193 service_thread_task_runner_->RunUntilIdle(); |
125 | 194 |
126 // Fast-forward time. Expect |task_a_raw| and |task_c_raw| to be forwarded to | 195 // Fast-forward time. Expect |task_a_raw| and |task_c_raw| to be forwarded to |
127 // |task_target|. | 196 // |task_target_|. |
128 EXPECT_CALL(task_target, DoPostTaskNowCallback(task_a_raw)); | 197 EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_a_raw)); |
129 EXPECT_CALL(task_target, DoPostTaskNowCallback(task_c_raw)); | 198 EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_c_raw)); |
130 service_thread_task_runner_->FastForwardBy(TimeDelta::FromHours(1)); | 199 service_thread_task_runner_->FastForwardBy(TimeDelta::FromHours(1)); |
131 testing::Mock::VerifyAndClear(&task_target); | 200 testing::Mock::VerifyAndClear(&task_target_); |
132 | 201 |
133 // Fast-forward time. Expect |task_b_raw| to be forwarded to |task_target|. | 202 // Fast-forward time. Expect |task_b_raw| to be forwarded to |task_target_|. |
134 EXPECT_CALL(task_target, DoPostTaskNowCallback(task_b_raw)); | 203 EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_b_raw)); |
135 service_thread_task_runner_->FastForwardBy(TimeDelta::FromHours(1)); | 204 service_thread_task_runner_->FastForwardBy(TimeDelta::FromHours(1)); |
136 testing::Mock::VerifyAndClear(&task_target); | 205 testing::Mock::VerifyAndClear(&task_target_); |
137 } | 206 } |
138 | 207 |
139 } // namespace internal | 208 } // namespace internal |
140 } // namespace base | 209 } // namespace base |
OLD | NEW |