Implement support for Chrome task origin tracing. #3.5/4

This CL migrates unit tests to the new TaskQueueBase interface.

Bug: chromium:1416199
Change-Id: Ic15c694b28eb67450ac99fdd56754de1246a4d95
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/295621
Commit-Queue: Markus Handell <handellm@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39434}
diff --git a/api/task_queue/test/mock_task_queue_base.h b/api/task_queue/test/mock_task_queue_base.h
index 2e99be7..0540afe 100644
--- a/api/task_queue/test/mock_task_queue_base.h
+++ b/api/task_queue/test/mock_task_queue_base.h
@@ -20,15 +20,22 @@
 
 class MockTaskQueueBase : public TaskQueueBase {
  public:
+  using TaskQueueBase::PostDelayedTaskTraits;
+  using TaskQueueBase::PostTaskTraits;
+
   MOCK_METHOD(void, Delete, (), (override));
-  MOCK_METHOD(void, PostTask, (absl::AnyInvocable<void() &&>), (override));
   MOCK_METHOD(void,
-              PostDelayedTask,
-              (absl::AnyInvocable<void() &&>, TimeDelta),
+              PostTaskImpl,
+              (absl::AnyInvocable<void() &&>,
+               const PostTaskTraits&,
+               const Location&),
               (override));
   MOCK_METHOD(void,
-              PostDelayedHighPrecisionTask,
-              (absl::AnyInvocable<void() &&>, TimeDelta),
+              PostDelayedTaskImpl,
+              (absl::AnyInvocable<void() &&>,
+               TimeDelta,
+               const PostDelayedTaskTraits&,
+               const Location&),
               (override));
 };
 
diff --git a/audio/audio_state_unittest.cc b/audio/audio_state_unittest.cc
index 4426a78..070e2209 100644
--- a/audio/audio_state_unittest.cc
+++ b/audio/audio_state_unittest.cc
@@ -40,7 +40,9 @@
     FakeTaskQueue() = default;
 
     void Delete() override { delete this; }
-    void PostTask(absl::AnyInvocable<void() &&> task) override {
+    void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                      const PostTaskTraits& /*traits*/,
+                      const Location& /*location*/) override {
       std::move(task)();
     }
   };
diff --git a/audio/voip/test/audio_channel_unittest.cc b/audio/voip/test/audio_channel_unittest.cc
index 8955810..b5f85c5 100644
--- a/audio/voip/test/audio_channel_unittest.cc
+++ b/audio/voip/test/audio_channel_unittest.cc
@@ -14,6 +14,7 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/call/transport.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "audio/voip/test/mock_task_queue.h"
 #include "modules/audio_mixer/audio_mixer_impl.h"
@@ -31,6 +32,7 @@
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::Unused;
+using ::testing::WithArg;
 
 constexpr uint64_t kStartTime = 123456789;
 constexpr uint32_t kLocalSsrc = 0xdeadc0de;
@@ -49,9 +51,9 @@
     decoder_factory_ = CreateBuiltinAudioDecoderFactory();
 
     // By default, run the queued task immediately.
-    ON_CALL(task_queue_, PostTask)
-        .WillByDefault(
-            [](absl::AnyInvocable<void() &&> task) { std::move(task)(); });
+    ON_CALL(task_queue_, PostTaskImpl)
+        .WillByDefault(WithArg<0>(
+            [](absl::AnyInvocable<void() &&> task) { std::move(task)(); }));
   }
 
   void SetUp() override { audio_channel_ = CreateAudioChannel(kLocalSsrc); }
