1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
// Copyright 2015 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 CONTENT_RENDERER_SCHEDULER_TASK_QUEUE_IMPL_H_
#define CONTENT_RENDERER_SCHEDULER_TASK_QUEUE_IMPL_H_
#include <set>
#include "base/pending_task.h"
#include "base/threading/thread_checker.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/trace_event_argument.h"
#include "components/scheduler/child/lazy_now.h"
#include "components/scheduler/child/task_queue.h"
#include "components/scheduler/scheduler_export.h"
namespace scheduler {
class TaskQueueManager;
namespace internal {
class SCHEDULER_EXPORT TaskQueueImpl final : public TaskQueue {
public:
TaskQueueImpl(TaskQueueManager* task_queue_manager,
const Spec& spec,
const char* disabled_by_default_tracing_category,
const char* disabled_by_default_verbose_tracing_category);
class SCHEDULER_EXPORT Task : public base::PendingTask {
public:
Task();
Task(const tracked_objects::Location& posted_from,
const base::Closure& task,
int sequence_number,
bool nestable);
int enqueue_order() const {
#ifndef NDEBUG
DCHECK(enqueue_order_set_);
#endif
return enqueue_order_;
}
void set_enqueue_order(int enqueue_order) {
#ifndef NDEBUG
DCHECK(!enqueue_order_set_);
enqueue_order_set_ = true;
#endif
enqueue_order_ = enqueue_order;
}
private:
#ifndef NDEBUG
bool enqueue_order_set_;
#endif
// Similar to sequence number, but the |enqueue_order| is set by
// EnqueueTasksLocked and is not initially defined for delayed tasks until
// they are enqueued on the |incoming_queue_|.
int enqueue_order_;
};
// TaskQueue implementation.
bool RunsTasksOnCurrentThread() const override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
const base::Closure& task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
const base::Closure& task,
base::TimeDelta delay) override;
bool PostDelayedTaskAt(const tracked_objects::Location& from_here,
const base::Closure& task,
base::TimeTicks desired_run_time) override;
bool IsQueueEnabled() const override;
QueueState GetQueueState() const override;
void SetQueuePriority(QueuePriority priority) override;
void PumpQueue() override;
void SetPumpPolicy(PumpPolicy pump_policy) override;
bool NextPendingDelayedTaskRunTime(
base::TimeTicks* next_pending_delayed_task);
void UpdateWorkQueue(LazyNow* lazy_now,
bool should_trigger_wakeup,
const Task* previous_task);
Task TakeTaskFromWorkQueue();
void WillDeleteTaskQueueManager();
std::queue<Task>& work_queue() { return work_queue_; }
WakeupPolicy wakeup_policy() const {
DCHECK(main_thread_checker_.CalledOnValidThread());
return wakeup_policy_;
}
const char* GetName() const override;
void AsValueInto(base::trace_event::TracedValue* state) const;
size_t get_task_queue_set_index() const { return set_index_; }
void set_task_queue_set_index(size_t set_index) { set_index_ = set_index; }
// If the work queue isn't empty, |enqueue_order| gets set to the enqueue
// order of the front task and the function returns true. Otherwise the
// function returns false.
bool GetWorkQueueFrontTaskEnqueueOrder(int* enqueue_order) const;
bool GetQuiescenceMonitored() const { return should_monitor_quiescence_; }
bool GetShouldNotifyObservers() const { return should_notify_observers_; }
// Delayed task posted to the underlying run loop, which locks |lock_| and
// calls MoveReadyDelayedTasksToIncomingQueueLocked to process dealyed tasks
// that need to be run now.
void MoveReadyDelayedTasksToIncomingQueue(LazyNow* lazy_now);
// Test support functions. These should not be used in production code.
void PushTaskOntoWorkQueueForTest(const Task& task);
void PopTaskFromWorkQueueForTest();
size_t WorkQueueSizeForTest() const { return work_queue_.size(); }
// Can be called on any thread.
static const char* PumpPolicyToString(TaskQueue::PumpPolicy pump_policy);
// Can be called on any thread.
static const char* WakeupPolicyToString(
TaskQueue::WakeupPolicy wakeup_policy);
// Can be called on any thread.
static const char* PriorityToString(TaskQueue::QueuePriority priority);
private:
enum class TaskType {
NORMAL,
NON_NESTABLE,
};
~TaskQueueImpl() override;
bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
const base::Closure& task,
base::TimeDelta delay,
TaskType task_type);
bool PostDelayedTaskLocked(LazyNow* lazy_now,
const tracked_objects::Location& from_here,
const base::Closure& task,
base::TimeTicks desired_run_time,
TaskType task_type);
// Enqueues any delayed tasks which should be run now on the incoming_queue_
// and calls ScheduleDelayedWorkLocked to ensure future tasks are scheduled.
// Must be called with |lock_| locked.
void MoveReadyDelayedTasksToIncomingQueueLocked(LazyNow* lazy_now);
void PumpQueueLocked();
bool TaskIsOlderThanQueuedTasks(const Task* task);
bool ShouldAutoPumpQueueLocked(bool should_trigger_wakeup,
const Task* previous_task);
// Push the task onto the |incoming_queue_| and for auto pumped queues it
// calls MaybePostDoWorkOnMainRunner if the incomming queue was empty.
void EnqueueTaskLocked(const Task& pending_task);
// Push the task onto the |incoming_queue_| and allocates an
// enqueue_order for it based on |enqueue_order_policy|. Does not call
// MaybePostDoWorkOnMainRunner!
void EnqueueDelayedTaskLocked(const Task& pending_task);
void TraceQueueSize(bool is_locked) const;
static void QueueAsValueInto(const std::queue<Task>& queue,
base::trace_event::TracedValue* state);
static void QueueAsValueInto(const std::priority_queue<Task>& queue,
base::trace_event::TracedValue* state);
static void TaskAsValueInto(const Task& task,
base::trace_event::TracedValue* state);
// This lock protects all members in the contigious block below.
// TODO(alexclarke): Group all the members protected by the lock into a struct
mutable base::Lock lock_;
base::PlatformThreadId thread_id_;
TaskQueueManager* task_queue_manager_;
std::queue<Task> incoming_queue_;
PumpPolicy pump_policy_;
std::priority_queue<Task> delayed_task_queue_;
std::set<base::TimeTicks> in_flight_kick_delayed_tasks_;
const char* name_;
const char* disabled_by_default_tracing_category_;
const char* disabled_by_default_verbose_tracing_category_;
base::ThreadChecker main_thread_checker_;
std::queue<Task> work_queue_;
WakeupPolicy wakeup_policy_;
size_t set_index_;
bool should_monitor_quiescence_;
bool should_notify_observers_;
DISALLOW_COPY_AND_ASSIGN(TaskQueueImpl);
};
} // namespace internal
} // namespace scheduler
#endif // CONTENT_RENDERER_SCHEDULER_TASK_QUEUE_IMPL_H_
|
