137 lines
4.5 KiB
C++
137 lines
4.5 KiB
C++
// Copyright 2016 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 BASE_TASK_THREAD_POOL_DELAYED_TASK_MANAGER_H_
|
|
#define BASE_TASK_THREAD_POOL_DELAYED_TASK_MANAGER_H_
|
|
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
#include "base/base_export.h"
|
|
#include "base/callback.h"
|
|
#include "base/macros.h"
|
|
#include "base/memory/ptr_util.h"
|
|
#include "base/memory/ref_counted.h"
|
|
#include "base/optional.h"
|
|
#include "base/synchronization/atomic_flag.h"
|
|
#include "base/task/common/checked_lock.h"
|
|
#include "base/task/common/intrusive_heap.h"
|
|
#include "base/task/thread_pool/task.h"
|
|
#include "base/thread_annotations.h"
|
|
#include "base/time/default_tick_clock.h"
|
|
#include "base/time/tick_clock.h"
|
|
|
|
namespace base {
|
|
|
|
class SequencedTaskRunner;
|
|
|
|
namespace internal {
|
|
|
|
// The DelayedTaskManager forwards tasks to post task callbacks when they become
|
|
// ripe for execution. Tasks are not forwarded before Start() is called. This
|
|
// class is thread-safe.
|
|
class BASE_EXPORT DelayedTaskManager {
|
|
public:
|
|
// Posts |task| for execution immediately.
|
|
using PostTaskNowCallback = OnceCallback<void(Task task)>;
|
|
|
|
// |tick_clock| can be specified for testing.
|
|
DelayedTaskManager(
|
|
const TickClock* tick_clock = DefaultTickClock::GetInstance());
|
|
~DelayedTaskManager();
|
|
|
|
// Starts the delayed task manager, allowing past and future tasks to be
|
|
// forwarded to their callbacks as they become ripe for execution.
|
|
// |service_thread_task_runner| posts tasks to the ThreadPool service
|
|
// thread.
|
|
void Start(scoped_refptr<SequencedTaskRunner> service_thread_task_runner);
|
|
|
|
// Schedules a call to |post_task_now_callback| with |task| as argument when
|
|
// |task| is ripe for execution. |task_runner| is passed to retain a
|
|
// reference until |task| is ripe.
|
|
void AddDelayedTask(Task task,
|
|
PostTaskNowCallback post_task_now_callback,
|
|
scoped_refptr<TaskRunner> task_runner);
|
|
|
|
// Pop and post all the ripe tasks in the delayed task queue.
|
|
void ProcessRipeTasks();
|
|
|
|
// Returns the |delayed_run_time| of the next scheduled task, if any.
|
|
Optional<TimeTicks> NextScheduledRunTime() const;
|
|
|
|
private:
|
|
struct DelayedTask {
|
|
DelayedTask();
|
|
DelayedTask(Task task,
|
|
PostTaskNowCallback callback,
|
|
scoped_refptr<TaskRunner> task_runner);
|
|
DelayedTask(DelayedTask&& other);
|
|
~DelayedTask();
|
|
|
|
// Required by IntrusiveHeap::insert().
|
|
DelayedTask& operator=(DelayedTask&& other);
|
|
|
|
// Required by IntrusiveHeap.
|
|
bool operator<=(const DelayedTask& other) const;
|
|
|
|
Task task;
|
|
PostTaskNowCallback callback;
|
|
scoped_refptr<TaskRunner> task_runner;
|
|
|
|
// True iff the delayed task has been marked as scheduled.
|
|
bool IsScheduled() const;
|
|
|
|
// Mark the delayed task as scheduled. Since the sort key is
|
|
// |task.delayed_run_time|, it does not alter sort order when it is called.
|
|
void SetScheduled();
|
|
|
|
// Required by IntrusiveHeap.
|
|
void SetHeapHandle(const HeapHandle& handle) {}
|
|
|
|
// Required by IntrusiveHeap.
|
|
void ClearHeapHandle() {}
|
|
|
|
// Required by IntrusiveHeap.
|
|
HeapHandle GetHeapHandle() const { return HeapHandle::Invalid(); }
|
|
|
|
private:
|
|
bool scheduled_ = false;
|
|
DISALLOW_COPY_AND_ASSIGN(DelayedTask);
|
|
};
|
|
|
|
// Get the time at which to schedule the next |ProcessRipeTasks()| execution,
|
|
// or TimeTicks::Max() if none needs to be scheduled (i.e. no task, or next
|
|
// task already scheduled).
|
|
TimeTicks GetTimeToScheduleProcessRipeTasksLockRequired()
|
|
EXCLUSIVE_LOCKS_REQUIRED(queue_lock_);
|
|
|
|
// Schedule |ProcessRipeTasks()| on the service thread to be executed at the
|
|
// given |process_ripe_tasks_time|, provided the given time is not
|
|
// TimeTicks::Max().
|
|
void ScheduleProcessRipeTasksOnServiceThread(
|
|
TimeTicks process_ripe_tasks_time);
|
|
|
|
const RepeatingClosure process_ripe_tasks_closure_;
|
|
|
|
const TickClock* const tick_clock_;
|
|
|
|
// Synchronizes access to |delayed_task_queue_| and the setting of
|
|
// |service_thread_task_runner_|. Once |service_thread_task_runner_| is set,
|
|
// it is never modified. It is therefore safe to access
|
|
// |service_thread_task_runner_| without synchronization once it is observed
|
|
// that it is non-null.
|
|
mutable CheckedLock queue_lock_;
|
|
|
|
scoped_refptr<SequencedTaskRunner> service_thread_task_runner_;
|
|
|
|
IntrusiveHeap<DelayedTask> delayed_task_queue_ GUARDED_BY(queue_lock_);
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(DelayedTaskManager);
|
|
};
|
|
|
|
} // namespace internal
|
|
} // namespace base
|
|
|
|
#endif // BASE_TASK_THREAD_POOL_DELAYED_TASK_MANAGER_H_
|