// Copyright 2014 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.
|
|
#ifndef COMPONENTS_TIMERS_ALARM_TIMER_CHROMEOS_H_
|
#define COMPONENTS_TIMERS_ALARM_TIMER_CHROMEOS_H_
|
|
#include <memory>
|
|
#include "base/files/file_descriptor_watcher_posix.h"
|
#include "base/macros.h"
|
#include "base/memory/scoped_refptr.h"
|
#include "base/memory/weak_ptr.h"
|
#include "base/threading/sequenced_task_runner_handle.h"
|
#include "base/time/time.h"
|
#include "base/timer/timer.h"
|
|
namespace base {
|
struct PendingTask;
|
}
|
|
namespace timers {
|
// The class implements a timer that is capable of waking the system up from a
|
// suspended state. For example, this is useful for running tasks that are
|
// needed for maintaining network connectivity, like sending heartbeat messages.
|
// Currently, this feature is only available on Chrome OS systems running linux
|
// version 3.11 or higher. On all other platforms, the SimpleAlarmTimer behaves
|
// exactly the same way as a regular Timer.
|
//
|
// A SimpleAlarmTimer instance can only be used from the sequence on which it
|
// was instantiated. Start() and Stop() must be called from a thread that
|
// supports FileDescriptorWatcher.
|
//
|
// A SimpleAlarmTimer only fires once but remembers the task that it was given
|
// even after it has fired. Useful if you want to run the same task multiple
|
// times but not at a regular interval.
|
class SimpleAlarmTimer : public base::RetainingOneShotTimer {
|
public:
|
SimpleAlarmTimer();
|
~SimpleAlarmTimer() override;
|
|
// Timer overrides.
|
void Stop() override;
|
void Reset() override;
|
|
private:
|
// Called when |alarm_fd_| is readable without blocking. Reads data from
|
// |alarm_fd_| and calls OnTimerFired().
|
void OnAlarmFdReadableWithoutBlocking();
|
|
// Called when the timer fires. Runs the callback.
|
void OnTimerFired();
|
|
// Tracks whether the timer has the ability to wake the system up from
|
// suspend. This is a runtime check because we won't know if the system
|
// supports being woken up from suspend until the constructor actually tries
|
// to set it up.
|
bool CanWakeFromSuspend() const;
|
|
// Timer file descriptor.
|
const int alarm_fd_;
|
|
// Watches |alarm_fd_|.
|
std::unique_ptr<base::FileDescriptorWatcher::Controller> alarm_fd_watcher_;
|
|
// Posts tasks to the sequence on which this AlarmTimer was instantiated.
|
const scoped_refptr<base::SequencedTaskRunner> origin_task_runner_ =
|
base::SequencedTaskRunnerHandle::Get();
|
|
// Keeps track of the user task we want to run. A new one is constructed every
|
// time Reset() is called.
|
std::unique_ptr<base::PendingTask> pending_task_;
|
|
// Used to invalidate pending callbacks.
|
base::WeakPtrFactory<SimpleAlarmTimer> weak_factory_;
|
|
DISALLOW_COPY_AND_ASSIGN(SimpleAlarmTimer);
|
};
|
|
} // namespace timers
|
|
#endif // COMPONENTS_TIMERS_ALARM_TIMER_CHROMEOS_H_
|
