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}

DEPS

@@ -1428,6 +1428,7 @@ include_rules = [
   "+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",

api/task_queue/BUILD.gn

@@ -12,5 +12,25 @@ rtc_source_set("task_queue") {
   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",
   ]
 }

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

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_

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_

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_

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 @@ 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.
-  enum class Priority {
-    NORMAL = 0,
-    HIGH,
-    LOW,
-  };
+  using Priority = ::webrtc::TaskQueuePriority;
 
   explicit TaskQueue(const char* queue_name,
                      Priority priority = Priority::NORMAL);