diff --git a/net/dcsctp/timer/task_queue_timeout_test.cc b/net/dcsctp/timer/task_queue_timeout_test.cc
index f360ba7..8e392e3 100644
--- a/net/dcsctp/timer/task_queue_timeout_test.cc
+++ b/net/dcsctp/timer/task_queue_timeout_test.cc
@@ -20,6 +20,7 @@
 namespace dcsctp {
 namespace {
 using ::testing::_;
+using ::testing::Field;
 using ::testing::MockFunction;
 using ::testing::NiceMock;
 
@@ -118,7 +119,14 @@
 
 TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToLow) {
   NiceMock<webrtc::MockTaskQueueBase> mock_task_queue;
-  EXPECT_CALL(mock_task_queue, PostDelayedTask(_, _));
+  EXPECT_CALL(
+      mock_task_queue,
+      PostDelayedTaskImpl(
+          _, _,
+          Field(
+              &webrtc::MockTaskQueueBase::PostDelayedTaskTraits::high_precision,
+              false),
+          _));
   TaskQueueTimeoutFactory factory(
       mock_task_queue, []() { return TimeMs(1337); },
       [](TimeoutID timeout_id) {});
@@ -129,7 +137,14 @@
 
 TEST(TaskQueueTimeoutWithMockTaskQueueTest, CanSetTimeoutPrecisionToHigh) {
   NiceMock<webrtc::MockTaskQueueBase> mock_task_queue;
-  EXPECT_CALL(mock_task_queue, PostDelayedHighPrecisionTask(_, _));
+  EXPECT_CALL(
+      mock_task_queue,
+      PostDelayedTaskImpl(
+          _, _,
+          Field(
+              &webrtc::MockTaskQueueBase::PostDelayedTaskTraits::high_precision,
+              true),
+          _));
   TaskQueueTimeoutFactory factory(
       mock_task_queue, []() { return TimeMs(1337); },
       [](TimeoutID timeout_id) {});
@@ -140,7 +155,14 @@
 
 TEST(TaskQueueTimeoutWithMockTaskQueueTest, TimeoutPrecisionIsLowByDefault) {
   NiceMock<webrtc::MockTaskQueueBase> mock_task_queue;
-  EXPECT_CALL(mock_task_queue, PostDelayedTask(_, _));
+  EXPECT_CALL(
+      mock_task_queue,
+      PostDelayedTaskImpl(
+          _, _,
+          Field(
+              &webrtc::MockTaskQueueBase::PostDelayedTaskTraits::high_precision,
+              false),
+          _));
   TaskQueueTimeoutFactory factory(
       mock_task_queue, []() { return TimeMs(1337); },
       [](TimeoutID timeout_id) {});
diff --git a/rtc_base/task_utils/BUILD.gn b/rtc_base/task_utils/BUILD.gn
index 1b3a3b5..5fcf25e 100644
--- a/rtc_base/task_utils/BUILD.gn
+++ b/rtc_base/task_utils/BUILD.gn
@@ -36,6 +36,7 @@
       "..:rtc_task_queue",
       "..:task_queue_for_test",
       "../../api/task_queue",
+      "../../api/task_queue/test:mock_task_queue_base",
       "../../api/units:time_delta",
       "../../api/units:timestamp",
       "../../system_wrappers:system_wrappers",
diff --git a/rtc_base/task_utils/repeating_task_unittest.cc b/rtc_base/task_utils/repeating_task_unittest.cc
index 55e06c7..2c269b4 100644
--- a/rtc_base/task_utils/repeating_task_unittest.cc
+++ b/rtc_base/task_utils/repeating_task_unittest.cc
@@ -15,6 +15,7 @@
 
 #include "absl/functional/any_invocable.h"
 #include "api/task_queue/task_queue_base.h"
+#include "api/task_queue/test/mock_task_queue_base.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
 #include "rtc_base/event.h"
@@ -32,6 +33,7 @@
 using ::testing::MockFunction;
 using ::testing::NiceMock;
 using ::testing::Return;
+using ::testing::WithArg;
 
 constexpr TimeDelta kTimeout = TimeDelta::Millis(1000);
 
@@ -41,21 +43,10 @@
   MOCK_METHOD(void, Delete, ());
 };
 
-class MockTaskQueue : public TaskQueueBase {
+class MockTaskQueue : public MockTaskQueueBase {
  public:
   MockTaskQueue() : task_queue_setter_(this) {}
 
-  MOCK_METHOD(void, Delete, (), (override));
-  MOCK_METHOD(void, PostTask, (absl::AnyInvocable<void() &&>), (override));
-  MOCK_METHOD(void,
-              PostDelayedTask,
-              (absl::AnyInvocable<void() &&>, TimeDelta),
-              (override));
-  MOCK_METHOD(void,
-              PostDelayedHighPrecisionTask,
-              (absl::AnyInvocable<void() &&>, TimeDelta),
-              (override));
-
  private:
   CurrentTaskQueueSetter task_queue_setter_;
 };
@@ -67,23 +58,22 @@
 
   void Delete() override {}
 
-  void PostTask(absl::AnyInvocable<void() &&> task) override {
+  void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                    const PostTaskTraits& /*traits*/,
+                    const Location& /*location*/) override {
     last_task_ = std::move(task);
     last_precision_ = absl::nullopt;
     last_delay_ = TimeDelta::Zero();
   }
 
-  void PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                       TimeDelta delay) override {
+  void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                           TimeDelta delay,
+                           const PostDelayedTaskTraits& traits,
+                           const Location& /*location*/) override {
     last_task_ = std::move(task);
-    last_precision_ = TaskQueueBase::DelayPrecision::kLow;
-    last_delay_ = delay;
-  }
-
-  void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
-                                    TimeDelta delay) override {
-    last_task_ = std::move(task);
-    last_precision_ = TaskQueueBase::DelayPrecision::kHigh;
+    last_precision_ = traits.high_precision
+                          ? TaskQueueBase::DelayPrecision::kHigh
+                          : TaskQueueBase::DelayPrecision::kLow;
     last_delay_ = delay;
   }
 
@@ -339,8 +329,10 @@
   SimulatedClock clock(Timestamp::Zero());
 
   NiceMock<MockTaskQueue> task_queue;
-  ON_CALL(task_queue, PostDelayedTask)
-      .WillByDefault([&](absl::AnyInvocable<void() &&> task, TimeDelta delay) {
+  ON_CALL(task_queue, PostDelayedTaskImpl)
+      .WillByDefault([&](absl::AnyInvocable<void() &&> task, TimeDelta delay,
+                         const MockTaskQueue::PostDelayedTaskTraits&,
+                         const Location&) {
         EXPECT_EQ(delay, expected_delay);
         delayed_task = std::move(task);
       });
@@ -368,10 +360,10 @@
   absl::AnyInvocable<void() &&> repeating_task;
 
   MockTaskQueue task_queue;
-  EXPECT_CALL(task_queue, PostDelayedTask)
-      .WillOnce([&](absl::AnyInvocable<void() &&> task, TimeDelta delay) {
+  EXPECT_CALL(task_queue, PostDelayedTaskImpl)
+      .WillOnce(WithArg<0>([&](absl::AnyInvocable<void() &&> task) {
         repeating_task = std::move(task);
-      });
+      }));
 
   RepeatingTaskHandle handle =
       RepeatingTaskHandle::DelayedStart(&task_queue, TimeDelta::Millis(100),
diff --git a/rtc_base/unique_id_generator_unittest.cc b/rtc_base/unique_id_generator_unittest.cc
index ec9c3fb..a6ae8ec 100644
--- a/rtc_base/unique_id_generator_unittest.cc
+++ b/rtc_base/unique_id_generator_unittest.cc
@@ -33,11 +33,13 @@
   FakeTaskQueue() : task_queue_setter_(this) {}
 
   void Delete() override {}
-  void PostTask(absl::AnyInvocable<void() &&> task) override {}
-  void PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                       webrtc::TimeDelta delay) override {}
-  void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
-                                    webrtc::TimeDelta delay) override {}
+  void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                    const PostTaskTraits& traits,
+                    const webrtc::Location& location) override {}
+  void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                           webrtc::TimeDelta delay,
+                           const PostDelayedTaskTraits& traits,
+                           const webrtc::Location& location) override {}
 
  private:
   CurrentTaskQueueSetter task_queue_setter_;
diff --git a/test/time_controller/external_time_controller.cc b/test/time_controller/external_time_controller.cc
index f652eb6..41f36ea 100644
--- a/test/time_controller/external_time_controller.cc
+++ b/test/time_controller/external_time_controller.cc
@@ -33,23 +33,24 @@
                    std::unique_ptr<TaskQueueBase, TaskQueueDeleter> base)
       : parent_(parent), base_(std::move(base)) {}
 
