Thanks to visit codestin.com
Credit goes to chromium.googlesource.com

Google Git
Sign in
chromium / chromium / src / main / . / base / task / current_thread.cc
blob: e97435f1705a929ec02848b88b4fe05bdf7399e4 [file] [log] [blame]
Avi Drissmane4622aa2022-09-08 20:36:06[diff] [blame]1// Copyright 2018 The Chromium Authors
Gabriel Charette01b83012018-04-13 20:29:35[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
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]5#include "base/task/current_thread.h"
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]6
Jan Keitel748d58e02024-01-19 21:55:38[diff] [blame]7#include <utility>
8
9#include "base/callback_list.h"
Avi Drissman63e1f992023-01-13 18:54:43[diff] [blame]10#include "base/functional/bind.h"
11#include "base/functional/callback.h"
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]12#include "base/message_loop/message_pump_for_io.h"
13#include "base/message_loop/message_pump_for_ui.h"
Carlos Caballerodd8bf7b042019-07-30 14:14:15[diff] [blame]14#include "base/message_loop/message_pump_type.h"
Carlos Caballero128dc1f12019-03-20 10:46:11[diff] [blame]15#include "base/task/sequence_manager/sequence_manager_impl.h"
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]16#include "base/threading/thread_local.h"
Etienne Pierre-dorayfc7952f02025-06-06 00:04:33[diff] [blame]17#include "base/trace_event/trace_event.h"
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]18#include "build/build_config.h"
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]19
20namespace base {
21
22//------------------------------------------------------------------------------
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]23// CurrentThread
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]24
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]25// static
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]26sequence_manager::internal::SequenceManagerImpl*
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]27CurrentThread::GetCurrentSequenceManagerImpl() {
Carlos Caballero128dc1f12019-03-20 10:46:11[diff] [blame]28 return sequence_manager::internal::SequenceManagerImpl::GetCurrent();
29}
30
31// static
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]32CurrentThread CurrentThread::Get() {
33 return CurrentThread(GetCurrentSequenceManagerImpl());
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]34}
35
36// static
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]37CurrentThread CurrentThread::GetNull() {
38 return CurrentThread(nullptr);
Alexander Timin35cc3302018-10-31 18:54:49[diff] [blame]39}
40
41// static
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]42bool CurrentThread::IsSet() {
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]43 return !!GetCurrentSequenceManagerImpl();
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]44}
45
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]46void CurrentThread::AddDestructionObserver(
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]47 DestructionObserver* destruction_observer) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]48 DCHECK(current_->IsBoundToCurrentThread());
49 current_->AddDestructionObserver(destruction_observer);
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]50}
51
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]52void CurrentThread::RemoveDestructionObserver(
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]53 DestructionObserver* destruction_observer) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]54 DCHECK(current_->IsBoundToCurrentThread());
55 current_->RemoveDestructionObserver(destruction_observer);
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]56}
57
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]58void CurrentThread::SetTaskRunner(
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]59 scoped_refptr<SingleThreadTaskRunner> task_runner) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]60 DCHECK(current_->IsBoundToCurrentThread());
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]61 current_->SetTaskRunner(std::move(task_runner));
62}
63
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]64bool CurrentThread::IsBoundToCurrentThread() const {
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]65 return current_ == GetCurrentSequenceManagerImpl();
Alexander Timind1e773cb2018-10-26 14:19:03[diff] [blame]66}
67
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]68bool CurrentThread::IsIdleForTesting() {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]69 DCHECK(current_->IsBoundToCurrentThread());
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]70 return current_->IsIdleForTesting();
71}
72
Gabriel Charette5dd30f12022-07-09 15:14:22[diff] [blame]73void CurrentThread::EnableMessagePumpTimeKeeperMetrics(
henrika3cee59b2024-05-03 16:20:52[diff] [blame]74 const char* thread_name,
75 bool wall_time_based_metrics_enabled_for_testing) {
76 return current_->EnableMessagePumpTimeKeeperMetrics(
77 thread_name, wall_time_based_metrics_enabled_for_testing);
Gabriel Charette5dd30f12022-07-09 15:14:22[diff] [blame]78}
79
Ken Rockot2276a612024-11-22 23:08:44[diff] [blame]80IOWatcher* CurrentThread::GetIOWatcher() {
81 DCHECK(current_->IsBoundToCurrentThread());
82 return current_->GetMessagePump()->GetIOWatcher();
83}
84
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]85void CurrentThread::AddTaskObserver(TaskObserver* task_observer) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]86 DCHECK(current_->IsBoundToCurrentThread());
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]87 current_->AddTaskObserver(task_observer);
88}
89
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]90void CurrentThread::RemoveTaskObserver(TaskObserver* task_observer) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]91 DCHECK(current_->IsBoundToCurrentThread());
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]92 current_->RemoveTaskObserver(task_observer);
93}
94
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]95void CurrentThread::SetAddQueueTimeToTasks(bool enable) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]96 DCHECK(current_->IsBoundToCurrentThread());
Erik Chena95335192018-07-30 17:48:22[diff] [blame]97 current_->SetAddQueueTimeToTasks(enable);
98}
99
Jan Keitel748d58e02024-01-19 21:55:38[diff] [blame]100CallbackListSubscription CurrentThread::RegisterOnNextIdleCallback(
101 RegisterOnNextIdleCallbackPasskey,
Gabriel Charettea2232cce2021-12-01 01:00:18[diff] [blame]102 OnceClosure on_next_idle_callback) {
Jan Keitel748d58e02024-01-19 21:55:38[diff] [blame]103 return current_->RegisterOnNextIdleCallback(std::move(on_next_idle_callback));
Gabriel Charettea2232cce2021-12-01 01:00:18[diff] [blame]104}
105
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]106CurrentThread::ScopedAllowApplicationTasksInNativeNestedLoop::
Gabriel Charette69e7ddc52020-06-04 17:42:12[diff] [blame]107 ScopedAllowApplicationTasksInNativeNestedLoop()
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]108 : sequence_manager_(GetCurrentSequenceManagerImpl()),
Sean Mahere5d5f6932024-04-04 18:07:33[diff] [blame]109 previous_state_(
110 sequence_manager_->IsTaskExecutionAllowedInNativeNestedLoop()) {
Gabriel Charetteb1c3f2d2020-05-29 20:16:37[diff] [blame]111 TRACE_EVENT_BEGIN0("base", "ScopedNestableTaskAllower");
Sean Mahere5d5f6932024-04-04 18:07:33[diff] [blame]112 sequence_manager_->SetTaskExecutionAllowedInNativeNestedLoop(true);
Gabriel Charettec25437c62018-04-17 00:48:44[diff] [blame]113}
114
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]115CurrentThread::ScopedAllowApplicationTasksInNativeNestedLoop::
Gabriel Charette69e7ddc52020-06-04 17:42:12[diff] [blame]116 ~ScopedAllowApplicationTasksInNativeNestedLoop() {
Sean Mahere5d5f6932024-04-04 18:07:33[diff] [blame]117 sequence_manager_->SetTaskExecutionAllowedInNativeNestedLoop(previous_state_);
Gabriel Charetteb1c3f2d2020-05-29 20:16:37[diff] [blame]118 TRACE_EVENT_END0("base", "ScopedNestableTaskAllower");
Gabriel Charettec25437c62018-04-17 00:48:44[diff] [blame]119}
120
Gabriel Charette0e02a9a2022-12-13 23:10:54[diff] [blame]121bool CurrentThread::ApplicationTasksAllowedInNativeNestedLoop() const {
Sean Mahere5d5f6932024-04-04 18:07:33[diff] [blame]122 return current_->IsTaskExecutionAllowedInNativeNestedLoop();
Gabriel Charettebdbb58e72020-06-03 18:26:06[diff] [blame]123}
124
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]125//------------------------------------------------------------------------------
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]126// CurrentUIThread
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]127
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]128// static
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]129CurrentUIThread CurrentUIThread::Get() {
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]130 auto* sequence_manager = GetCurrentSequenceManagerImpl();
131 DCHECK(sequence_manager);
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]132#if BUILDFLAG(IS_ANDROID)
Carlos Caballerodd8bf7b042019-07-30 14:14:15[diff] [blame]133 DCHECK(sequence_manager->IsType(MessagePumpType::UI) ||
134 sequence_manager->IsType(MessagePumpType::JAVA));
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]135#else // BUILDFLAG(IS_ANDROID)
Carlos Caballerodd8bf7b042019-07-30 14:14:15[diff] [blame]136 DCHECK(sequence_manager->IsType(MessagePumpType::UI));
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]137#endif // BUILDFLAG(IS_ANDROID)
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]138 return CurrentUIThread(sequence_manager);
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]139}
140
141// static
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]142bool CurrentUIThread::IsSet() {
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]143 sequence_manager::internal::SequenceManagerImpl* sequence_manager =
144 GetCurrentSequenceManagerImpl();
145 return sequence_manager &&
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]146#if BUILDFLAG(IS_ANDROID)
Carlos Caballerodd8bf7b042019-07-30 14:14:15[diff] [blame]147 (sequence_manager->IsType(MessagePumpType::UI) ||
148 sequence_manager->IsType(MessagePumpType::JAVA));
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]149#else // BUILDFLAG(IS_ANDROID)
Carlos Caballerodd8bf7b042019-07-30 14:14:15[diff] [blame]150 sequence_manager->IsType(MessagePumpType::UI);
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]151#endif // BUILDFLAG(IS_ANDROID)
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]152}
153
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]154MessagePumpForUI* CurrentUIThread::GetMessagePumpForUI() const {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]155 return static_cast<MessagePumpForUI*>(current_->GetMessagePump());
156}
157
kylechardda7bc02022-10-26 20:34:15[diff] [blame]158#if BUILDFLAG(IS_OZONE) && !BUILDFLAG(IS_FUCHSIA) && !BUILDFLAG(IS_WIN)
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]159bool CurrentUIThread::WatchFileDescriptor(
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]160 int fd,
161 bool persistent,
162 MessagePumpForUI::Mode mode,
163 MessagePumpForUI::FdWatchController* controller,
164 MessagePumpForUI::FdWatcher* delegate) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]165 DCHECK(current_->IsBoundToCurrentThread());
166 return GetMessagePumpForUI()->WatchFileDescriptor(fd, persistent, mode,
167 controller, delegate);
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]168}
169#endif
170
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]171#if BUILDFLAG(IS_IOS)
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]172void CurrentUIThread::Attach() {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]173 current_->AttachToMessagePump();
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]174}
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]175#endif // BUILDFLAG(IS_IOS)
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]176
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]177#if BUILDFLAG(IS_ANDROID)
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]178void CurrentUIThread::Abort() {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]179 GetMessagePumpForUI()->Abort();
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]180}
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]181#endif // BUILDFLAG(IS_ANDROID)
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]182
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]183#if BUILDFLAG(IS_WIN)
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]184void CurrentUIThread::AddMessagePumpObserver(
Erik Chend5c62372018-08-10 20:48:41[diff] [blame]185 MessagePumpForUI::Observer* observer) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]186 GetMessagePumpForUI()->AddObserver(observer);
Erik Chend5c62372018-08-10 20:48:41[diff] [blame]187}
188
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]189void CurrentUIThread::RemoveMessagePumpObserver(
Erik Chend5c62372018-08-10 20:48:41[diff] [blame]190 MessagePumpForUI::Observer* observer) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]191 GetMessagePumpForUI()->RemoveObserver(observer);
Erik Chend5c62372018-08-10 20:48:41[diff] [blame]192}
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]193#endif // BUILDFLAG(IS_WIN)
Erik Chend5c62372018-08-10 20:48:41[diff] [blame]194
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]195//------------------------------------------------------------------------------
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]196// CurrentIOThread
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]197
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]198// static
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]199CurrentIOThread CurrentIOThread::Get() {
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]200 auto* sequence_manager = GetCurrentSequenceManagerImpl();
201 DCHECK(sequence_manager);
Carlos Caballerodd8bf7b042019-07-30 14:14:15[diff] [blame]202 DCHECK(sequence_manager->IsType(MessagePumpType::IO));
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]203 return CurrentIOThread(sequence_manager);
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]204}
205
206// static
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]207bool CurrentIOThread::IsSet() {
Carlos Caballero14712af92019-04-17 16:13:01[diff] [blame]208 auto* sequence_manager = GetCurrentSequenceManagerImpl();
Carlos Caballerodd8bf7b042019-07-30 14:14:15[diff] [blame]209 return sequence_manager && sequence_manager->IsType(MessagePumpType::IO);
Gabriel Charettee6bea7b22018-04-14 03:56:08[diff] [blame]210}
211
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]212MessagePumpForIO* CurrentIOThread::GetMessagePumpForIO() const {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]213 return static_cast<MessagePumpForIO*>(current_->GetMessagePump());
214}
215
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]216#if BUILDFLAG(IS_WIN)
François Doray5b785902024-11-05 14:32:04[diff] [blame]217bool CurrentIOThread::RegisterIOHandler(HANDLE file,
218 MessagePumpForIO::IOHandler* handler) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]219 DCHECK(current_->IsBoundToCurrentThread());
220 return GetMessagePumpForIO()->RegisterIOHandler(file, handler);
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]221}
222
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]223bool CurrentIOThread::RegisterJobObject(HANDLE job,
224 MessagePumpForIO::IOHandler* handler) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]225 DCHECK(current_->IsBoundToCurrentThread());
226 return GetMessagePumpForIO()->RegisterJobObject(job, handler);
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]227}
228
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]229#elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]230bool CurrentIOThread::WatchFileDescriptor(
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]231 int fd,
232 bool persistent,
233 MessagePumpForIO::Mode mode,
234 MessagePumpForIO::FdWatchController* controller,
235 MessagePumpForIO::FdWatcher* delegate) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]236 DCHECK(current_->IsBoundToCurrentThread());
237 return GetMessagePumpForIO()->WatchFileDescriptor(fd, persistent, mode,
238 controller, delegate);
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]239}
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]240#endif // BUILDFLAG(IS_WIN)
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]241
Raphael Kubo da Costa50af5a9b2025-04-17 21:50:03[diff] [blame]242#if BUILDFLAG(IS_MAC) || \
243 (BUILDFLAG(IS_IOS) && !BUILDFLAG(CRONET_BUILD) && !BUILDFLAG(IS_IOS_TVOS))
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]244bool CurrentIOThread::WatchMachReceivePort(
Robert Sesekc96c6322019-02-23 01:26:16[diff] [blame]245 mach_port_t port,
246 MessagePumpForIO::MachPortWatchController* controller,
247 MessagePumpForIO::MachPortWatcher* delegate) {
248 DCHECK(current_->IsBoundToCurrentThread());
249 return GetMessagePumpForIO()->WatchMachReceivePort(port, controller,
250 delegate);
251}
252#endif
253
Xiaohan Wangbba17e22022-01-15 17:58:14[diff] [blame]254#if BUILDFLAG(IS_FUCHSIA)
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]255// Additional watch API for native platform resources.
Carlos Caballero4a050922020-07-02 11:43:38[diff] [blame]256bool CurrentIOThread::WatchZxHandle(
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]257 zx_handle_t handle,
258 bool persistent,
259 zx_signals_t signals,
260 MessagePumpForIO::ZxHandleWatchController* controller,
261 MessagePumpForIO::ZxHandleWatcher* delegate) {
Alex Clarke605c2032018-11-14 18:46:32[diff] [blame]262 DCHECK(current_->IsBoundToCurrentThread());
263 return GetMessagePumpForIO()->WatchZxHandle(handle, persistent, signals,
264 controller, delegate);
Gabriel Charette01b83012018-04-13 20:29:35[diff] [blame]265}
266#endif
267
268} // namespace base