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
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/scheduler/public/post_cancellable_task.h"
#include "base/memory/weak_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "third_party/blink/renderer/platform/wtf/functional.h"
#include "third_party/blink/renderer/platform/wtf/thread_safe_ref_counted.h"
namespace blink {
class TaskHandle::Runner : public WTF::ThreadSafeRefCounted<Runner> {
public:
explicit Runner(base::OnceClosure task) : task_(std::move(task)) {}
Runner(const Runner&) = delete;
Runner& operator=(const Runner&) = delete;
base::WeakPtr<Runner> AsWeakPtr() { return weak_ptr_factory_.GetWeakPtr(); }
bool IsActive() const { return task_ && !task_.IsCancelled(); }
void Cancel() {
base::OnceClosure task = std::move(task_);
weak_ptr_factory_.InvalidateWeakPtrs();
}
~Runner() { Cancel(); }
// The TaskHandle parameter on run() holds a reference to the Runner to keep
// it alive while a task is pending in a task queue, and clears the reference
// on the task disposal, so that it doesn't leave a circular reference like
// below:
// struct Foo : GarbageCollected<Foo> {
// void bar() {}
// TaskHandle m_handle;
// };
//
// foo.m_handle = taskRunner->postCancellableTask(
// FROM_HERE, WTF::bind(&Foo::bar, wrapPersistent(foo)));
//
// There is a circular reference in the example above as:
// foo -> m_handle -> m_runner -> m_task -> Persistent<Foo> in WTF::bind.
// The TaskHandle parameter on run() is needed to break the circle by clearing
// |m_task| when the wrapped base::OnceClosure is deleted.
void Run(const TaskHandle&) {
base::OnceClosure task = std::move(task_);
weak_ptr_factory_.InvalidateWeakPtrs();
std::move(task).Run();
}
private:
base::OnceClosure task_;
base::WeakPtrFactory<Runner> weak_ptr_factory_{this};
};
} // namespace blink
namespace base {
using RunnerMethodType =
void (blink::TaskHandle::Runner::*)(const blink::TaskHandle&);
template <>
struct CallbackCancellationTraits<
RunnerMethodType,
std::tuple<base::WeakPtr<blink::TaskHandle::Runner>, blink::TaskHandle>> {
static constexpr bool is_cancellable = true;
static bool IsCancelled(RunnerMethodType,
const base::WeakPtr<blink::TaskHandle::Runner>&,
const blink::TaskHandle& handle) {
return !handle.IsActive();
}
static bool MaybeValid(RunnerMethodType,
const base::WeakPtr<blink::TaskHandle::Runner>&,
const blink::TaskHandle& handle) {
// TODO(https://crbug.com/653394): Consider returning a thread-safe best
// guess of validity.
return true;
}
};
} // namespace base
namespace blink {
bool TaskHandle::IsActive() const {
return runner_ && runner_->IsActive();
}
void TaskHandle::Cancel() {
if (runner_) {
runner_->Cancel();
runner_ = nullptr;
}
}
TaskHandle::TaskHandle() = default;
TaskHandle::~TaskHandle() {
Cancel();
}
TaskHandle::TaskHandle(TaskHandle&&) = default;
TaskHandle& TaskHandle::operator=(TaskHandle&& other) {
TaskHandle tmp(std::move(other));
runner_.swap(tmp.runner_);
return *this;
}
TaskHandle::TaskHandle(scoped_refptr<Runner> runner)
: runner_(std::move(runner)) {
DCHECK(runner_);
}
TaskHandle PostCancellableTask(base::SequencedTaskRunner& task_runner,
const base::Location& location,
base::OnceClosure task) {
DCHECK(task_runner.RunsTasksInCurrentSequence());
scoped_refptr<TaskHandle::Runner> runner =
base::AdoptRef(new TaskHandle::Runner(std::move(task)));
task_runner.PostTask(
location, WTF::BindOnce(&TaskHandle::Runner::Run, runner->AsWeakPtr(),
TaskHandle(runner)));
return TaskHandle(runner);
}
TaskHandle PostDelayedCancellableTask(base::SequencedTaskRunner& task_runner,
const base::Location& location,
base::OnceClosure task,
base::TimeDelta delay) {
DCHECK(task_runner.RunsTasksInCurrentSequence());
scoped_refptr<TaskHandle::Runner> runner =
base::AdoptRef(new TaskHandle::Runner(std::move(task)));
task_runner.PostDelayedTask(
location,
WTF::BindOnce(&TaskHandle::Runner::Run, runner->AsWeakPtr(),
TaskHandle(runner)),
delay);
return TaskHandle(runner);
}
TaskHandle PostNonNestableCancellableTask(
base::SequencedTaskRunner& task_runner,
const base::Location& location,
base::OnceClosure task) {
DCHECK(task_runner.RunsTasksInCurrentSequence());
scoped_refptr<TaskHandle::Runner> runner =
base::AdoptRef(new TaskHandle::Runner(std::move(task)));
task_runner.PostNonNestableTask(
location, WTF::BindOnce(&TaskHandle::Runner::Run, runner->AsWeakPtr(),
TaskHandle(runner)));
return TaskHandle(runner);
}
TaskHandle PostNonNestableDelayedCancellableTask(
base::SequencedTaskRunner& task_runner,
const base::Location& location,
base::OnceClosure task,
base::TimeDelta delay) {
DCHECK(task_runner.RunsTasksInCurrentSequence());
scoped_refptr<TaskHandle::Runner> runner =
base::AdoptRef(new TaskHandle::Runner(std::move(task)));
task_runner.PostNonNestableDelayedTask(
location,
WTF::BindOnce(&TaskHandle::Runner::Run, runner->AsWeakPtr(),
TaskHandle(runner)),
delay);
return TaskHandle(runner);
}
} // namespace blink
|