-  void PostTask(absl::AnyInvocable<void() &&> task) override {
+  void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                    const PostTaskTraits& traits,
+                    const Location& location) override {
     parent_->UpdateTime();
     base_->PostTask(TaskWrapper(std::move(task)));
     parent_->ScheduleNext();
   }
 
-  void PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                       TimeDelta delay) override {
+  void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                           TimeDelta delay,
+                           const PostDelayedTaskTraits& traits,
+                           const Location& location) override {
     parent_->UpdateTime();
-    base_->PostDelayedTask(TaskWrapper(std::move(task)), delay);
-    parent_->ScheduleNext();
-  }
-
-  void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
-                                    TimeDelta delay) override {
-    parent_->UpdateTime();
-    base_->PostDelayedHighPrecisionTask(TaskWrapper(std::move(task)), delay);
+    if (traits.high_precision) {
+      base_->PostDelayedHighPrecisionTask(TaskWrapper(std::move(task)), delay);
+    } else {
+      base_->PostDelayedTask(TaskWrapper(std::move(task)), delay);
+    }
     parent_->ScheduleNext();
   }
 
diff --git a/test/time_controller/simulated_task_queue.cc b/test/time_controller/simulated_task_queue.cc
index 3c26721..66b3fd8 100644
--- a/test/time_controller/simulated_task_queue.cc
+++ b/test/time_controller/simulated_task_queue.cc
@@ -66,20 +66,19 @@
   }
 }
 
