diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /third_party/libwebrtc/rtc_base/task_queue.h | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/rtc_base/task_queue.h')
-rw-r--r-- | third_party/libwebrtc/rtc_base/task_queue.h | 117 |
1 files changed, 117 insertions, 0 deletions
diff --git a/third_party/libwebrtc/rtc_base/task_queue.h b/third_party/libwebrtc/rtc_base/task_queue.h new file mode 100644 index 0000000000..e52c49cf00 --- /dev/null +++ b/third_party/libwebrtc/rtc_base/task_queue.h @@ -0,0 +1,117 @@ +/* + * Copyright 2016 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef RTC_BASE_TASK_QUEUE_H_ +#define RTC_BASE_TASK_QUEUE_H_ + +#include <stdint.h> + +#include <memory> +#include <utility> + +#include "absl/functional/any_invocable.h" +#include "absl/memory/memory.h" +#include "api/task_queue/task_queue_base.h" +#include "api/task_queue/task_queue_factory.h" +#include "rtc_base/system/rtc_export.h" +#include "rtc_base/thread_annotations.h" + +namespace rtc { +// Implements a task queue that asynchronously executes tasks in a way that +// guarantees that they're executed in FIFO order and that tasks never overlap. +// Tasks may always execute on the same worker thread and they may not. +// To DCHECK that tasks are executing on a known task queue, use IsCurrent(). +// +// Here are some usage examples: +// +// 1) Asynchronously running a lambda: +// +// class MyClass { +// ... +// TaskQueue queue_("MyQueue"); +// }; +// +// void MyClass::StartWork() { +// queue_.PostTask([]() { Work(); }); +// ... +// +// 2) Posting a custom task on a timer. The task posts itself again after +// every running: +// +// class TimerTask : public QueuedTask { +// public: +// TimerTask() {} +// private: +// bool Run() override { +// ++count_; +// TaskQueueBase::Current()->PostDelayedTask( +// absl::WrapUnique(this), 1000); +// // Ownership has been transferred to the next occurance, +// // so return false to prevent from being deleted now. +// return false; +// } +// int count_ = 0; +// }; +// ... +// queue_.PostDelayedTask(std::make_unique<TimerTask>(), 1000); +// +// For more examples, see task_queue_unittests.cc. +// +// A note on destruction: +// +// When a TaskQueue is deleted, pending tasks will not be executed but they will +// be deleted. The deletion of tasks may happen asynchronously after the +// TaskQueue itself has been deleted or it may happen synchronously while the +// TaskQueue instance is being deleted. This may vary from one OS to the next +// so assumptions about lifetimes of pending tasks should not be made. +class RTC_LOCKABLE RTC_EXPORT TaskQueue { + public: + // TaskQueue priority levels. On some platforms these will map to thread + // priorities, on others such as Mac and iOS, GCD queue priorities. + using Priority = ::webrtc::TaskQueueFactory::Priority; + + explicit TaskQueue(std::unique_ptr<webrtc::TaskQueueBase, + webrtc::TaskQueueDeleter> task_queue); + ~TaskQueue(); + + TaskQueue(const TaskQueue&) = delete; + TaskQueue& operator=(const TaskQueue&) = delete; + + // Used for DCHECKing the current queue. + bool IsCurrent() const; + + // Returns non-owning pointer to the task queue implementation. + webrtc::TaskQueueBase* Get() { return impl_; } + + void PostTask( + absl::AnyInvocable<void() &&> task, + const webrtc::Location& location = webrtc::Location::Current()) { + impl_->PostTask(std::move(task), location); + } + void PostDelayedTask( + absl::AnyInvocable<void() &&> task, + webrtc::TimeDelta delay, + const webrtc::Location& location = webrtc::Location::Current()) { + impl_->PostDelayedTask(std::move(task), delay, location); + } + void PostDelayedHighPrecisionTask( + absl::AnyInvocable<void() &&> task, + webrtc::TimeDelta delay, + const webrtc::Location& location = webrtc::Location::Current()) { + impl_->PostDelayedHighPrecisionTask(std::move(task), delay, location); + } + + private: + webrtc::TaskQueueBase* const impl_; +}; + +} // namespace rtc + +#endif // RTC_BASE_TASK_QUEUE_H_ |