Introduce webrtc::TaskQueue and TaskQueueFactory interfaces
Bug: webrtc:10191
Change-Id: Ia2fff34cb260d904f25f7263051695f1c004a53b
Reviewed-on: https://webrtc-review.googlesource.com/c/117360
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26295}diff --git a/DEPS b/DEPS
index 978d72e..92a1c81 100644
--- a/DEPS
+++ b/DEPS
@@ -1428,6 +1428,7 @@
"+rtc_tools",
# Abseil whitelist. Keep this in sync with abseil-in-webrtc.md.
+ "+absl/base/attributes.h",
"+absl/container/inlined_vector.h",
"+absl/memory/memory.h",
"+absl/meta/type_traits.h",
diff --git a/api/task_queue/BUILD.gn b/api/task_queue/BUILD.gn
index e9dfe66..d058291 100644
--- a/api/task_queue/BUILD.gn
+++ b/api/task_queue/BUILD.gn
@@ -12,5 +12,25 @@
visibility = [ "*" ]
public = [
"queued_task.h",
+ "task_queue_priority.h",
+ ]
+}
+
+# TODO(bugs.webrtc.org/10191): Merge the target into task_queue target above
+# when support for link-time injection is dropped.
+rtc_source_set("task_queue_factory") {
+ visibility = [ "*" ]
+ public = [
+ "task_queue_base.h",
+ "task_queue_factory.h",
+ ]
+ sources = [
+ "task_queue_base.cc",
+ ]
+
+ deps = [
+ ":task_queue",
+ "//third_party/abseil-cpp/absl/base:core_headers",
+ "//third_party/abseil-cpp/absl/strings",
]
}
diff --git a/api/task_queue/task_queue_base.cc b/api/task_queue/task_queue_base.cc
new file mode 100644
index 0000000..409eb49
--- /dev/null
+++ b/api/task_queue/task_queue_base.cc
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2019 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.
+ */
+#include "api/task_queue/task_queue_base.h"
+
+#include "absl/base/attributes.h"
+
+namespace webrtc {
+namespace {
+
+ABSL_CONST_INIT thread_local TaskQueueBase* current = nullptr;
+
+} // namespace
+
+TaskQueueBase* TaskQueueBase::Current() {
+ return current;
+}
+
+TaskQueueBase::CurrentTaskQueueSetter::CurrentTaskQueueSetter(
+ TaskQueueBase* task_queue)
+ : previous_(current) {
+ current = task_queue;
+}
+
+TaskQueueBase::CurrentTaskQueueSetter::~CurrentTaskQueueSetter() {
+ current = previous_;
+}
+
+} // namespace webrtc
diff --git a/api/task_queue/task_queue_base.h b/api/task_queue/task_queue_base.h
new file mode 100644
index 0000000..a5163fe
--- /dev/null
+++ b/api/task_queue/task_queue_base.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2019 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 API_TASK_QUEUE_TASK_QUEUE_BASE_H_
+#define API_TASK_QUEUE_TASK_QUEUE_BASE_H_
+
+#include <memory>
+
+#include "api/task_queue/queued_task.h"
+
+namespace webrtc {
+
+// 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().
+class TaskQueueBase {
+ public:
+ // Starts destruction of the task queue.
+ // On return ensures no task are running and no new tasks are able to start
+ // on the task queue.
+ // Responsible for deallocation. Deallocation may happen syncrhoniously during
+ // Delete or asynchronously after Delete returns.
+ // Code not running on the TaskQueue should not make any assumption when
+ // TaskQueue is deallocated and thus should not call any methods after Delete.
+ // Code running on the TaskQueue should not call Delete, but can assume
+ // TaskQueue still exists and may call other methods, e.g. PostTask.
+ virtual void Delete() = 0;
+
+ // Schedules a task to execute. Tasks are executed in FIFO order.
+ // If |task->Run()| returns true, task is deleted on the task queue
+ // before next QueuedTask starts executing.
+ // When a TaskQueue is deleted, pending tasks will not be executed but they
+ // will be deleted. The deletion of tasks may happen synchronously on the
+ // TaskQueue or it may happen asynchronously after TaskQueue is deleted.
+ // This may vary from one implementation to the next so assumptions about
+ // lifetimes of pending tasks should not be made.
+ virtual void PostTask(std::unique_ptr<QueuedTask> task) = 0;
+
+ // Schedules a task to execute a specified number of milliseconds from when
+ // the call is made. The precision should be considered as "best effort"
+ // and in some cases, such as on Windows when all high precision timers have
+ // been used up, can be off by as much as 15 millseconds.
+ virtual void PostDelayedTask(std::unique_ptr<QueuedTask> task,
+ uint32_t milliseconds) = 0;
+
+ // Until all TaskQueue implementations switch to using CurrentTaskQueueSetter
+ // below, this function may return nullptr even if code is executed by a
+ // TaskQueue. Keep using rtc::TaskQueue::Current() until bugs.webrtc.org/10191
+ // is resolved.
+ static TaskQueueBase* Current();
+ bool IsCurrent() const { return Current() == this; }
+
+ protected:
+ class CurrentTaskQueueSetter {
+ public:
+ explicit CurrentTaskQueueSetter(TaskQueueBase* task_queue);
+ CurrentTaskQueueSetter(const CurrentTaskQueueSetter&) = delete;
+ CurrentTaskQueueSetter& operator=(const CurrentTaskQueueSetter&) = delete;
+ ~CurrentTaskQueueSetter();
+
+ private:
+ TaskQueueBase* const previous_;
+ };
+
+ // Users of the TaskQueue should call Delete instead of directly deleting
+ // this object.
+ virtual ~TaskQueueBase() = default;
+};
+
+struct TaskQueueDeleter {
+ void operator()(TaskQueueBase* task_queue) const { task_queue->Delete(); }
+};
+
+} // namespace webrtc
+
+#endif // API_TASK_QUEUE_TASK_QUEUE_BASE_H_
diff --git a/api/task_queue/task_queue_factory.h b/api/task_queue/task_queue_factory.h
new file mode 100644
index 0000000..6827138
--- /dev/null
+++ b/api/task_queue/task_queue_factory.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2019 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 API_TASK_QUEUE_TASK_QUEUE_FACTORY_H_
+#define API_TASK_QUEUE_TASK_QUEUE_FACTORY_H_
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "api/task_queue/task_queue_base.h"
+#include "api/task_queue/task_queue_priority.h"
+
+namespace webrtc {
+
+class TaskQueueFactory {
+ 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::TaskQueuePriority;
+
+ virtual ~TaskQueueFactory() = default;
+ virtual std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue(
+ absl::string_view name,
+ Priority priority) const = 0;
+};
+
+} // namespace webrtc
+
+#endif // API_TASK_QUEUE_TASK_QUEUE_FACTORY_H_
diff --git a/api/task_queue/task_queue_priority.h b/api/task_queue/task_queue_priority.h
new file mode 100644
index 0000000..a8696ec
--- /dev/null
+++ b/api/task_queue/task_queue_priority.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2019 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 API_TASK_QUEUE_TASK_QUEUE_PRIORITY_H_
+#define API_TASK_QUEUE_TASK_QUEUE_PRIORITY_H_
+
+namespace webrtc {
+
+// TODO(bugs.webrtc.org/10191): Move as member class of TaskQueueFactory when
+// rtc::TaskQueue would be able to depende on it.
+enum class TaskQueuePriority { NORMAL = 0, HIGH, LOW };
+
+} // namespace webrtc
+
+#endif // API_TASK_QUEUE_TASK_QUEUE_PRIORITY_H_
diff --git a/rtc_base/task_queue.h b/rtc_base/task_queue.h
index 41fcf41..43497de 100644
--- a/rtc_base/task_queue.h
+++ b/rtc_base/task_queue.h
@@ -18,6 +18,7 @@
#include "absl/memory/memory.h"
#include "api/task_queue/queued_task.h"
+#include "api/task_queue/task_queue_priority.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/scoped_ref_ptr.h"
#include "rtc_base/system/rtc_export.h"
@@ -142,11 +143,7 @@
public:
// TaskQueue priority levels. On some platforms these will map to thread
// priorities, on others such as Mac and iOS, GCD queue priorities.
- enum class Priority {
- NORMAL = 0,
- HIGH,
- LOW,
- };
+ using Priority = ::webrtc::TaskQueuePriority;
explicit TaskQueue(const char* queue_name,
Priority priority = Priority::NORMAL);