-void SimulatedTaskQueue::PostTask(absl::AnyInvocable<void() &&> task) {
+void SimulatedTaskQueue::PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                                      const PostTaskTraits& /*traits*/,
+                                      const Location& /*location*/) {
   MutexLock lock(&lock_);
   ready_tasks_.push_back(std::move(task));
   next_run_time_ = Timestamp::MinusInfinity();
 }
 
-void SimulatedTaskQueue::PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                                         TimeDelta delay) {
-  PostDelayedHighPrecisionTask(std::move(task), delay);
-}
-
-void SimulatedTaskQueue::PostDelayedHighPrecisionTask(
+void SimulatedTaskQueue::PostDelayedTaskImpl(
     absl::AnyInvocable<void() &&> task,
-    TimeDelta delay) {
+    TimeDelta delay,
+    const PostDelayedTaskTraits& /*traits*/,
+    const Location& /*location*/) {
   MutexLock lock(&lock_);
   Timestamp target_time = handler_->CurrentTime() + delay;
   delayed_tasks_[target_time].push_back(std::move(task));
diff --git a/test/time_controller/simulated_task_queue.h b/test/time_controller/simulated_task_queue.h
index 3c55f15..6ca4632 100644
--- a/test/time_controller/simulated_task_queue.h
+++ b/test/time_controller/simulated_task_queue.h
@@ -40,11 +40,13 @@
 
   // TaskQueueBase interface
   void Delete() override;
-  void PostTask(absl::AnyInvocable<void() &&> task) override;
-  void PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                       TimeDelta delay) override;
-  void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
-                                    TimeDelta delay) override;
+  void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                    const PostTaskTraits& traits,
+                    const Location& location) override;
+  void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                           TimeDelta delay,
+                           const PostDelayedTaskTraits& traits,
+                           const Location& location) override;
 
  private:
   sim_time_impl::SimulatedTimeControllerImpl* const handler_;
diff --git a/test/time_controller/simulated_thread.cc b/test/time_controller/simulated_thread.cc
index bdd1096..0973a75 100644
--- a/test/time_controller/simulated_thread.cc
+++ b/test/time_controller/simulated_thread.cc
@@ -77,24 +77,19 @@
   }
 }
 
