evan@chromium.org | 3c0bc35 | 2012-02-14 09:29:14 +0900 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
license.bot | f003cfe | 2008-08-24 09:55:55 +0900 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 4 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 5 | #include "base/timer/timer.h" |
| 6 | |
avi | a6a6a68 | 2015-12-27 07:15:14 +0900 | [diff] [blame] | 7 | #include <stddef.h> |
| 8 | |
dcheng | cc8e4d8 | 2016-04-05 06:25:51 +0900 | [diff] [blame] | 9 | #include <memory> |
| 10 | |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 11 | #include "base/bind.h" |
| 12 | #include "base/bind_helpers.h" |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 13 | #include "base/callback.h" |
avi | a6a6a68 | 2015-12-27 07:15:14 +0900 | [diff] [blame] | 14 | #include "base/macros.h" |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 15 | #include "base/memory/ptr_util.h" |
pkotwicz | 55d7a1e | 2017-01-18 05:45:26 +0900 | [diff] [blame] | 16 | #include "base/memory/ref_counted.h" |
avi@chromium.org | a043a86 | 2013-07-18 17:12:40 +0900 | [diff] [blame] | 17 | #include "base/message_loop/message_loop.h" |
fdoray | 85919bb | 2016-07-01 03:17:39 +0900 | [diff] [blame] | 18 | #include "base/run_loop.h" |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 19 | #include "base/sequenced_task_runner.h" |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 20 | #include "base/synchronization/waitable_event.h" |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 21 | #include "base/task_scheduler/post_task.h" |
| 22 | #include "base/test/scoped_task_environment.h" |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 23 | #include "base/test/test_mock_time_task_runner.h" |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 24 | #include "base/threading/platform_thread.h" |
| 25 | #include "base/threading/sequenced_task_runner_handle.h" |
| 26 | #include "base/threading/thread.h" |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 27 | #include "base/time/tick_clock.h" |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 28 | #include "base/time/time.h" |
avi | a6a6a68 | 2015-12-27 07:15:14 +0900 | [diff] [blame] | 29 | #include "build/build_config.h" |
initial.commit | 3f4a732 | 2008-07-27 06:49:38 +0900 | [diff] [blame] | 30 | #include "testing/gtest/include/gtest/gtest.h" |
| 31 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 32 | namespace base { |
dsh@google.com | 0f8dd26 | 2008-10-28 05:43:33 +0900 | [diff] [blame] | 33 | |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 34 | namespace { |
| 35 | |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 36 | // The message loops on which each timer should be tested. |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 37 | const MessageLoop::Type testing_message_loops[] = { |
| 38 | MessageLoop::TYPE_DEFAULT, MessageLoop::TYPE_IO, |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 39 | #if !defined(OS_IOS) // iOS does not allow direct running of the UI loop. |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 40 | MessageLoop::TYPE_UI, |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 41 | #endif |
| 42 | }; |
| 43 | |
| 44 | const int kNumTestingMessageLoops = arraysize(testing_message_loops); |
| 45 | |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 46 | class Receiver { |
| 47 | public: |
| 48 | Receiver() : count_(0) {} |
| 49 | void OnCalled() { count_++; } |
| 50 | bool WasCalled() { return count_ > 0; } |
| 51 | int TimesCalled() { return count_; } |
| 52 | |
| 53 | private: |
| 54 | int count_; |
| 55 | }; |
| 56 | |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 57 | // A basic helper class that can start a one-shot timer and signal a |
| 58 | // WaitableEvent when this timer fires. |
| 59 | class OneShotTimerTesterBase { |
| 60 | public: |
| 61 | // |did_run|, if provided, will be signaled when Run() fires. |
| 62 | explicit OneShotTimerTesterBase( |
| 63 | WaitableEvent* did_run = nullptr, |
| 64 | const TimeDelta& delay = TimeDelta::FromMilliseconds(10)) |
| 65 | : did_run_(did_run), delay_(delay) {} |
| 66 | |
| 67 | virtual ~OneShotTimerTesterBase() = default; |
| 68 | |
| 69 | void Start() { |
| 70 | started_time_ = TimeTicks::Now(); |
| 71 | timer_->Start(FROM_HERE, delay_, this, &OneShotTimerTesterBase::Run); |
| 72 | } |
| 73 | |
| 74 | bool IsRunning() { return timer_->IsRunning(); } |
| 75 | |
| 76 | TimeTicks started_time() const { return started_time_; } |
| 77 | TimeDelta delay() const { return delay_; } |
| 78 | |
| 79 | protected: |
| 80 | virtual void Run() { |
| 81 | if (did_run_) { |
| 82 | EXPECT_FALSE(did_run_->IsSignaled()); |
| 83 | did_run_->Signal(); |
| 84 | } |
| 85 | } |
| 86 | |
Jeremy Roman | cd0c467 | 2017-08-17 08:27:24 +0900 | [diff] [blame] | 87 | std::unique_ptr<OneShotTimer> timer_ = std::make_unique<OneShotTimer>(); |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 88 | |
| 89 | private: |
| 90 | WaitableEvent* const did_run_; |
| 91 | const TimeDelta delay_; |
| 92 | TimeTicks started_time_; |
| 93 | |
| 94 | DISALLOW_COPY_AND_ASSIGN(OneShotTimerTesterBase); |
| 95 | }; |
| 96 | |
| 97 | // Extends functionality of OneShotTimerTesterBase with the abilities to wait |
| 98 | // until the timer fires and to change task runner for the timer. |
| 99 | class OneShotTimerTester : public OneShotTimerTesterBase { |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 100 | public: |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 101 | // |did_run|, if provided, will be signaled when Run() fires. |
| 102 | explicit OneShotTimerTester( |
| 103 | WaitableEvent* did_run = nullptr, |
| 104 | const TimeDelta& delay = TimeDelta::FromMilliseconds(10)) |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 105 | : OneShotTimerTesterBase(did_run, delay), |
| 106 | quit_closure_(run_loop_.QuitClosure()) {} |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 107 | |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 108 | ~OneShotTimerTester() override = default; |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 109 | |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 110 | void SetTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 111 | timer_->SetTaskRunner(std::move(task_runner)); |
| 112 | |
| 113 | // Run() will be invoked on |task_runner| but |run_loop_|'s QuitClosure |
| 114 | // needs to run on this thread (where the MessageLoop lives). |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 115 | quit_closure_ = Bind(IgnoreResult(&SequencedTaskRunner::PostTask), |
| 116 | SequencedTaskRunnerHandle::Get(), FROM_HERE, |
| 117 | run_loop_.QuitClosure()); |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 118 | } |
| 119 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 120 | // Blocks until Run() executes and confirms that Run() didn't fire before |
| 121 | // |delay_| expired. |
| 122 | void WaitAndConfirmTimerFiredAfterDelay() { |
| 123 | run_loop_.Run(); |
| 124 | |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 125 | EXPECT_NE(TimeTicks(), started_time()); |
| 126 | EXPECT_GE(TimeTicks::Now() - started_time(), delay()); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 127 | } |
| 128 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 129 | protected: |
| 130 | // Overridable method to do things on Run() before signaling events/closures |
| 131 | // managed by this helper. |
| 132 | virtual void OnRun() {} |
| 133 | |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 134 | private: |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 135 | void Run() override { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 136 | OnRun(); |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 137 | OneShotTimerTesterBase::Run(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 138 | quit_closure_.Run(); |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 139 | } |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 140 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 141 | RunLoop run_loop_; |
| 142 | Closure quit_closure_; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 143 | |
| 144 | DISALLOW_COPY_AND_ASSIGN(OneShotTimerTester); |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 145 | }; |
| 146 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 147 | class OneShotSelfDeletingTimerTester : public OneShotTimerTester { |
| 148 | protected: |
| 149 | void OnRun() override { timer_.reset(); } |
| 150 | }; |
| 151 | |
| 152 | constexpr int kNumRepeats = 10; |
| 153 | |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 154 | class RepeatingTimerTester { |
| 155 | public: |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 156 | explicit RepeatingTimerTester(WaitableEvent* did_run, const TimeDelta& delay) |
| 157 | : counter_(kNumRepeats), |
| 158 | quit_closure_(run_loop_.QuitClosure()), |
| 159 | did_run_(did_run), |
| 160 | delay_(delay) {} |
erg@google.com | bf6ce9f | 2010-01-27 08:08:02 +0900 | [diff] [blame] | 161 | |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 162 | void Start() { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 163 | started_time_ = TimeTicks::Now(); |
qsr@chromium.org | 38b986c | 2013-12-07 00:22:35 +0900 | [diff] [blame] | 164 | timer_.Start(FROM_HERE, delay_, this, &RepeatingTimerTester::Run); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 165 | } |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 166 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 167 | void WaitAndConfirmTimerFiredRepeatedlyAfterDelay() { |
| 168 | run_loop_.Run(); |
| 169 | |
| 170 | EXPECT_NE(TimeTicks(), started_time_); |
| 171 | EXPECT_GE(TimeTicks::Now() - started_time_, kNumRepeats * delay_); |
| 172 | } |
| 173 | |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 174 | private: |
| 175 | void Run() { |
| 176 | if (--counter_ == 0) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 177 | if (did_run_) { |
| 178 | EXPECT_FALSE(did_run_->IsSignaled()); |
| 179 | did_run_->Signal(); |
| 180 | } |
qsr@chromium.org | 38b986c | 2013-12-07 00:22:35 +0900 | [diff] [blame] | 181 | timer_.Stop(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 182 | quit_closure_.Run(); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 183 | } |
| 184 | } |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 185 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 186 | RepeatingTimer timer_; |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 187 | int counter_; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 188 | |
| 189 | RunLoop run_loop_; |
| 190 | Closure quit_closure_; |
| 191 | WaitableEvent* const did_run_; |
| 192 | |
| 193 | const TimeDelta delay_; |
| 194 | TimeTicks started_time_; |
| 195 | |
| 196 | DISALLOW_COPY_AND_ASSIGN(RepeatingTimerTester); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 197 | }; |
| 198 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 199 | // Basic test with same setup as RunTest_OneShotTimers_Cancel below to confirm |
| 200 | // that |did_run_a| would be signaled in that test if it wasn't for the |
| 201 | // deletion. |
| 202 | void RunTest_OneShotTimers(MessageLoop::Type message_loop_type) { |
| 203 | MessageLoop loop(message_loop_type); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 204 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 205 | WaitableEvent did_run_a(WaitableEvent::ResetPolicy::MANUAL, |
| 206 | WaitableEvent::InitialState::NOT_SIGNALED); |
| 207 | OneShotTimerTester a(&did_run_a); |
| 208 | a.Start(); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 209 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 210 | OneShotTimerTester b; |
| 211 | b.Start(); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 212 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 213 | b.WaitAndConfirmTimerFiredAfterDelay(); |
| 214 | |
| 215 | EXPECT_TRUE(did_run_a.IsSignaled()); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 216 | } |
| 217 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 218 | void RunTest_OneShotTimers_Cancel(MessageLoop::Type message_loop_type) { |
| 219 | MessageLoop loop(message_loop_type); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 220 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 221 | WaitableEvent did_run_a(WaitableEvent::ResetPolicy::MANUAL, |
| 222 | WaitableEvent::InitialState::NOT_SIGNALED); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 223 | OneShotTimerTester* a = new OneShotTimerTester(&did_run_a); |
| 224 | |
| 225 | // This should run before the timer expires. |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 226 | SequencedTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 227 | |
| 228 | // Now start the timer. |
| 229 | a->Start(); |
maruel@chromium.org | 8fe7adc | 2009-03-04 00:01:12 +0900 | [diff] [blame] | 230 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 231 | OneShotTimerTester b; |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 232 | b.Start(); |
| 233 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 234 | b.WaitAndConfirmTimerFiredAfterDelay(); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 235 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 236 | EXPECT_FALSE(did_run_a.IsSignaled()); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 237 | } |
| 238 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 239 | void RunTest_OneShotSelfDeletingTimer(MessageLoop::Type message_loop_type) { |
| 240 | MessageLoop loop(message_loop_type); |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 241 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 242 | OneShotSelfDeletingTimerTester f; |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 243 | f.Start(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 244 | f.WaitAndConfirmTimerFiredAfterDelay(); |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 245 | } |
| 246 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 247 | void RunTest_RepeatingTimer(MessageLoop::Type message_loop_type, |
qsr@chromium.org | 38b986c | 2013-12-07 00:22:35 +0900 | [diff] [blame] | 248 | const TimeDelta& delay) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 249 | MessageLoop loop(message_loop_type); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 250 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 251 | RepeatingTimerTester f(nullptr, delay); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 252 | f.Start(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 253 | f.WaitAndConfirmTimerFiredRepeatedlyAfterDelay(); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 254 | } |
| 255 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 256 | void RunTest_RepeatingTimer_Cancel(MessageLoop::Type message_loop_type, |
qsr@chromium.org | 38b986c | 2013-12-07 00:22:35 +0900 | [diff] [blame] | 257 | const TimeDelta& delay) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 258 | MessageLoop loop(message_loop_type); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 259 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 260 | WaitableEvent did_run_a(WaitableEvent::ResetPolicy::MANUAL, |
| 261 | WaitableEvent::InitialState::NOT_SIGNALED); |
qsr@chromium.org | 38b986c | 2013-12-07 00:22:35 +0900 | [diff] [blame] | 262 | RepeatingTimerTester* a = new RepeatingTimerTester(&did_run_a, delay); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 263 | |
| 264 | // This should run before the timer expires. |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 265 | SequencedTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, a); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 266 | |
| 267 | // Now start the timer. |
| 268 | a->Start(); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 269 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 270 | RepeatingTimerTester b(nullptr, delay); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 271 | b.Start(); |
| 272 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 273 | b.WaitAndConfirmTimerFiredRepeatedlyAfterDelay(); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 274 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 275 | // |a| should not have fired despite |b| starting after it on the same |
| 276 | // sequence and being complete by now. |
| 277 | EXPECT_FALSE(did_run_a.IsSignaled()); |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 278 | } |
| 279 | |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 280 | class DelayTimerTarget { |
| 281 | public: |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 282 | bool signaled() const { return signaled_; } |
| 283 | |
| 284 | void Signal() { |
| 285 | ASSERT_FALSE(signaled_); |
| 286 | signaled_ = true; |
| 287 | } |
| 288 | |
| 289 | private: |
hashimoto | 9c17099 | 2015-01-23 00:21:41 +0900 | [diff] [blame] | 290 | bool signaled_ = false; |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 291 | }; |
| 292 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 293 | void RunTest_DelayTimer_NoCall(MessageLoop::Type message_loop_type) { |
| 294 | MessageLoop loop(message_loop_type); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 295 | |
| 296 | // If Delay is never called, the timer shouldn't go off. |
| 297 | DelayTimerTarget target; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 298 | DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target, |
| 299 | &DelayTimerTarget::Signal); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 300 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 301 | OneShotTimerTester tester; |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 302 | tester.Start(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 303 | tester.WaitAndConfirmTimerFiredAfterDelay(); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 304 | |
| 305 | ASSERT_FALSE(target.signaled()); |
| 306 | } |
| 307 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 308 | void RunTest_DelayTimer_OneCall(MessageLoop::Type message_loop_type) { |
| 309 | MessageLoop loop(message_loop_type); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 310 | |
| 311 | DelayTimerTarget target; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 312 | DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(1), &target, |
| 313 | &DelayTimerTarget::Signal); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 314 | timer.Reset(); |
| 315 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 316 | OneShotTimerTester tester(nullptr, TimeDelta::FromMilliseconds(100)); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 317 | tester.Start(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 318 | tester.WaitAndConfirmTimerFiredAfterDelay(); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 319 | |
| 320 | ASSERT_TRUE(target.signaled()); |
| 321 | } |
| 322 | |
| 323 | struct ResetHelper { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 324 | ResetHelper(DelayTimer* timer, DelayTimerTarget* target) |
danakj | 85d43f4 | 2015-09-24 16:53:00 +0900 | [diff] [blame] | 325 | : timer_(timer), target_(target) {} |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 326 | |
| 327 | void Reset() { |
| 328 | ASSERT_FALSE(target_->signaled()); |
| 329 | timer_->Reset(); |
| 330 | } |
| 331 | |
| 332 | private: |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 333 | DelayTimer* const timer_; |
danakj | 85d43f4 | 2015-09-24 16:53:00 +0900 | [diff] [blame] | 334 | DelayTimerTarget* const target_; |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 335 | }; |
| 336 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 337 | void RunTest_DelayTimer_Reset(MessageLoop::Type message_loop_type) { |
| 338 | MessageLoop loop(message_loop_type); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 339 | |
| 340 | // If Delay is never called, the timer shouldn't go off. |
| 341 | DelayTimerTarget target; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 342 | DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(50), &target, |
| 343 | &DelayTimerTarget::Signal); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 344 | timer.Reset(); |
| 345 | |
| 346 | ResetHelper reset_helper(&timer, &target); |
| 347 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 348 | OneShotTimer timers[20]; |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 349 | for (size_t i = 0; i < arraysize(timers); ++i) { |
jbates@chromium.org | ad6a345 | 2011-09-03 03:23:02 +0900 | [diff] [blame] | 350 | timers[i].Start(FROM_HERE, TimeDelta::FromMilliseconds(i * 10), |
| 351 | &reset_helper, &ResetHelper::Reset); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 352 | } |
| 353 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 354 | OneShotTimerTester tester(nullptr, TimeDelta::FromMilliseconds(300)); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 355 | tester.Start(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 356 | tester.WaitAndConfirmTimerFiredAfterDelay(); |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 357 | |
| 358 | ASSERT_TRUE(target.signaled()); |
| 359 | } |
| 360 | |
agl@chromium.org | f589086 | 2009-02-27 08:17:56 +0900 | [diff] [blame] | 361 | class DelayTimerFatalTarget { |
| 362 | public: |
| 363 | void Signal() { |
| 364 | ASSERT_TRUE(false); |
| 365 | } |
| 366 | }; |
| 367 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 368 | void RunTest_DelayTimer_Deleted(MessageLoop::Type message_loop_type) { |
| 369 | MessageLoop loop(message_loop_type); |
agl@chromium.org | f589086 | 2009-02-27 08:17:56 +0900 | [diff] [blame] | 370 | |
| 371 | DelayTimerFatalTarget target; |
| 372 | |
| 373 | { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 374 | DelayTimer timer(FROM_HERE, TimeDelta::FromMilliseconds(50), &target, |
| 375 | &DelayTimerFatalTarget::Signal); |
agl@chromium.org | f589086 | 2009-02-27 08:17:56 +0900 | [diff] [blame] | 376 | timer.Reset(); |
| 377 | } |
| 378 | |
| 379 | // When the timer is deleted, the DelayTimerFatalTarget should never be |
| 380 | // called. |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 381 | PlatformThread::Sleep(TimeDelta::FromMilliseconds(100)); |
agl@chromium.org | f589086 | 2009-02-27 08:17:56 +0900 | [diff] [blame] | 382 | } |
| 383 | |
darin@google.com | d936b5b | 2008-08-26 14:53:57 +0900 | [diff] [blame] | 384 | } // namespace |
| 385 | |
| 386 | //----------------------------------------------------------------------------- |
| 387 | // Each test is run against each type of MessageLoop. That way we are sure |
| 388 | // that timers work properly in all configurations. |
| 389 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 390 | TEST(TimerTest, OneShotTimers) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 391 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 392 | RunTest_OneShotTimers(testing_message_loops[i]); |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 393 | } |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 394 | } |
| 395 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 396 | TEST(TimerTest, OneShotTimers_Cancel) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 397 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 398 | RunTest_OneShotTimers_Cancel(testing_message_loops[i]); |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 399 | } |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 400 | } |
| 401 | |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 402 | // If underline timer does not handle properly, we will crash or fail |
jeanluc@chromium.org | 5fcf787 | 2011-08-18 02:41:02 +0900 | [diff] [blame] | 403 | // in full page heap environment. |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 404 | TEST(TimerTest, OneShotSelfDeletingTimer) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 405 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
| 406 | RunTest_OneShotSelfDeletingTimer(testing_message_loops[i]); |
| 407 | } |
huanr@chromium.org | 7d5b058 | 2009-02-07 09:37:01 +0900 | [diff] [blame] | 408 | } |
| 409 | |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 410 | TEST(TimerTest, OneShotTimer_CustomTaskRunner) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 411 | // A MessageLoop is required for the timer events on the other thread to |
| 412 | // communicate back to the Timer under test. |
| 413 | MessageLoop loop; |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 414 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 415 | Thread other_thread("OneShotTimer_CustomTaskRunner"); |
| 416 | other_thread.Start(); |
| 417 | |
| 418 | WaitableEvent did_run(WaitableEvent::ResetPolicy::MANUAL, |
| 419 | WaitableEvent::InitialState::NOT_SIGNALED); |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 420 | OneShotTimerTester f(&did_run); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 421 | f.SetTaskRunner(other_thread.task_runner()); |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 422 | f.Start(); |
Scott Graham | 0be6f74 | 2017-07-26 06:25:32 +0900 | [diff] [blame] | 423 | EXPECT_TRUE(f.IsRunning() || did_run.IsSignaled()); |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 424 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 425 | f.WaitAndConfirmTimerFiredAfterDelay(); |
| 426 | EXPECT_TRUE(did_run.IsSignaled()); |
| 427 | |
| 428 | // |f| should already have communicated back to this |loop| before invoking |
| 429 | // Run() and as such this thread should already be aware that |f| is no longer |
| 430 | // running. |
| 431 | EXPECT_TRUE(loop.IsIdleForTesting()); |
| 432 | EXPECT_FALSE(f.IsRunning()); |
petrcermak | 4dec79e | 2014-11-06 11:17:57 +0900 | [diff] [blame] | 433 | } |
| 434 | |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 435 | TEST(TimerTest, OneShotTimerWithTickClock) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 436 | scoped_refptr<TestMockTimeTaskRunner> task_runner( |
| 437 | new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now())); |
| 438 | std::unique_ptr<TickClock> tick_clock(task_runner->GetMockTickClock()); |
| 439 | MessageLoop message_loop; |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 440 | message_loop.SetTaskRunner(task_runner); |
| 441 | Receiver receiver; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 442 | OneShotTimer timer(tick_clock.get()); |
| 443 | timer.Start(FROM_HERE, TimeDelta::FromSeconds(1), |
| 444 | Bind(&Receiver::OnCalled, Unretained(&receiver))); |
| 445 | task_runner->FastForwardBy(TimeDelta::FromSeconds(1)); |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 446 | EXPECT_TRUE(receiver.WasCalled()); |
| 447 | } |
| 448 | |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 449 | TEST(TimerTest, RepeatingTimer) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 450 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
qsr@chromium.org | 38b986c | 2013-12-07 00:22:35 +0900 | [diff] [blame] | 451 | RunTest_RepeatingTimer(testing_message_loops[i], |
| 452 | TimeDelta::FromMilliseconds(10)); |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 453 | } |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 454 | } |
| 455 | |
| 456 | TEST(TimerTest, RepeatingTimer_Cancel) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 457 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
qsr@chromium.org | 38b986c | 2013-12-07 00:22:35 +0900 | [diff] [blame] | 458 | RunTest_RepeatingTimer_Cancel(testing_message_loops[i], |
| 459 | TimeDelta::FromMilliseconds(10)); |
| 460 | } |
| 461 | } |
| 462 | |
| 463 | TEST(TimerTest, RepeatingTimerZeroDelay) { |
| 464 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
| 465 | RunTest_RepeatingTimer(testing_message_loops[i], |
| 466 | TimeDelta::FromMilliseconds(0)); |
| 467 | } |
| 468 | } |
| 469 | |
| 470 | TEST(TimerTest, RepeatingTimerZeroDelay_Cancel) { |
| 471 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
| 472 | RunTest_RepeatingTimer_Cancel(testing_message_loops[i], |
| 473 | TimeDelta::FromMilliseconds(0)); |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 474 | } |
darin@google.com | 0b8a30c | 2008-08-29 05:50:12 +0900 | [diff] [blame] | 475 | } |
mbelshe@google.com | e0efec8 | 2008-12-03 08:16:55 +0900 | [diff] [blame] | 476 | |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 477 | TEST(TimerTest, RepeatingTimerWithTickClock) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 478 | scoped_refptr<TestMockTimeTaskRunner> task_runner( |
| 479 | new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now())); |
| 480 | std::unique_ptr<TickClock> tick_clock(task_runner->GetMockTickClock()); |
| 481 | MessageLoop message_loop; |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 482 | message_loop.SetTaskRunner(task_runner); |
| 483 | Receiver receiver; |
| 484 | const int expected_times_called = 10; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 485 | RepeatingTimer timer(tick_clock.get()); |
| 486 | timer.Start(FROM_HERE, TimeDelta::FromSeconds(1), |
| 487 | Bind(&Receiver::OnCalled, Unretained(&receiver))); |
| 488 | task_runner->FastForwardBy(TimeDelta::FromSeconds(expected_times_called)); |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 489 | timer.Stop(); |
| 490 | EXPECT_EQ(expected_times_called, receiver.TimesCalled()); |
| 491 | } |
| 492 | |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 493 | TEST(TimerTest, DelayTimer_NoCall) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 494 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
| 495 | RunTest_DelayTimer_NoCall(testing_message_loops[i]); |
| 496 | } |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 497 | } |
| 498 | |
| 499 | TEST(TimerTest, DelayTimer_OneCall) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 500 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
| 501 | RunTest_DelayTimer_OneCall(testing_message_loops[i]); |
| 502 | } |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 503 | } |
| 504 | |
phajdan.jr@chromium.org | 0cafffe | 2009-10-17 00:26:16 +0900 | [diff] [blame] | 505 | // It's flaky on the buildbot, http://crbug.com/25038. |
evan@chromium.org | 3c0bc35 | 2012-02-14 09:29:14 +0900 | [diff] [blame] | 506 | TEST(TimerTest, DISABLED_DelayTimer_Reset) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 507 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
| 508 | RunTest_DelayTimer_Reset(testing_message_loops[i]); |
| 509 | } |
agl@chromium.org | 31de02e | 2009-02-20 11:00:04 +0900 | [diff] [blame] | 510 | } |
| 511 | |
agl@chromium.org | f589086 | 2009-02-27 08:17:56 +0900 | [diff] [blame] | 512 | TEST(TimerTest, DelayTimer_Deleted) { |
leng@chromium.org | 44fe4d7 | 2012-07-17 20:22:59 +0900 | [diff] [blame] | 513 | for (int i = 0; i < kNumTestingMessageLoops; i++) { |
| 514 | RunTest_DelayTimer_Deleted(testing_message_loops[i]); |
| 515 | } |
agl@chromium.org | f589086 | 2009-02-27 08:17:56 +0900 | [diff] [blame] | 516 | } |
| 517 | |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 518 | TEST(TimerTest, DelayTimerWithTickClock) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 519 | scoped_refptr<TestMockTimeTaskRunner> task_runner( |
| 520 | new TestMockTimeTaskRunner(Time::Now(), TimeTicks::Now())); |
| 521 | std::unique_ptr<TickClock> tick_clock(task_runner->GetMockTickClock()); |
| 522 | MessageLoop message_loop; |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 523 | message_loop.SetTaskRunner(task_runner); |
| 524 | Receiver receiver; |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 525 | DelayTimer timer(FROM_HERE, TimeDelta::FromSeconds(1), &receiver, |
| 526 | &Receiver::OnCalled, tick_clock.get()); |
| 527 | task_runner->FastForwardBy(TimeDelta::FromMilliseconds(999)); |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 528 | EXPECT_FALSE(receiver.WasCalled()); |
| 529 | timer.Reset(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 530 | task_runner->FastForwardBy(TimeDelta::FromMilliseconds(999)); |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 531 | EXPECT_FALSE(receiver.WasCalled()); |
| 532 | timer.Reset(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 533 | task_runner->FastForwardBy(TimeDelta::FromSeconds(1)); |
jameswest | 9f1f3a0 | 2016-11-15 14:19:54 +0900 | [diff] [blame] | 534 | EXPECT_TRUE(receiver.WasCalled()); |
| 535 | } |
| 536 | |
mbelshe@google.com | e0efec8 | 2008-12-03 08:16:55 +0900 | [diff] [blame] | 537 | TEST(TimerTest, MessageLoopShutdown) { |
| 538 | // This test is designed to verify that shutdown of the |
| 539 | // message loop does not cause crashes if there were pending |
| 540 | // timers not yet fired. It may only trigger exceptions |
jeanluc@chromium.org | 5fcf787 | 2011-08-18 02:41:02 +0900 | [diff] [blame] | 541 | // if debug heap checking is enabled. |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 542 | WaitableEvent did_run(WaitableEvent::ResetPolicy::MANUAL, |
| 543 | WaitableEvent::InitialState::NOT_SIGNALED); |
mbelshe@google.com | e0efec8 | 2008-12-03 08:16:55 +0900 | [diff] [blame] | 544 | { |
ahest | 9a63aa2 | 2016-12-13 20:34:38 +0900 | [diff] [blame] | 545 | OneShotTimerTesterBase a(&did_run); |
| 546 | OneShotTimerTesterBase b(&did_run); |
| 547 | OneShotTimerTesterBase c(&did_run); |
| 548 | OneShotTimerTesterBase d(&did_run); |
mbelshe@google.com | e0efec8 | 2008-12-03 08:16:55 +0900 | [diff] [blame] | 549 | { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 550 | MessageLoop loop; |
mbelshe@google.com | e0efec8 | 2008-12-03 08:16:55 +0900 | [diff] [blame] | 551 | a.Start(); |
| 552 | b.Start(); |
| 553 | } // MessageLoop destructs by falling out of scope. |
| 554 | } // OneShotTimers destruct. SHOULD NOT CRASH, of course. |
| 555 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 556 | EXPECT_FALSE(did_run.IsSignaled()); |
mbelshe@google.com | e0efec8 | 2008-12-03 08:16:55 +0900 | [diff] [blame] | 557 | } |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 558 | |
pkotwicz | 55d7a1e | 2017-01-18 05:45:26 +0900 | [diff] [blame] | 559 | // Ref counted class which owns a Timer. The class passes a reference to itself |
| 560 | // via the |user_task| parameter in Timer::Start(). |Timer::user_task_| might |
| 561 | // end up holding the last reference to the class. |
| 562 | class OneShotSelfOwningTimerTester |
| 563 | : public RefCounted<OneShotSelfOwningTimerTester> { |
| 564 | public: |
| 565 | OneShotSelfOwningTimerTester() = default; |
| 566 | |
| 567 | void StartTimer() { |
| 568 | // Start timer with long delay in order to test the timer getting destroyed |
| 569 | // while a timer task is still pending. |
| 570 | timer_.Start(FROM_HERE, TimeDelta::FromDays(1), |
| 571 | base::Bind(&OneShotSelfOwningTimerTester::Run, this)); |
| 572 | } |
| 573 | |
| 574 | private: |
| 575 | friend class RefCounted<OneShotSelfOwningTimerTester>; |
| 576 | ~OneShotSelfOwningTimerTester() = default; |
| 577 | |
| 578 | void Run() { |
| 579 | ADD_FAILURE() << "Timer unexpectedly fired."; |
| 580 | } |
| 581 | |
| 582 | OneShotTimer timer_; |
| 583 | |
| 584 | DISALLOW_COPY_AND_ASSIGN(OneShotSelfOwningTimerTester); |
| 585 | }; |
| 586 | |
| 587 | TEST(TimerTest, MessageLoopShutdownSelfOwningTimer) { |
| 588 | // This test verifies that shutdown of the message loop does not cause crashes |
| 589 | // if there is a pending timer not yet fired and |Timer::user_task_| owns the |
| 590 | // timer. The test may only trigger exceptions if debug heap checking is |
| 591 | // enabled. |
| 592 | |
| 593 | MessageLoop loop; |
| 594 | scoped_refptr<OneShotSelfOwningTimerTester> tester = |
| 595 | new OneShotSelfOwningTimerTester(); |
| 596 | |
| 597 | std::move(tester)->StartTimer(); |
| 598 | // |Timer::user_task_| owns sole reference to |tester|. |
| 599 | |
| 600 | // MessageLoop destructs by falling out of scope. SHOULD NOT CRASH. |
| 601 | } |
| 602 | |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 603 | void TimerTestCallback() { |
| 604 | } |
| 605 | |
| 606 | TEST(TimerTest, NonRepeatIsRunning) { |
| 607 | { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 608 | MessageLoop loop; |
| 609 | Timer timer(false, false); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 610 | EXPECT_FALSE(timer.IsRunning()); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 611 | timer.Start(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback)); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 612 | EXPECT_TRUE(timer.IsRunning()); |
| 613 | timer.Stop(); |
| 614 | EXPECT_FALSE(timer.IsRunning()); |
| 615 | EXPECT_TRUE(timer.user_task().is_null()); |
| 616 | } |
| 617 | |
| 618 | { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 619 | Timer timer(true, false); |
| 620 | MessageLoop loop; |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 621 | EXPECT_FALSE(timer.IsRunning()); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 622 | timer.Start(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback)); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 623 | EXPECT_TRUE(timer.IsRunning()); |
| 624 | timer.Stop(); |
| 625 | EXPECT_FALSE(timer.IsRunning()); |
| 626 | ASSERT_FALSE(timer.user_task().is_null()); |
| 627 | timer.Reset(); |
| 628 | EXPECT_TRUE(timer.IsRunning()); |
| 629 | } |
| 630 | } |
| 631 | |
| 632 | TEST(TimerTest, NonRepeatMessageLoopDeath) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 633 | Timer timer(false, false); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 634 | { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 635 | MessageLoop loop; |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 636 | EXPECT_FALSE(timer.IsRunning()); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 637 | timer.Start(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback)); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 638 | EXPECT_TRUE(timer.IsRunning()); |
| 639 | } |
| 640 | EXPECT_FALSE(timer.IsRunning()); |
| 641 | EXPECT_TRUE(timer.user_task().is_null()); |
| 642 | } |
| 643 | |
| 644 | TEST(TimerTest, RetainRepeatIsRunning) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 645 | MessageLoop loop; |
| 646 | Timer timer(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback), |
| 647 | true); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 648 | EXPECT_FALSE(timer.IsRunning()); |
| 649 | timer.Reset(); |
| 650 | EXPECT_TRUE(timer.IsRunning()); |
| 651 | timer.Stop(); |
| 652 | EXPECT_FALSE(timer.IsRunning()); |
| 653 | timer.Reset(); |
| 654 | EXPECT_TRUE(timer.IsRunning()); |
| 655 | } |
| 656 | |
| 657 | TEST(TimerTest, RetainNonRepeatIsRunning) { |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 658 | MessageLoop loop; |
| 659 | Timer timer(FROM_HERE, TimeDelta::FromDays(1), Bind(&TimerTestCallback), |
| 660 | false); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 661 | EXPECT_FALSE(timer.IsRunning()); |
| 662 | timer.Reset(); |
| 663 | EXPECT_TRUE(timer.IsRunning()); |
| 664 | timer.Stop(); |
| 665 | EXPECT_FALSE(timer.IsRunning()); |
| 666 | timer.Reset(); |
| 667 | EXPECT_TRUE(timer.IsRunning()); |
| 668 | } |
| 669 | |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 670 | //----------------------------------------------------------------------------- |
| 671 | |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 672 | namespace { |
| 673 | |
| 674 | bool g_callback_happened1 = false; |
| 675 | bool g_callback_happened2 = false; |
| 676 | |
| 677 | void ClearAllCallbackHappened() { |
| 678 | g_callback_happened1 = false; |
| 679 | g_callback_happened2 = false; |
| 680 | } |
| 681 | |
| 682 | void SetCallbackHappened1() { |
| 683 | g_callback_happened1 = true; |
Gabriel Charette | 274bec8 | 2017-07-26 21:36:23 +0900 | [diff] [blame] | 684 | RunLoop::QuitCurrentWhenIdleDeprecated(); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 685 | } |
| 686 | |
| 687 | void SetCallbackHappened2() { |
| 688 | g_callback_happened2 = true; |
Gabriel Charette | 274bec8 | 2017-07-26 21:36:23 +0900 | [diff] [blame] | 689 | RunLoop::QuitCurrentWhenIdleDeprecated(); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 690 | } |
| 691 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 692 | } // namespace |
| 693 | |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 694 | TEST(TimerTest, ContinuationStopStart) { |
| 695 | { |
| 696 | ClearAllCallbackHappened(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 697 | MessageLoop loop; |
| 698 | Timer timer(false, false); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 699 | timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10), |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 700 | Bind(&SetCallbackHappened1)); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 701 | timer.Stop(); |
| 702 | timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(40), |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 703 | Bind(&SetCallbackHappened2)); |
| 704 | RunLoop().Run(); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 705 | EXPECT_FALSE(g_callback_happened1); |
| 706 | EXPECT_TRUE(g_callback_happened2); |
| 707 | } |
| 708 | } |
| 709 | |
| 710 | TEST(TimerTest, ContinuationReset) { |
| 711 | { |
| 712 | ClearAllCallbackHappened(); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 713 | MessageLoop loop; |
| 714 | Timer timer(false, false); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 715 | timer.Start(FROM_HERE, TimeDelta::FromMilliseconds(10), |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 716 | Bind(&SetCallbackHappened1)); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 717 | timer.Reset(); |
| 718 | // Since Reset happened before task ran, the user_task must not be cleared: |
| 719 | ASSERT_FALSE(timer.user_task().is_null()); |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 720 | RunLoop().Run(); |
jbates@chromium.org | 1800183 | 2012-03-27 09:18:57 +0900 | [diff] [blame] | 721 | EXPECT_TRUE(g_callback_happened1); |
| 722 | } |
| 723 | } |
| 724 | |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 725 | namespace { |
| 726 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 727 | // Fixture for tests requiring ScopedTaskEnvironment. Includes a WaitableEvent |
| 728 | // so that cases may Wait() on one thread and Signal() (explicitly, or |
| 729 | // implicitly via helper methods) on another. |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 730 | class TimerSequenceTest : public testing::Test { |
| 731 | public: |
| 732 | TimerSequenceTest() |
| 733 | : event_(WaitableEvent::ResetPolicy::AUTOMATIC, |
| 734 | WaitableEvent::InitialState::NOT_SIGNALED) {} |
| 735 | |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 736 | // Block until Signal() is called on another thread. |
| 737 | void Wait() { event_.Wait(); } |
| 738 | |
| 739 | void Signal() { event_.Signal(); } |
| 740 | |
| 741 | // Helper to augment a task with a subsequent call to Signal(). |
| 742 | Closure TaskWithSignal(const Closure& task) { |
| 743 | return Bind(&TimerSequenceTest::RunTaskAndSignal, Unretained(this), task); |
| 744 | } |
| 745 | |
| 746 | // Create the timer. |
| 747 | void CreateTimer() { timer_.reset(new OneShotTimer); } |
| 748 | |
| 749 | // Schedule an event on the timer. |
| 750 | void StartTimer(TimeDelta delay, const Closure& task) { |
| 751 | timer_->Start(FROM_HERE, delay, task); |
| 752 | } |
| 753 | |
| 754 | void SetTaskRunnerForTimer(scoped_refptr<SequencedTaskRunner> task_runner) { |
| 755 | timer_->SetTaskRunner(std::move(task_runner)); |
| 756 | } |
| 757 | |
| 758 | // Tell the timer to abandon the task. |
| 759 | void AbandonTask() { |
| 760 | EXPECT_TRUE(timer_->IsRunning()); |
| 761 | // Reset() to call Timer::AbandonScheduledTask() |
| 762 | timer_->Reset(); |
| 763 | EXPECT_TRUE(timer_->IsRunning()); |
| 764 | timer_->Stop(); |
| 765 | EXPECT_FALSE(timer_->IsRunning()); |
| 766 | } |
| 767 | |
| 768 | static void VerifyAffinity(const SequencedTaskRunner* task_runner) { |
Yeol | 0d4f3eb | 2017-07-26 02:09:10 +0900 | [diff] [blame] | 769 | EXPECT_TRUE(task_runner->RunsTasksInCurrentSequence()); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 770 | } |
| 771 | |
| 772 | // Delete the timer. |
| 773 | void DeleteTimer() { timer_.reset(); } |
| 774 | |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 775 | private: |
| 776 | void RunTaskAndSignal(const Closure& task) { |
| 777 | task.Run(); |
| 778 | Signal(); |
| 779 | } |
| 780 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 781 | base::test::ScopedTaskEnvironment scoped_task_environment_; |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 782 | WaitableEvent event_; |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 783 | std::unique_ptr<OneShotTimer> timer_; |
| 784 | |
| 785 | DISALLOW_COPY_AND_ASSIGN(TimerSequenceTest); |
| 786 | }; |
| 787 | |
| 788 | } // namespace |
| 789 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 790 | TEST_F(TimerSequenceTest, OneShotTimerTaskOnPoolSequence) { |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 791 | scoped_refptr<SequencedTaskRunner> task_runner = |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 792 | base::CreateSequencedTaskRunnerWithTraits({}); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 793 | |
| 794 | base::RunLoop run_loop_; |
| 795 | |
| 796 | // Timer is created on this thread. |
| 797 | CreateTimer(); |
| 798 | |
| 799 | // Task will execute on a pool thread. |
| 800 | SetTaskRunnerForTimer(task_runner); |
| 801 | StartTimer(TimeDelta::FromMilliseconds(1), |
| 802 | Bind(IgnoreResult(&SequencedTaskRunner::PostTask), |
| 803 | SequencedTaskRunnerHandle::Get(), FROM_HERE, |
| 804 | run_loop_.QuitClosure())); |
| 805 | |
| 806 | // Spin the loop so that the delayed task fires on it, which will forward it |
| 807 | // to |task_runner|. And since the Timer's task is one that posts back to this |
| 808 | // MessageLoop to quit, we finally unblock. |
| 809 | run_loop_.Run(); |
| 810 | |
| 811 | // Timer will be destroyed on this thread. |
| 812 | DeleteTimer(); |
| 813 | } |
| 814 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 815 | TEST_F(TimerSequenceTest, OneShotTimerUsedOnPoolSequence) { |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 816 | scoped_refptr<SequencedTaskRunner> task_runner = |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 817 | base::CreateSequencedTaskRunnerWithTraits({}); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 818 | |
| 819 | // Timer is created on this thread. |
| 820 | CreateTimer(); |
| 821 | |
| 822 | // Task will be scheduled from a pool thread. |
| 823 | task_runner->PostTask( |
tzik | 330d83f | 2017-06-26 15:13:17 +0900 | [diff] [blame] | 824 | FROM_HERE, BindOnce(&TimerSequenceTest::StartTimer, Unretained(this), |
| 825 | TimeDelta::FromMilliseconds(1), |
| 826 | Bind(&TimerSequenceTest::Signal, Unretained(this)))); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 827 | Wait(); |
| 828 | |
| 829 | // Timer must be destroyed on pool thread, too. |
| 830 | task_runner->PostTask( |
| 831 | FROM_HERE, |
| 832 | TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this)))); |
| 833 | Wait(); |
| 834 | } |
| 835 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 836 | TEST_F(TimerSequenceTest, OneShotTimerTwoSequencesAbandonTask) { |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 837 | scoped_refptr<SequencedTaskRunner> task_runner1 = |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 838 | base::CreateSequencedTaskRunnerWithTraits({}); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 839 | scoped_refptr<SequencedTaskRunner> task_runner2 = |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 840 | base::CreateSequencedTaskRunnerWithTraits({}); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 841 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 842 | // Create timer on sequence #1. |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 843 | task_runner1->PostTask( |
| 844 | FROM_HERE, |
| 845 | TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this)))); |
| 846 | Wait(); |
| 847 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 848 | // And tell it to execute on a different sequence (#2). |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 849 | task_runner1->PostTask( |
| 850 | FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer, |
| 851 | Unretained(this), task_runner2))); |
| 852 | Wait(); |
| 853 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 854 | // Task will be scheduled from sequence #1. |
tzik | 330d83f | 2017-06-26 15:13:17 +0900 | [diff] [blame] | 855 | task_runner1->PostTask( |
| 856 | FROM_HERE, BindOnce(&TimerSequenceTest::StartTimer, Unretained(this), |
Peter Kasting | 24efe5e | 2018-02-24 09:03:01 +0900 | [diff] [blame^] | 857 | TimeDelta::FromHours(1), DoNothing())); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 858 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 859 | // Abandon task - must be called from scheduling sequence (#1). |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 860 | task_runner1->PostTask( |
| 861 | FROM_HERE, |
| 862 | TaskWithSignal(Bind(&TimerSequenceTest::AbandonTask, Unretained(this)))); |
| 863 | Wait(); |
| 864 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 865 | // Timer must be destroyed on the sequence it was scheduled from (#1). |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 866 | task_runner1->PostTask( |
| 867 | FROM_HERE, |
| 868 | TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this)))); |
| 869 | Wait(); |
| 870 | } |
| 871 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 872 | TEST_F(TimerSequenceTest, OneShotTimerUsedAndTaskedOnDifferentSequences) { |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 873 | scoped_refptr<SequencedTaskRunner> task_runner1 = |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 874 | base::CreateSequencedTaskRunnerWithTraits({}); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 875 | scoped_refptr<SequencedTaskRunner> task_runner2 = |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 876 | base::CreateSequencedTaskRunnerWithTraits({}); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 877 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 878 | // Create timer on sequence #1. |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 879 | task_runner1->PostTask( |
| 880 | FROM_HERE, |
| 881 | TaskWithSignal(Bind(&TimerSequenceTest::CreateTimer, Unretained(this)))); |
| 882 | Wait(); |
| 883 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 884 | // And tell it to execute on a different sequence (#2). |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 885 | task_runner1->PostTask( |
| 886 | FROM_HERE, TaskWithSignal(Bind(&TimerSequenceTest::SetTaskRunnerForTimer, |
| 887 | Unretained(this), task_runner2))); |
| 888 | Wait(); |
| 889 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 890 | // Task will be scheduled from sequence #1. |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 891 | task_runner1->PostTask( |
tzik | 330d83f | 2017-06-26 15:13:17 +0900 | [diff] [blame] | 892 | FROM_HERE, |
| 893 | BindOnce(&TimerSequenceTest::StartTimer, Unretained(this), |
| 894 | TimeDelta::FromMilliseconds(1), |
| 895 | TaskWithSignal(Bind(&TimerSequenceTest::VerifyAffinity, |
| 896 | Unretained(task_runner2.get()))))); |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 897 | |
| 898 | Wait(); |
| 899 | |
Francois Doray | 1851672 | 2018-01-28 10:32:18 +0900 | [diff] [blame] | 900 | // Timer must be destroyed on the sequence it was scheduled from (#1). |
gab | b4a7cd4 | 2017-06-02 01:23:36 +0900 | [diff] [blame] | 901 | task_runner1->PostTask( |
| 902 | FROM_HERE, |
| 903 | TaskWithSignal(Bind(&TimerSequenceTest::DeleteTimer, Unretained(this)))); |
| 904 | Wait(); |
| 905 | } |
| 906 | |
gab | ccd5b95 | 2016-11-29 08:01:33 +0900 | [diff] [blame] | 907 | } // namespace base |