[go: nahoru, domu]
Google Git
Sign in
chromium / chromium / src / main / . / base / run_loop.cc
blob: 72a884ffef613dd43de4d126eb871be68b43c582 [file] [log] [blame]
Avi Drissmane4622aa2022-09-08 20:36:06[diff] [blame]1// Copyright 2012 The Chromium Authors
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]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 "base/run_loop.h"
6
Wezd9e4cb772019-01-09 03:07:03[diff] [blame]7#include "base/cancelable_callback.h"
Gabriel Charette2a53350172021-05-06 20:22:55[diff] [blame]8#include "base/check.h"
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]9#include "base/compiler_specific.h"
Avi Drissman63e1f992023-01-13 18:54:43[diff] [blame]10#include "base/functional/bind.h"
11#include "base/functional/callback.h"
David Sanders97aac0de2022-02-07 14:33:53[diff] [blame]12#include "base/observer_list.h"
Patrick Monette643cdf62021-10-15 19:13:42[diff] [blame]13#include "base/task/single_thread_task_runner.h"
Gabriel Charettefbf3c622020-11-19 14:51:13[diff] [blame]14#include "base/trace_event/base_tracing.h"
avi9b6f42932015-12-26 22:15:14[diff] [blame]15#include "build/build_config.h"
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]16#include "third_party/abseil-cpp/absl/base/attributes.h"
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]17
18namespace base {
19
gab7af9dc02017-05-05 13:38:54[diff] [blame]20namespace {
21
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]22ABSL_CONST_INIT thread_local RunLoop::Delegate* delegate = nullptr;
23ABSL_CONST_INIT thread_local const RunLoop::RunLoopTimeout* run_loop_timeout =
24 nullptr;
gab7af9dc02017-05-05 13:38:54[diff] [blame]25
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]26// Runs |closure| immediately if this is called on |task_runner|, otherwise
27// forwards |closure| to it.
28void ProxyToTaskRunner(scoped_refptr<SequencedTaskRunner> task_runner,
29 OnceClosure closure) {
30 if (task_runner->RunsTasksInCurrentSequence()) {
31 std::move(closure).Run();
32 return;
33 }
34 task_runner->PostTask(FROM_HERE, std::move(closure));
35}
36
danakje125e8d62021-01-21 22:06:31[diff] [blame]37void OnRunLoopTimeout(RunLoop* run_loop,
38 const Location& location,
39 OnceCallback<void(const Location&)> on_timeout) {
Wezd9e4cb772019-01-09 03:07:03[diff] [blame]40 run_loop->Quit();
danakje125e8d62021-01-21 22:06:31[diff] [blame]41 std::move(on_timeout).Run(location);
Wezd9e4cb772019-01-09 03:07:03[diff] [blame]42}
43
gab7af9dc02017-05-05 13:38:54[diff] [blame]44} // namespace
45
Gabriel Charette50518fc2018-05-22 17:53:22[diff] [blame]46RunLoop::Delegate::Delegate() {
gab273551962017-05-18 06:01:10[diff] [blame]47 // The Delegate can be created on another thread. It is only bound in
48 // RegisterDelegateForCurrentThread().
49 DETACH_FROM_THREAD(bound_thread_checker_);
50}
51
52RunLoop::Delegate::~Delegate() {
53 DCHECK_CALLED_ON_VALID_THREAD(bound_thread_checker_);
Gabriel Charetteb87279d2019-06-27 03:21:04[diff] [blame]54 DCHECK(active_run_loops_.empty());
gab273551962017-05-18 06:01:10[diff] [blame]55 // A RunLoop::Delegate may be destroyed before it is bound, if so it may still
56 // be on its creation thread (e.g. a Thread that fails to start) and
57 // shouldn't disrupt that thread's state.
Yannic Bonenberger3dcd7fe2019-06-08 11:01:45[diff] [blame]58 if (bound_) {
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]59 DCHECK_EQ(this, delegate);
60 delegate = nullptr;
Yannic Bonenberger3dcd7fe2019-06-08 11:01:45[diff] [blame]61 }
gab273551962017-05-18 06:01:10[diff] [blame]62}
63
Gabriel Charettea3ec9612017-12-14 17:22:40[diff] [blame]64bool RunLoop::Delegate::ShouldQuitWhenIdle() {
Ali Hijazie63cbaf62023-12-20 19:29:35[diff] [blame]65 const auto* top_loop = active_run_loops_.top().get();
Gabriel Charette2a53350172021-05-06 20:22:55[diff] [blame]66 if (top_loop->quit_when_idle_) {
Bruce Dawson9066bfa2021-10-14 06:17:27[diff] [blame]67 TRACE_EVENT_WITH_FLOW0("toplevel.flow", "RunLoop_ExitedOnIdle",
68 TRACE_ID_LOCAL(top_loop), TRACE_EVENT_FLAG_FLOW_IN);
Gabriel Charettefbf3c622020-11-19 14:51:13[diff] [blame]69 return true;
70 }
71 return false;
gab273551962017-05-18 06:01:10[diff] [blame]72}
73
Gabriel Charette0592c3a2017-07-26 12:02:04[diff] [blame]74// static
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]75void RunLoop::RegisterDelegateForCurrentThread(Delegate* new_delegate) {
gab273551962017-05-18 06:01:10[diff] [blame]76 // Bind |delegate| to this thread.
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]77 DCHECK(!new_delegate->bound_);
78 DCHECK_CALLED_ON_VALID_THREAD(new_delegate->bound_thread_checker_);
gab273551962017-05-18 06:01:10[diff] [blame]79
80 // There can only be one RunLoop::Delegate per thread.
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]81 DCHECK(!delegate)
Gabriel Charettefa5e7f0d2018-01-29 12:08:21[diff] [blame]82 << "Error: Multiple RunLoop::Delegates registered on the same thread.\n\n"
83 "Hint: You perhaps instantiated a second "
Gabriel Charette694c3c332019-08-19 14:53:05[diff] [blame]84 "MessageLoop/TaskEnvironment on a thread that already had one?";
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]85 delegate = new_delegate;
gab273551962017-05-18 06:01:10[diff] [blame]86 delegate->bound_ = true;
gab273551962017-05-18 06:01:10[diff] [blame]87}
88
Gabriel Charette3ff403e2017-08-07 04:22:48[diff] [blame]89RunLoop::RunLoop(Type type)
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]90 : delegate_(delegate),
Gabriel Charette3ff403e2017-08-07 04:22:48[diff] [blame]91 type_(type),
Sean Maher7d0e8052022-12-09 01:46:32[diff] [blame]92 origin_task_runner_(SingleThreadTaskRunner::GetCurrentDefault()) {
Gabriel Charettee2b632b2017-08-02 03:52:16[diff] [blame]93 DCHECK(delegate_) << "A RunLoop::Delegate must be bound to this thread prior "
94 "to using RunLoop.";
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]95 DCHECK(origin_task_runner_);
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]96}
97
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]98RunLoop::~RunLoop() {
Gabriel Charette78fd3352019-08-01 23:24:15[diff] [blame]99 // ~RunLoop() must happen-after the RunLoop is done running but it doesn't
100 // have to be on |sequence_checker_| (it usually is but sometimes it can be a
101 // member of a RefCountedThreadSafe object and be destroyed on another thread
102 // after being quit).
103 DCHECK(!running_);
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]104}
105
danakje125e8d62021-01-21 22:06:31[diff] [blame]106void RunLoop::Run(const Location& location) {
gab980a52712017-05-18 16:20:16[diff] [blame]107 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
Alexander Timin26ac38f2021-10-05 00:50:36[diff] [blame]108 // "test" tracing category is used here because in regular scenarios RunLoop
109 // trace events are not useful (each process normally has one RunLoop covering
110 // its entire lifetime) and might be confusing (they make idle processes look
111 // non-idle). In tests, however, creating a RunLoop is a frequent and an
112 // explicit action making this trace event very useful.
113 TRACE_EVENT("test", "RunLoop::Run", "location", location);
gab7af9dc02017-05-05 13:38:54[diff] [blame]114
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]115 if (!BeforeRun())
116 return;
vadimt12f0f7d2014-09-15 19:19:38[diff] [blame]117
Wez9d5dd282020-02-10 17:21:22[diff] [blame]118 // If there is a RunLoopTimeout active then set the timeout.
Alison Gale59c007a2024-04-20 03:05:40[diff] [blame]119 // TODO(crbug.com/40602467): Use real-time for Run() timeouts so that they
Wezd9e4cb772019-01-09 03:07:03[diff] [blame]120 // can be applied even in tests which mock TimeTicks::Now().
121 CancelableOnceClosure cancelable_timeout;
Wez9d5dd282020-02-10 17:21:22[diff] [blame]122 const RunLoopTimeout* run_timeout = GetTimeoutForCurrentThread();
Wezbbffcc52019-02-21 02:01:20[diff] [blame]123 if (run_timeout) {
danakje125e8d62021-01-21 22:06:31[diff] [blame]124 cancelable_timeout.Reset(BindOnce(&OnRunLoopTimeout, Unretained(this),
125 location, run_timeout->on_timeout));
Wez9d5dd282020-02-10 17:21:22[diff] [blame]126 origin_task_runner_->PostDelayedTask(
127 FROM_HERE, cancelable_timeout.callback(), run_timeout->timeout);
Wezd9e4cb772019-01-09 03:07:03[diff] [blame]128 }
129
Gabriel Charetteb030a4a2017-10-26 01:04:40[diff] [blame]130 DCHECK_EQ(this, delegate_->active_run_loops_.top());
131 const bool application_tasks_allowed =
132 delegate_->active_run_loops_.size() == 1U ||
133 type_ == Type::kNestableTasksAllowed;
Alex Clarkecfde7b32019-08-15 17:11:47[diff] [blame]134 delegate_->Run(application_tasks_allowed, TimeDelta::Max());
vadimt12f0f7d2014-09-15 19:19:38[diff] [blame]135
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]136 AfterRun();
137}
138
139void RunLoop::RunUntilIdle() {
gab980a52712017-05-18 16:20:16[diff] [blame]140 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
gab7af9dc02017-05-05 13:38:54[diff] [blame]141
Gabriel Charette2a53350172021-05-06 20:22:55[diff] [blame]142 quit_when_idle_ = true;
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]143 Run();
Gabriel Charette2a53350172021-05-06 20:22:55[diff] [blame]144
145 if (!AnyQuitCalled()) {
146 quit_when_idle_ = false;
147#if DCHECK_IS_ON()
148 run_allowed_ = true;
149#endif
150 }
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]151}
152
153void RunLoop::Quit() {
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]154 // Thread-safe.
155
Gabriel Charette3a2ce022020-05-28 19:44:35[diff] [blame]156 // This can only be hit if RunLoop::Quit() is called directly (QuitClosure()
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]157 // proxies through ProxyToTaskRunner() as it can only deref its WeakPtr on
158 // |origin_task_runner_|).
159 if (!origin_task_runner_->RunsTasksInCurrentSequence()) {
Wezd9e4cb772019-01-09 03:07:03[diff] [blame]160 origin_task_runner_->PostTask(FROM_HERE,
161 BindOnce(&RunLoop::Quit, Unretained(this)));
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]162 return;
163 }
gab7af9dc02017-05-05 13:38:54[diff] [blame]164
Bruce Dawson9066bfa2021-10-14 06:17:27[diff] [blame]165 // While Quit() is an "OUT" call to reach one of the quit-states ("IN"),
166 // OUT|IN is used to visually link multiple Quit*() together which can help
167 // when debugging flaky tests.
168 TRACE_EVENT_WITH_FLOW0("toplevel.flow", "RunLoop::Quit", TRACE_ID_LOCAL(this),
169 TRACE_EVENT_FLAG_FLOW_OUT | TRACE_EVENT_FLAG_FLOW_IN);
Gabriel Charettefbf3c622020-11-19 14:51:13[diff] [blame]170
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]171 quit_called_ = true;
gab273551962017-05-18 06:01:10[diff] [blame]172 if (running_ && delegate_->active_run_loops_.top() == this) {
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]173 // This is the inner-most RunLoop, so quit now.
gab273551962017-05-18 06:01:10[diff] [blame]174 delegate_->Quit();
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]175 }
176}
177
fdoraya4f28ec2016-06-10 00:08:58[diff] [blame]178void RunLoop::QuitWhenIdle() {
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]179 // Thread-safe.
180
Gabriel Charette3a2ce022020-05-28 19:44:35[diff] [blame]181 // This can only be hit if RunLoop::QuitWhenIdle() is called directly
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]182 // (QuitWhenIdleClosure() proxies through ProxyToTaskRunner() as it can only
183 // deref its WeakPtr on |origin_task_runner_|).
184 if (!origin_task_runner_->RunsTasksInCurrentSequence()) {
185 origin_task_runner_->PostTask(
Wezd9e4cb772019-01-09 03:07:03[diff] [blame]186 FROM_HERE, BindOnce(&RunLoop::QuitWhenIdle, Unretained(this)));
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]187 return;
188 }
189
Bruce Dawson9066bfa2021-10-14 06:17:27[diff] [blame]190 // OUT|IN as in Quit() to link all Quit*() together should there be multiple.
191 TRACE_EVENT_WITH_FLOW0("toplevel.flow", "RunLoop::QuitWhenIdle",
192 TRACE_ID_LOCAL(this),
193 TRACE_EVENT_FLAG_FLOW_OUT | TRACE_EVENT_FLAG_FLOW_IN);
Gabriel Charettefbf3c622020-11-19 14:51:13[diff] [blame]194
Gabriel Charette2a53350172021-05-06 20:22:55[diff] [blame]195 quit_when_idle_ = true;
196 quit_when_idle_called_ = true;
fdoraya4f28ec2016-06-10 00:08:58[diff] [blame]197}
198
kylechar650caf02019-07-17 03:25:41[diff] [blame]199RepeatingClosure RunLoop::QuitClosure() {
Gabriel Charette3a2ce022020-05-28 19:44:35[diff] [blame]200 // Obtaining the QuitClosure() is not thread-safe; either obtain the
201 // QuitClosure() from the owning thread before Run() or invoke Quit() directly
202 // (which is thread-safe).
Gabriel Charetted913e5b2019-06-27 05:41:59[diff] [blame]203 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]204
kylechar650caf02019-07-17 03:25:41[diff] [blame]205 return BindRepeating(
206 &ProxyToTaskRunner, origin_task_runner_,
207 BindRepeating(&RunLoop::Quit, weak_factory_.GetWeakPtr()));
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]208}
209
kylechar650caf02019-07-17 03:25:41[diff] [blame]210RepeatingClosure RunLoop::QuitWhenIdleClosure() {
Gabriel Charette3a2ce022020-05-28 19:44:35[diff] [blame]211 // Obtaining the QuitWhenIdleClosure() is not thread-safe; either obtain the
212 // QuitWhenIdleClosure() from the owning thread before Run() or invoke
213 // QuitWhenIdle() directly (which is thread-safe).
Gabriel Charetted913e5b2019-06-27 05:41:59[diff] [blame]214 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]215
kylechar650caf02019-07-17 03:25:41[diff] [blame]216 return BindRepeating(
217 &ProxyToTaskRunner, origin_task_runner_,
218 BindRepeating(&RunLoop::QuitWhenIdle, weak_factory_.GetWeakPtr()));
fdoraya3658602016-06-10 18:23:15[diff] [blame]219}
220
Gabriel Charette2a53350172021-05-06 20:22:55[diff] [blame]221bool RunLoop::AnyQuitCalled() {
222 return quit_called_ || quit_when_idle_called_;
223}
224
gab7af9dc02017-05-05 13:38:54[diff] [blame]225// static
gab7af9dc02017-05-05 13:38:54[diff] [blame]226bool RunLoop::IsRunningOnCurrentThread() {
gab273551962017-05-18 06:01:10[diff] [blame]227 return delegate && !delegate->active_run_loops_.empty();
gab7af9dc02017-05-05 13:38:54[diff] [blame]228}
229
230// static
231bool RunLoop::IsNestedOnCurrentThread() {
gab273551962017-05-18 06:01:10[diff] [blame]232 return delegate && delegate->active_run_loops_.size() > 1;
gab7af9dc02017-05-05 13:38:54[diff] [blame]233}
234
235// static
236void RunLoop::AddNestingObserverOnCurrentThread(NestingObserver* observer) {
gab273551962017-05-18 06:01:10[diff] [blame]237 DCHECK(delegate);
gab273551962017-05-18 06:01:10[diff] [blame]238 delegate->nesting_observers_.AddObserver(observer);
gab7af9dc02017-05-05 13:38:54[diff] [blame]239}
240
241// static
242void RunLoop::RemoveNestingObserverOnCurrentThread(NestingObserver* observer) {
gab273551962017-05-18 06:01:10[diff] [blame]243 DCHECK(delegate);
gab273551962017-05-18 06:01:10[diff] [blame]244 delegate->nesting_observers_.RemoveObserver(observer);
gab7af9dc02017-05-05 13:38:54[diff] [blame]245}
246
Gabriel Charette5bc88412018-05-16 03:28:25[diff] [blame]247
Gabriel Charettea44975052017-08-21 23:14:04[diff] [blame]248#if DCHECK_IS_ON()
Hans Wennborg9b292ba2022-02-15 16:01:29[diff] [blame]249ScopedDisallowRunningRunLoop::ScopedDisallowRunningRunLoop()
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]250 : current_delegate_(delegate),
251 previous_run_allowance_(current_delegate_ &&
252 current_delegate_->allow_running_for_testing_) {
Gabriel Charettea44975052017-08-21 23:14:04[diff] [blame]253 if (current_delegate_)
254 current_delegate_->allow_running_for_testing_ = false;
255}
256
Hans Wennborg9b292ba2022-02-15 16:01:29[diff] [blame]257ScopedDisallowRunningRunLoop::~ScopedDisallowRunningRunLoop() {
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]258 DCHECK_EQ(current_delegate_, delegate);
Gabriel Charettea44975052017-08-21 23:14:04[diff] [blame]259 if (current_delegate_)
260 current_delegate_->allow_running_for_testing_ = previous_run_allowance_;
261}
262#else // DCHECK_IS_ON()
263// Defined out of line so that the compiler doesn't inline these and realize
264// the scope has no effect and then throws an "unused variable" warning in
265// non-dcheck builds.
Hans Wennborg9b292ba2022-02-15 16:01:29[diff] [blame]266ScopedDisallowRunningRunLoop::ScopedDisallowRunningRunLoop() = default;
267ScopedDisallowRunningRunLoop::~ScopedDisallowRunningRunLoop() = default;
Gabriel Charettea44975052017-08-21 23:14:04[diff] [blame]268#endif // DCHECK_IS_ON()
269
Wez9d5dd282020-02-10 17:21:22[diff] [blame]270RunLoop::RunLoopTimeout::RunLoopTimeout() = default;
271
272RunLoop::RunLoopTimeout::~RunLoopTimeout() = default;
273
274// static
275void RunLoop::SetTimeoutForCurrentThread(const RunLoopTimeout* timeout) {
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]276 run_loop_timeout = timeout;
Wez9d5dd282020-02-10 17:21:22[diff] [blame]277}
278
279// static
280const RunLoop::RunLoopTimeout* RunLoop::GetTimeoutForCurrentThread() {
Peter Kasting960e2d32023-03-14 17:18:41[diff] [blame]281 // Workaround false-positive MSAN use-of-uninitialized-value on
282 // thread_local storage for loaded libraries:
283 // https://github.com/google/sanitizers/issues/1265
284 MSAN_UNPOISON(&run_loop_timeout, sizeof(RunLoopTimeout*));
285
286 return run_loop_timeout;
Wez212eeb72020-02-04 17:54:54[diff] [blame]287}
288
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]289bool RunLoop::BeforeRun() {
gab980a52712017-05-18 16:20:16[diff] [blame]290 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
gab7af9dc02017-05-05 13:38:54[diff] [blame]291
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]292#if DCHECK_IS_ON()
Gabriel Charettea44975052017-08-21 23:14:04[diff] [blame]293 DCHECK(delegate_->allow_running_for_testing_)
294 << "RunLoop::Run() isn't allowed in the scope of a "
Hans Wennborg9b292ba2022-02-15 16:01:29[diff] [blame]295 "ScopedDisallowRunningRunLoop. Hint: if mixing "
Gabriel Charettea44975052017-08-21 23:14:04[diff] [blame]296 "TestMockTimeTaskRunners on same thread, use TestMockTimeTaskRunner's "
297 "API instead of RunLoop to drive individual task runners.";
Gabriel Charette2a53350172021-05-06 20:22:55[diff] [blame]298 DCHECK(run_allowed_);
299 run_allowed_ = false;
gabcf5e4ce2017-05-19 22:56:57[diff] [blame]300#endif // DCHECK_IS_ON()
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]301
302 // Allow Quit to be called before Run.
Gabriel Charettefbf3c622020-11-19 14:51:13[diff] [blame]303 if (quit_called_) {
Bruce Dawson9066bfa2021-10-14 06:17:27[diff] [blame]304 TRACE_EVENT_WITH_FLOW0("toplevel.flow", "RunLoop_ExitedEarly",
305 TRACE_ID_LOCAL(this), TRACE_EVENT_FLAG_FLOW_IN);
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]306 return false;
Gabriel Charettefbf3c622020-11-19 14:51:13[diff] [blame]307 }
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]308
Gabriel Charetteb87279d2019-06-27 03:21:04[diff] [blame]309 auto& active_run_loops = delegate_->active_run_loops_;
310 active_run_loops.push(this);
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]311
Gabriel Charetteb87279d2019-06-27 03:21:04[diff] [blame]312 const bool is_nested = active_run_loops.size() > 1;
gab7af9dc02017-05-05 13:38:54[diff] [blame]313
314 if (is_nested) {
gab273551962017-05-18 06:01:10[diff] [blame]315 for (auto& observer : delegate_->nesting_observers_)
gab7af9dc02017-05-05 13:38:54[diff] [blame]316 observer.OnBeginNestedRunLoop();
Gabriel Charette3ff403e2017-08-07 04:22:48[diff] [blame]317 if (type_ == Type::kNestableTasksAllowed)
318 delegate_->EnsureWorkScheduled();
gab7af9dc02017-05-05 13:38:54[diff] [blame]319 }
jamescookaacdfd02016-04-28 00:50:03[diff] [blame]320
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]321 running_ = true;
322 return true;
323}
324
325void RunLoop::AfterRun() {
gab980a52712017-05-18 16:20:16[diff] [blame]326 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
gab7af9dc02017-05-05 13:38:54[diff] [blame]327
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]328 running_ = false;
329
Bruce Dawson9066bfa2021-10-14 06:17:27[diff] [blame]330 TRACE_EVENT_WITH_FLOW0("toplevel.flow", "RunLoop_Exited",
331 TRACE_ID_LOCAL(this), TRACE_EVENT_FLAG_FLOW_IN);
Gabriel Charettefbf3c622020-11-19 14:51:13[diff] [blame]332
Gabriel Charetteb87279d2019-06-27 03:21:04[diff] [blame]333 auto& active_run_loops = delegate_->active_run_loops_;
334 DCHECK_EQ(active_run_loops.top(), this);
335 active_run_loops.pop();
gab7af9dc02017-05-05 13:38:54[diff] [blame]336
Gabriel Charetteb87279d2019-06-27 03:21:04[diff] [blame]337 // Exiting a nested RunLoop?
338 if (!active_run_loops.empty()) {
Francois Doray80bdddf2018-01-04 16:17:32[diff] [blame]339 for (auto& observer : delegate_->nesting_observers_)
340 observer.OnExitNestedRunLoop();
Francois Doray80bdddf2018-01-04 16:17:32[diff] [blame]341
Gabriel Charetteb87279d2019-06-27 03:21:04[diff] [blame]342 // Execute deferred Quit, if any:
343 if (active_run_loops.top()->quit_called_)
344 delegate_->Quit();
345 }
jbates@chromium.org8e937c1e2012-06-28 22:57:30[diff] [blame]346}
347
348} // namespace base