blob: 70a016b722804782b6957a4e59b3986bba0abe04 [file] [log] [blame]
* 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.
// This file contains the implementation of TaskQueue for Mac and iOS.
// The implementation uses Grand Central Dispatch queues (GCD) to
// do the actual task queuing.
#include "webrtc/rtc_base/task_queue.h"
#include <string.h>
#include <dispatch/dispatch.h>
#include "webrtc/rtc_base/checks.h"
#include "webrtc/rtc_base/logging.h"
#include "webrtc/rtc_base/refcount.h"
#include "webrtc/rtc_base/refcountedobject.h"
#include "webrtc/rtc_base/task_queue_posix.h"
namespace rtc {
namespace {
using Priority = TaskQueue::Priority;
int TaskQueuePriorityToGCD(Priority priority) {
switch (priority) {
case Priority::NORMAL:
case Priority::HIGH:
case Priority::LOW:
using internal::GetQueuePtrTls;
using internal::AutoSetCurrentQueuePtr;
class TaskQueue::Impl : public RefCountInterface {
Impl(const char* queue_name, TaskQueue* task_queue, Priority priority);
~Impl() override;
static TaskQueue* Current();
// Used for DCHECKing the current queue.
bool IsCurrent() const;
void PostTask(std::unique_ptr<QueuedTask> task);
void PostTaskAndReply(std::unique_ptr<QueuedTask> task,
std::unique_ptr<QueuedTask> reply,
TaskQueue::Impl* reply_queue);
void PostDelayedTask(std::unique_ptr<QueuedTask> task, uint32_t milliseconds);
struct QueueContext {
explicit QueueContext(TaskQueue* q) : queue(q), is_active(true) {}
static void SetNotActive(void* context) {
QueueContext* qc = static_cast<QueueContext*>(context);
qc->is_active = false;
static void DeleteContext(void* context) {
QueueContext* qc = static_cast<QueueContext*>(context);
delete qc;
TaskQueue* const queue;
bool is_active;
struct TaskContext {
TaskContext(QueueContext* queue_ctx, std::unique_ptr<QueuedTask> task)
: queue_ctx(queue_ctx), task(std::move(task)) {}
virtual ~TaskContext() {}
static void RunTask(void* context) {
std::unique_ptr<TaskContext> tc(static_cast<TaskContext*>(context));
if (tc->queue_ctx->is_active) {
AutoSetCurrentQueuePtr set_current(tc->queue_ctx->queue);
if (!tc->task->Run())
QueueContext* const queue_ctx;
std::unique_ptr<QueuedTask> task;
// Special case context for holding two tasks, a |first_task| + the task
// that's owned by the parent struct, TaskContext, that then becomes the
// second (i.e. 'reply') task.
struct PostTaskAndReplyContext : public TaskContext {
explicit PostTaskAndReplyContext(QueueContext* first_queue_ctx,
std::unique_ptr<QueuedTask> first_task,
QueueContext* second_queue_ctx,
std::unique_ptr<QueuedTask> second_task)
: TaskContext(second_queue_ctx, std::move(second_task)),
reply_queue_(second_queue_ctx->queue->impl_->queue_) {
// Retain the reply queue for as long as this object lives.
// If we don't, we may have memory leaks and/or failures.
~PostTaskAndReplyContext() override { dispatch_release(reply_queue_); }
static void RunTask(void* context) {
auto* rc = static_cast<PostTaskAndReplyContext*>(context);
if (rc->first_queue_ctx->is_active) {
AutoSetCurrentQueuePtr set_current(rc->first_queue_ctx->queue);
if (!rc->first_task->Run())
// Post the reply task. This hands the work over to the parent struct.
// This task will eventually delete |this|.
dispatch_async_f(rc->reply_queue_, rc, &TaskContext::RunTask);
QueueContext* const first_queue_ctx;
std::unique_ptr<QueuedTask> first_task;
dispatch_queue_t reply_queue_;
dispatch_queue_t queue_;
QueueContext* const context_;
TaskQueue::Impl::Impl(const char* queue_name,
TaskQueue* task_queue,
Priority priority)
: queue_(dispatch_queue_create(queue_name, DISPATCH_QUEUE_SERIAL)),
context_(new QueueContext(task_queue)) {
dispatch_set_context(queue_, context_);
// Assign a finalizer that will delete the context when the last reference
// to the queue is released. This may run after the TaskQueue object has
// been deleted.
dispatch_set_finalizer_f(queue_, &QueueContext::DeleteContext);
queue_, dispatch_get_global_queue(TaskQueuePriorityToGCD(priority), 0));
TaskQueue::Impl::~Impl() {
// Implementation/behavioral note:
// Dispatch queues are reference counted via calls to dispatch_retain and
// dispatch_release. Pending blocks submitted to a queue also hold a
// reference to the queue until they have finished. Once all references to a
// queue have been released, the queue will be deallocated by the system.
// This is why we check the context before running tasks.
// Use dispatch_sync to set the context to null to guarantee that there's not
// a race between checking the context and using it from a task.
dispatch_sync_f(queue_, context_, &QueueContext::SetNotActive);
// static
TaskQueue* TaskQueue::Impl::Current() {
return static_cast<TaskQueue*>(pthread_getspecific(GetQueuePtrTls()));
bool TaskQueue::Impl::IsCurrent() const {
const TaskQueue* current = Current();
return current && this == current->impl_.get();
void TaskQueue::Impl::PostTask(std::unique_ptr<QueuedTask> task) {
auto* context = new TaskContext(context_, std::move(task));
dispatch_async_f(queue_, context, &TaskContext::RunTask);
void TaskQueue::Impl::PostDelayedTask(std::unique_ptr<QueuedTask> task,
uint32_t milliseconds) {
auto* context = new TaskContext(context_, std::move(task));
dispatch_time(DISPATCH_TIME_NOW, milliseconds * NSEC_PER_MSEC), queue_,
context, &TaskContext::RunTask);
void TaskQueue::Impl::PostTaskAndReply(std::unique_ptr<QueuedTask> task,
std::unique_ptr<QueuedTask> reply,
TaskQueue::Impl* reply_queue) {
auto* context = new PostTaskAndReplyContext(
context_, std::move(task), reply_queue->context_, std::move(reply));
dispatch_async_f(queue_, context, &PostTaskAndReplyContext::RunTask);
// Boilerplate for the PIMPL pattern.
TaskQueue::TaskQueue(const char* queue_name, Priority priority)
: impl_(new RefCountedObject<TaskQueue::Impl>(queue_name, this, priority)) {
TaskQueue::~TaskQueue() {}
// static
TaskQueue* TaskQueue::Current() {
return TaskQueue::Impl::Current();
// Used for DCHECKing the current queue.
bool TaskQueue::IsCurrent() const {
return impl_->IsCurrent();
void TaskQueue::PostTask(std::unique_ptr<QueuedTask> task) {
return TaskQueue::impl_->PostTask(std::move(task));
void TaskQueue::PostTaskAndReply(std::unique_ptr<QueuedTask> task,
std::unique_ptr<QueuedTask> reply,
TaskQueue* reply_queue) {
return TaskQueue::impl_->PostTaskAndReply(std::move(task), std::move(reply),
void TaskQueue::PostTaskAndReply(std::unique_ptr<QueuedTask> task,
std::unique_ptr<QueuedTask> reply) {
return TaskQueue::impl_->PostTaskAndReply(std::move(task), std::move(reply),
void TaskQueue::PostDelayedTask(std::unique_ptr<QueuedTask> task,
uint32_t milliseconds) {
return TaskQueue::impl_->PostDelayedTask(std::move(task), milliseconds);
} // namespace rtc