OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 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 "chromecast/base/alarm_manager.h" | |
6 | |
7 #include "base/memory/ptr_util.h" | |
8 #include "base/threading/thread_task_runner_handle.h" | |
9 #include "base/time/default_clock.h" | |
10 | |
11 #define MAKE_SURE_OWN_THREAD(callback, ...) \ | |
12 if (!task_runner_->BelongsToCurrentThread()) { \ | |
13 task_runner_->PostTask( \ | |
14 FROM_HERE, base::Bind(&AlarmManager::callback, \ | |
15 weak_factory_.GetWeakPtr(), ##__VA_ARGS__)); \ | |
16 return; \ | |
17 } | |
18 | |
19 namespace chromecast { | |
20 | |
21 namespace { | |
22 // How often to poll the clock. | |
23 int kClockPollInterval = 5; | |
halliwell
2017/02/22 19:09:15
nit: kClockPollIntervalSeconds. Comment probably
ryanchung
2017/02/22 19:39:39
Done. heh
| |
24 } // namespace | |
25 | |
26 AlarmManager::AlarmInfo::AlarmInfo( | |
27 const base::Closure& task, | |
28 base::Time time, | |
29 scoped_refptr<base::SingleThreadTaskRunner> task_runner) | |
30 : task_(task), time_(time), task_runner_(task_runner) {} | |
31 | |
32 AlarmManager::AlarmInfo::~AlarmInfo() {} | |
33 | |
34 AlarmManager::AlarmManager( | |
35 std::unique_ptr<base::Clock> clock, | |
36 scoped_refptr<base::SingleThreadTaskRunner> task_runner) | |
37 : clock_(std::move(clock)), task_runner_(task_runner), weak_factory_(this) { | |
38 if (!task_runner.get()) { | |
39 alarm_thread_.reset(new base::Thread("Cast_Alarm_Manager_Thread")); | |
halliwell
2017/02/22 19:09:15
hmmm ... why do we need to create a thread special
ryanchung
2017/02/22 19:39:39
Should we use the UI thread for this? At initializ
halliwell
2017/02/22 19:42:43
Yep, should be fine ... doesn't look like you're d
ryanchung
2017/02/22 19:51:12
Cool. Done. Using base::ThreadTaskRunnerHandle::Ge
| |
40 alarm_thread_->StartWithOptions( | |
41 base::Thread::Options(base::MessageLoop::TYPE_DEFAULT, 0)); | |
42 task_runner_ = alarm_thread_->task_runner(); | |
43 } | |
44 clock_tick_timer_.reset(new base::RepeatingTimer()); | |
45 clock_tick_timer_->SetTaskRunner(task_runner_); | |
46 base::TimeDelta polling_frequency = | |
47 base::TimeDelta::FromSeconds(kClockPollInterval); | |
48 clock_tick_timer_->Start( | |
49 FROM_HERE, polling_frequency, | |
50 base::Bind(&AlarmManager::CheckAlarm, weak_factory_.GetWeakPtr())); | |
51 } | |
52 | |
53 AlarmManager::AlarmManager() | |
54 : AlarmManager(base::MakeUnique<base::DefaultClock>(), nullptr) {} | |
55 | |
56 AlarmManager::~AlarmManager() { | |
57 clock_tick_timer_.reset(nullptr); | |
58 } | |
59 | |
60 void AlarmManager::PostAlarmTask(const base::Closure& task, base::Time time) { | |
61 AddAlarm(task, time, base::ThreadTaskRunnerHandle::Get()); | |
62 } | |
63 | |
64 void AlarmManager::AddAlarm( | |
65 const base::Closure& task, | |
66 base::Time time, | |
67 scoped_refptr<base::SingleThreadTaskRunner> task_runner) { | |
68 MAKE_SURE_OWN_THREAD(AddAlarm, task, time, task_runner); | |
69 std::unique_ptr<AlarmInfo> info = | |
70 base::MakeUnique<AlarmInfo>(task, time, task_runner); | |
71 next_alarm_.push(std::move(info)); | |
72 } | |
73 | |
74 void AlarmManager::CheckAlarm() { | |
75 DCHECK(task_runner_->BelongsToCurrentThread()); | |
76 base::Time now = clock_->Now(); | |
77 // Fire appropriate alarms. | |
78 while ((!next_alarm_.empty()) && now >= next_alarm_.top()->time()) { | |
79 next_alarm_.top()->task_runner()->PostTask(FROM_HERE, | |
80 next_alarm_.top()->task()); | |
81 next_alarm_.pop(); | |
82 } | |
83 } | |
84 | |
85 } // namespace chromecast | |
OLD | NEW |