-void SimulatedThread::PostTask(absl::AnyInvocable<void() &&> task) {
-  rtc::Thread::PostTask(std::move(task));
+void SimulatedThread::PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                                   const PostTaskTraits& traits,
+                                   const Location& location) {
+  rtc::Thread::PostTaskImpl(std::move(task), traits, location);
   MutexLock lock(&lock_);
   next_run_time_ = Timestamp::MinusInfinity();
 }
 
-void SimulatedThread::PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                                      TimeDelta delay) {
-  rtc::Thread::PostDelayedTask(std::move(task), delay);
-  MutexLock lock(&lock_);
-  next_run_time_ =
-      std::min(next_run_time_, Timestamp::Millis(rtc::TimeMillis()) + delay);
-}
-
-void SimulatedThread::PostDelayedHighPrecisionTask(
-    absl::AnyInvocable<void() &&> task,
-    TimeDelta delay) {
-  rtc::Thread::PostDelayedHighPrecisionTask(std::move(task), delay);
+void SimulatedThread::PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                                          TimeDelta delay,
+                                          const PostDelayedTaskTraits& traits,
+                                          const Location& location) {
+  rtc::Thread::PostDelayedTaskImpl(std::move(task), delay, traits, location);
   MutexLock lock(&lock_);
   next_run_time_ =
       std::min(next_run_time_, Timestamp::Millis(rtc::TimeMillis()) + delay);
diff --git a/test/time_controller/simulated_thread.h b/test/time_controller/simulated_thread.h
index e8e08c5..97b8560 100644
--- a/test/time_controller/simulated_thread.h
+++ b/test/time_controller/simulated_thread.h
@@ -37,11 +37,13 @@
 
   // Thread interface
   void BlockingCall(rtc::FunctionView<void()> functor) override;
-  void PostTask(absl::AnyInvocable<void() &&> task) override;
-  void PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                       TimeDelta delay) override;
-  void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
-                                    TimeDelta delay) override;
+  void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                    const PostTaskTraits& traits,
+                    const Location& location) override;
+  void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                           TimeDelta delay,
+                           const PostDelayedTaskTraits& traits,
+                           const Location& location) override;
 
   void Stop() override;
 
diff --git a/test/time_controller/simulated_time_controller.h b/test/time_controller/simulated_time_controller.h
index 121b917..98b816c 100644
--- a/test/time_controller/simulated_time_controller.h
+++ b/test/time_controller/simulated_time_controller.h
@@ -106,15 +106,15 @@
   using CurrentTaskQueueSetter = TaskQueueBase::CurrentTaskQueueSetter;
 
   void Delete() override { RTC_DCHECK_NOTREACHED(); }
-  void PostTask(absl::AnyInvocable<void() &&> /*task*/) override {
+  void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                    const PostTaskTraits& traits,
+                    const Location& location) override {
     RTC_DCHECK_NOTREACHED();
   }
-  void PostDelayedTask(absl::AnyInvocable<void() &&> /*task*/,
-                       TimeDelta /*delay*/) override {
-    RTC_DCHECK_NOTREACHED();
-  }
-  void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> /*task*/,
-                                    TimeDelta /*delay*/) override {
+  void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                           TimeDelta delay,
+                           const PostDelayedTaskTraits& traits,
+                           const Location& location) override {
     RTC_DCHECK_NOTREACHED();
   }
 };
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index c451b6f..10ec97c 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -9220,15 +9220,15 @@
 
    private:
     void Delete() override { delete this; }
-    void PostTask(absl::AnyInvocable<void() &&> task) override {
+    void PostTaskImpl(absl::AnyInvocable<void() &&> task,
+                      const PostTaskTraits& traits,
+                      const Location& location) override {
       // meh.
     }
-    void PostDelayedTask(absl::AnyInvocable<void() &&> task,
-                         TimeDelta delay) override {
-      ASSERT_TRUE(false);
-    }
-    void PostDelayedHighPrecisionTask(absl::AnyInvocable<void() &&> task,
-                                      TimeDelta delay) override {
+    void PostDelayedTaskImpl(absl::AnyInvocable<void() &&> task,
+                             TimeDelta delay,
+                             const PostDelayedTaskTraits& traits,
+                             const Location& location) override {
       ADD_FAILURE();
     }
   };