Uninherit TaskQueueForTest from legacy rtc::TaskQueue

rtc::TaskQueue is not used in any api and thus TaskQueueForTest no longer need to provide implementation for it.
TaskQueueForTest still helpful for code that expects TaskQueueBase.

Bug: webrtc:14169
Change-Id: I64ee2691ddeb0ff3a72cd4dd192730c06260f61f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/335323
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41577}

rtc_base/BUILD.gn

@@ -1771,9 +1771,7 @@ rtc_library("task_queue_for_test") {
   ]
   deps = [
     ":checks",
-    ":macromagic",
     ":rtc_event",
-    ":rtc_task_queue",
     "../api:function_view",
     "../api/task_queue",
     "../api/task_queue:default_task_queue_factory",
@@ -2012,7 +2010,6 @@ if (rtc_include_tests) {
         ":gunit_helpers",
         ":rtc_base_tests_utils",
         ":rtc_event",
-        ":rtc_task_queue",
         ":task_queue_for_test",
         ":timeutils",
         "../api/units:time_delta",

rtc_base/task_queue_for_test.cc

@@ -10,12 +10,28 @@
 
 #include "rtc_base/task_queue_for_test.h"
 
+#include <memory>
+#include <utility>
+
 #include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_base.h"
 
 namespace webrtc {
 
-TaskQueueForTest::TaskQueueForTest(absl::string_view name, Priority priority)
+TaskQueueForTest::TaskQueueForTest(
-    : TaskQueue(
+    std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue)
-          CreateDefaultTaskQueueFactory()->CreateTaskQueue(name, priority)) {}
+    : impl_(std::move(task_queue)) {}
+
+TaskQueueForTest::TaskQueueForTest(absl::string_view name,
+                                   TaskQueueFactory::Priority priority)
+    : impl_(CreateDefaultTaskQueueFactory()->CreateTaskQueue(name, priority)) {}
+
+TaskQueueForTest::~TaskQueueForTest() {
+  // Stop the TaskQueue before invalidating impl_ pointer so that tasks that
+  // race with the TaskQueueForTest destructor could still use TaskQueueForTest
+  // functions like 'IsCurrent'.
+  impl_.get_deleter()(impl_.get());
+  impl_.release();
+}
 
 }  // namespace webrtc

rtc_base/task_queue_for_test.h

@@ -17,10 +17,9 @@
 #include "absl/strings/string_view.h"
 #include "api/function_view.h"
 #include "api/task_queue/task_queue_base.h"
+#include "api/task_queue/task_queue_factory.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
-#include "rtc_base/task_queue.h"
-#include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
 
@@ -38,14 +37,39 @@ inline void SendTask(TaskQueueBase* task_queue,
                        /*warn_after=*/TimeDelta::Seconds(10)));
 }
 
-class RTC_LOCKABLE TaskQueueForTest : public rtc::TaskQueue {
+class TaskQueueForTest {
  public:
-  using rtc::TaskQueue::TaskQueue;
+  explicit TaskQueueForTest(
-  explicit TaskQueueForTest(absl::string_view name = "TestQueue",
+      std::unique_ptr<TaskQueueBase, TaskQueueDeleter> task_queue);
-                            Priority priority = Priority::NORMAL);
+  explicit TaskQueueForTest(
+      absl::string_view name = "TestQueue",
+      TaskQueueFactory::Priority priority = TaskQueueFactory::Priority::NORMAL);
   TaskQueueForTest(const TaskQueueForTest&) = delete;
   TaskQueueForTest& operator=(const TaskQueueForTest&) = delete;
-  ~TaskQueueForTest() = default;
+  ~TaskQueueForTest();
+
+  bool IsCurrent() const { return impl_->IsCurrent(); }
+
+  // Returns non-owning pointer to the task queue implementation.
+  TaskQueueBase* Get() { return impl_.get(); }
+
+  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);
+  }
 
   // A convenience, test-only method that blocks the current thread while
   // a task executes on the task queue.
@@ -61,6 +85,9 @@ class RTC_LOCKABLE TaskQueueForTest : public rtc::TaskQueue {
     // that all already posted tasks on the queue get executed.
     SendTask([]() {});
   }
+
+ private:
+  std::unique_ptr<TaskQueueBase, TaskQueueDeleter> impl_;
 };
 
 }  // namespace webrtc

rtc_base/task_queue_unittest.cc

@@ -28,10 +28,10 @@
 #include "rtc_base/time_utils.h"
 #include "test/gtest.h"
 
-namespace rtc {
+namespace webrtc {
 
 namespace {
-using ::webrtc::TimeDelta;
+
 // Noop on all platforms except Windows, where it turns on high precision
 // multimedia timers which increases the precision of TimeMillis() while in
 // scope.
@@ -51,12 +51,6 @@ class EnableHighResTimers {
 #endif
 };
 
-void CheckCurrent(Event* signal, TaskQueue* queue) {
-  EXPECT_TRUE(queue->IsCurrent());
-  if (signal)
-    signal->Set();
-}
-
 }  // namespace
 
 // This task needs to be run manually due to the slowness of some of our bots.
@@ -65,14 +59,18 @@ TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
   EnableHighResTimers high_res_scope;
 
   static const char kQueueName[] = "PostDelayedHighRes";
-  Event event;
+  rtc::Event event;
-  webrtc::TaskQueueForTest queue(kQueueName, TaskQueue::Priority::HIGH);
+  TaskQueueForTest queue(kQueueName, TaskQueueFactory::Priority::HIGH);
 
-  uint32_t start = Time();
+  uint32_t start = rtc::TimeMillis();
-  queue.PostDelayedTask([&event, &queue] { CheckCurrent(&event, &queue); },
+  queue.PostDelayedTask(
-                        TimeDelta::Millis(3));
+      [&event, &queue] {
-  EXPECT_TRUE(event.Wait(webrtc::TimeDelta::Seconds(1)));
+        EXPECT_TRUE(queue.IsCurrent());
-  uint32_t end = TimeMillis();
+        event.Set();
+      },
+      TimeDelta::Millis(3));
+  EXPECT_TRUE(event.Wait(TimeDelta::Seconds(1)));
+  uint32_t end = rtc::TimeMillis();
   // These tests are a little relaxed due to how "powerful" our test bots can
   // be.  Most recently we've seen windows bots fire the callback after 94-99ms,
   // which is why we have a little bit of leeway backwards as well.
@@ -80,4 +78,4 @@ TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
   EXPECT_NEAR(end - start, 3, 3u);
 }
 
-}  // namespace rtc
+}  // namespace webrtc