Remove rtc::QueuedTask alias, use webrtc::QueuedTask directly

Use absl::WrapUnique/absl::make_unique to create the queued tasks.

Bug: webrtc:10191
Change-Id: I8f47a60cb326b0fc361c7f0e338b25373d39937c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/126525
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27063}

audio/test/audio_bwe_integration_test.cc

@@ -11,6 +11,7 @@
 #include "audio/test/audio_bwe_integration_test.h"
 
 #include "absl/memory/memory.h"
+#include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
 #include "call/fake_network_pipe.h"
 #include "call/simulated_network.h"
@@ -81,7 +82,7 @@ void AudioBweTest::PerformTest() {
   SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraProcessTimeMs);
 }
 
-class StatsPollTask : public rtc::QueuedTask {
+class StatsPollTask : public QueuedTask {
  public:
   explicit StatsPollTask(Call* sender_call) : sender_call_(sender_call) {}
 
@@ -142,7 +143,7 @@ class NoBandwidthDropAfterDtx : public AudioBweTest {
 
   void PerformTest() override {
     stats_poller_.PostDelayedTask(
-        std::unique_ptr<rtc::QueuedTask>(new StatsPollTask(sender_call_)), 100);
+        absl::make_unique<StatsPollTask>(sender_call_), 100);
     sender_call_->OnAudioTransportOverheadChanged(0);
     AudioBweTest::PerformTest();
   }

logging/BUILD.gn

@@ -256,6 +256,7 @@ rtc_static_library("rtc_event_log_impl_base") {
     ":ice_log",
     ":rtc_event_log_api",
     "../api:libjingle_logging_api",
+    "../api/task_queue",
     "../api/task_queue:global_task_queue_factory",
     "../rtc_base:checks",
     "../rtc_base:rtc_base_approved",

logging/rtc_event_log/rtc_event_log_impl.cc

@@ -21,6 +21,7 @@
 #include "absl/types/optional.h"
 #include "api/rtc_event_log_output.h"
 #include "api/task_queue/global_task_queue_factory.h"
+#include "api/task_queue/queued_task.h"
 #include "logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.h"
 #include "logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h"
 #include "rtc_base/checks.h"
@@ -48,7 +49,7 @@ constexpr size_t kMaxEventsInConfigHistory = 1000;
 // unique_ptr to a lambda (a copy constructor is required). We should get
 // rid of this when we move to C++14.
 template <typename T>
-class ResourceOwningTask final : public rtc::QueuedTask {
+class ResourceOwningTask final : public QueuedTask {
  public:
   ResourceOwningTask(std::unique_ptr<T> resource,
                      std::function<void(std::unique_ptr<T>)> handler)

modules/audio_processing/aec_dump/BUILD.gn

@@ -66,6 +66,7 @@ if (rtc_enable_protobuf) {
       ":aec_dump",
       "../",
       "../../../api/audio:audio_frame_api",
+      "../../../api/task_queue",
       "../../../rtc_base:checks",
       "../../../rtc_base:protobuf_utils",
       "../../../rtc_base:rtc_base_approved",

modules/audio_processing/aec_dump/aec_dump_impl.cc

@@ -96,7 +96,7 @@ void AecDumpImpl::WriteInitMessage(const ProcessingConfig& api_format,
       api_format.reverse_output_stream().num_channels());
   msg->set_timestamp_ms(time_now_ms);
 
-  worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
+  worker_queue_->PostTask(std::move(task));
 }
 
 void AecDumpImpl::AddCaptureStreamInput(
@@ -124,7 +124,7 @@ void AecDumpImpl::AddAudioProcessingState(const AudioProcessingState& state) {
 void AecDumpImpl::WriteCaptureStreamMessage() {
   auto task = capture_stream_info_.GetTask();
   RTC_DCHECK(task);
-  worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
+  worker_queue_->PostTask(std::move(task));
   capture_stream_info_.SetTask(CreateWriteToFileTask());
 }
 
@@ -138,7 +138,7 @@ void AecDumpImpl::WriteRenderStreamMessage(const AudioFrame& frame) {
       sizeof(int16_t) * frame.samples_per_channel_ * frame.num_channels_;
   msg->set_data(frame.data(), data_size);
 
-  worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
+  worker_queue_->PostTask(std::move(task));
 }
 
 void AecDumpImpl::WriteRenderStreamMessage(
@@ -155,7 +155,7 @@ void AecDumpImpl::WriteRenderStreamMessage(
     msg->add_channel(channel_view.begin(), sizeof(float) * channel_view.size());
   }
 
-  worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
+  worker_queue_->PostTask(std::move(task));
 }
 
 void AecDumpImpl::WriteConfig(const InternalAPMConfig& config) {
@@ -164,7 +164,7 @@ void AecDumpImpl::WriteConfig(const InternalAPMConfig& config) {
   auto* event = task->GetEvent();
   event->set_type(audioproc::Event::CONFIG);
   CopyFromConfigToEvent(config, event->mutable_config());
-  worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
+  worker_queue_->PostTask(std::move(task));
 }
 
 void AecDumpImpl::WriteRuntimeSetting(
@@ -192,7 +192,7 @@ void AecDumpImpl::WriteRuntimeSetting(
       RTC_NOTREACHED();
       break;
   }
-  worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
+  worker_queue_->PostTask(std::move(task));
 }
 
 std::unique_ptr<WriteToFileTask> AecDumpImpl::CreateWriteToFileTask() {

modules/audio_processing/aec_dump/write_to_file_task.h

@@ -15,12 +15,12 @@
 #include <string>
 #include <utility>
 
+#include "api/task_queue/queued_task.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/event.h"
 #include "rtc_base/ignore_wundef.h"
 #include "rtc_base/platform_file.h"
 #include "rtc_base/system/file_wrapper.h"
-#include "rtc_base/task_queue.h"
 
 // Files generated at build-time by the protobuf compiler.
 RTC_PUSH_IGNORING_WUNDEF()
@@ -33,7 +33,7 @@ RTC_POP_IGNORING_WUNDEF()
 
 namespace webrtc {
 
-class WriteToFileTask : public rtc::QueuedTask {
+class WriteToFileTask : public QueuedTask {
  public:
   WriteToFileTask(webrtc::FileWrapper* debug_file,
                   int64_t* num_bytes_left_for_log);

modules/utility/BUILD.gn

@@ -58,8 +58,8 @@ if (rtc_include_tests) {
     deps = [
       ":utility",
       "..:module_api",
+      "../../api/task_queue",
       "../../rtc_base:rtc_base_approved",
-      "../../rtc_base:rtc_task_queue",
       "../../test:test_support",
     ]
   }

modules/utility/source/process_thread_impl_unittest.cc

@@ -11,10 +11,10 @@
 #include <memory>
 #include <utility>
 
+#include "api/task_queue/queued_task.h"
 #include "modules/include/module.h"
 #include "modules/utility/source/process_thread_impl.h"
 #include "rtc_base/location.h"
-#include "rtc_base/task_queue.h"
 #include "rtc_base/time_utils.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -40,7 +40,7 @@ class MockModule : public Module {
   MOCK_METHOD1(ProcessThreadAttached, void(ProcessThread*));
 };
 
-class RaiseEventTask : public rtc::QueuedTask {
+class RaiseEventTask : public QueuedTask {
  public:
   RaiseEventTask(rtc::Event* event) : event_(event) {}
   bool Run() override {

modules/video_coding/codecs/test/videoprocessor.h

@@ -17,7 +17,9 @@
 #include <memory>
 #include <vector>
 
+#include "absl/memory/memory.h"
 #include "absl/types/optional.h"
+#include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/test/videocodec_test_fixture.h"
 #include "api/test/videocodec_test_stats.h"
@@ -35,7 +37,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/sequenced_task_checker.h"
-#include "rtc_base/task_queue.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/thread_checker.h"
 #include "test/testsupport/frame_reader.h"
@@ -93,9 +94,8 @@ class VideoProcessor {
 
       // Post the callback to the right task queue, if needed.
       if (!task_queue_->IsCurrent()) {
-        task_queue_->PostTask(
-            std::unique_ptr<rtc::QueuedTask>(new EncodeCallbackTask(
-                video_processor_, encoded_image, codec_specific_info)));
+        task_queue_->PostTask(absl::make_unique<EncodeCallbackTask>(
+            video_processor_, encoded_image, codec_specific_info));
         return Result(Result::OK, 0);
       }
 
@@ -104,7 +104,7 @@ class VideoProcessor {
     }
 
    private:
-    class EncodeCallbackTask : public rtc::QueuedTask {
+    class EncodeCallbackTask : public QueuedTask {
      public:
       EncodeCallbackTask(VideoProcessor* video_processor,
                          const webrtc::EncodedImage& encoded_image,

rtc_base/task_queue.cc

@@ -34,11 +34,11 @@ bool TaskQueue::IsCurrent() const {
   return impl_->IsCurrent();
 }
 
-void TaskQueue::PostTask(std::unique_ptr<QueuedTask> task) {
+void TaskQueue::PostTask(std::unique_ptr<webrtc::QueuedTask> task) {
   return impl_->PostTask(std::move(task));
 }
 
-void TaskQueue::PostDelayedTask(std::unique_ptr<QueuedTask> task,
+void TaskQueue::PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task,
                                 uint32_t milliseconds) {
   return impl_->PostDelayedTask(std::move(task), milliseconds);
 }

rtc_base/task_queue.h

@@ -25,11 +25,6 @@
 #include "rtc_base/thread_annotations.h"
 
 namespace rtc {
-
-// TODO(danilchap): Remove the alias when all of webrtc is updated to use
-// webrtc::QueuedTask directly.
-using ::webrtc::QueuedTask;
-
 // Implements a task queue that 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.
@@ -98,14 +93,15 @@ class RTC_LOCKABLE RTC_EXPORT TaskQueue {
   // TODO(tommi): For better debuggability, implement RTC_FROM_HERE.
 
   // Ownership of the task is passed to PostTask.
-  void PostTask(std::unique_ptr<QueuedTask> task);
+  void PostTask(std::unique_ptr<webrtc::QueuedTask> task);
 
   // 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 (although 8 would be
   // more likely). This can be mitigated by limiting the use of delayed tasks.
-  void PostDelayedTask(std::unique_ptr<QueuedTask> task, uint32_t milliseconds);
+  void PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task,
+                       uint32_t milliseconds);
 
   // std::enable_if is used here to make sure that calls to PostTask() with
   // std::unique_ptr<SomeClassDerivedFromQueuedTask> would not end up being
@@ -113,7 +109,7 @@ class RTC_LOCKABLE RTC_EXPORT TaskQueue {
   template <class Closure,
             typename std::enable_if<!std::is_convertible<
                 Closure,
-                std::unique_ptr<QueuedTask>>::value>::type* = nullptr>
+                std::unique_ptr<webrtc::QueuedTask>>::value>::type* = nullptr>
   void PostTask(Closure&& closure) {
     PostTask(webrtc::ToQueuedTask(std::forward<Closure>(closure)));
   }
@@ -122,7 +118,7 @@ class RTC_LOCKABLE RTC_EXPORT TaskQueue {
   template <class Closure,
             typename std::enable_if<!std::is_convertible<
                 Closure,
-                std::unique_ptr<QueuedTask>>::value>::type* = nullptr>
+                std::unique_ptr<webrtc::QueuedTask>>::value>::type* = nullptr>
   void PostDelayedTask(Closure&& closure, uint32_t milliseconds) {
     PostDelayedTask(webrtc::ToQueuedTask(std::forward<Closure>(closure)),
                     milliseconds);

rtc_base/task_queue_for_test.h

@@ -37,7 +37,7 @@ class RTC_LOCKABLE TaskQueueForTest : public TaskQueue {
     rtc::Event event;
     PostTask(webrtc::ToQueuedTask(
         [&task]() {
-          RTC_CHECK_EQ(false, static_cast<QueuedTask*>(task)->Run());
+          RTC_CHECK_EQ(false, static_cast<webrtc::QueuedTask*>(task)->Run());
         },
         [&event]() { event.Set(); }));
     event.Wait(rtc::Event::kForever);

rtc_tools/network_tester/BUILD.gn

@@ -52,6 +52,7 @@ if (rtc_enable_protobuf) {
       "../../rtc_base:rtc_task_queue",
       "../../rtc_base:sequenced_task_checker",
       "../../rtc_base/third_party/sigslot:sigslot",
+      "//third_party/abseil-cpp/absl/memory",
       "//third_party/abseil-cpp/absl/types:optional",
     ]
   }

rtc_tools/network_tester/packet_sender.cc

@@ -15,7 +15,9 @@
 #include <string>
 #include <utility>
 
+#include "absl/memory/memory.h"
 #include "absl/types/optional.h"
+#include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
 #include "rtc_base/time_utils.h"
 #include "rtc_tools/network_tester/config_reader.h"
@@ -25,7 +27,7 @@ namespace webrtc {
 
 namespace {
 
-class SendPacketTask : public rtc::QueuedTask {
+class SendPacketTask : public QueuedTask {
  public:
   explicit SendPacketTask(PacketSender* packet_sender)
       : target_time_ms_(rtc::TimeMillis()), packet_sender_(packet_sender) {}
@@ -48,7 +50,7 @@ class SendPacketTask : public rtc::QueuedTask {
   PacketSender* const packet_sender_;
 };
 
-class UpdateTestSettingTask : public rtc::QueuedTask {
+class UpdateTestSettingTask : public QueuedTask {
  public:
   UpdateTestSettingTask(PacketSender* packet_sender,
                         std::unique_ptr<ConfigReader> config_reader)
@@ -93,12 +95,9 @@ void PacketSender::StartSending() {
     RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_);
     sending_ = true;
   });
-  worker_queue_.PostTask(
-      std::unique_ptr<rtc::QueuedTask>(new UpdateTestSettingTask(
-          this,
-          std::unique_ptr<ConfigReader>(new ConfigReader(config_file_path_)))));
-  worker_queue_.PostTask(
-      std::unique_ptr<rtc::QueuedTask>(new SendPacketTask(this)));
+  worker_queue_.PostTask(absl::make_unique<UpdateTestSettingTask>(
+      this, absl::make_unique<ConfigReader>(config_file_path_)));
+  worker_queue_.PostTask(absl::make_unique<SendPacketTask>(this));
 }
 
 void PacketSender::StopSending() {

sdk/android/BUILD.gn

@@ -634,6 +634,7 @@ if (is_android) {
       "../../rtc_base:sequenced_task_checker",
       "../../rtc_base:weak_ptr",
       "../../system_wrappers:field_trial",
+      "//third_party/abseil-cpp/absl/memory:memory",
       "//third_party/libyuv",
     ]
   }

sdk/android/src/jni/android_media_encoder.cc

@@ -14,6 +14,8 @@
 #include <string>
 #include <utility>
 
+#include "absl/memory/memory.h"
+#include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_encoder.h"
@@ -32,7 +34,6 @@
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/sequenced_task_checker.h"
-#include "rtc_base/task_queue.h"
 #include "rtc_base/thread.h"
 #include "rtc_base/time_utils.h"
 #include "rtc_base/weak_ptr.h"
@@ -120,7 +121,7 @@ class MediaCodecVideoEncoder : public VideoEncoder {
                        int stride_v);
 
  private:
-  class EncodeTask : public rtc::QueuedTask {
+  class EncodeTask : public QueuedTask {
    public:
     explicit EncodeTask(rtc::WeakPtr<MediaCodecVideoEncoder> encoder);
     bool Run() override;
@@ -223,7 +224,7 @@ class MediaCodecVideoEncoder : public VideoEncoder {
   int64_t last_input_timestamp_ms_;   // Timestamp of last received yuv frame.
   int64_t last_output_timestamp_ms_;  // Timestamp of last encoded frame.
   // Holds the task while the polling loop is paused.
-  std::unique_ptr<rtc::QueuedTask> encode_task_;
+  std::unique_ptr<QueuedTask> encode_task_;
 
   struct InputFrameInfo {
     InputFrameInfo(int64_t encode_start_time,
@@ -397,7 +398,7 @@ bool MediaCodecVideoEncoder::EncodeTask::Run() {
   ScopedLocalRefFrame local_ref_frame(jni);
 
   if (!encoder_->inited_) {
-    encoder_->encode_task_ = std::unique_ptr<rtc::QueuedTask>(this);
+    encoder_->encode_task_ = absl::WrapUnique(this);
     return false;
   }
 
@@ -417,11 +418,11 @@ bool MediaCodecVideoEncoder::EncodeTask::Run() {
 
   // If there aren't more frames to deliver, we can start polling at lower rate.
   if (encoder_->input_frame_infos_.empty()) {
-    TaskQueueBase::Current()->PostDelayedTask(
-        std::unique_ptr<rtc::QueuedTask>(this), kMediaCodecPollNoFramesMs);
+    TaskQueueBase::Current()->PostDelayedTask(absl::WrapUnique(this),
+                                              kMediaCodecPollNoFramesMs);
   } else {
-    TaskQueueBase::Current()->PostDelayedTask(
-        std::unique_ptr<rtc::QueuedTask>(this), kMediaCodecPollMs);
+    TaskQueueBase::Current()->PostDelayedTask(absl::WrapUnique(this),
+                                              kMediaCodecPollMs);
   }
 
   return false;

test/BUILD.gn

@@ -643,6 +643,7 @@ rtc_source_set("fake_video_codecs") {
   deps = [
     "..:webrtc_common",
     "../api:scoped_refptr",
+    "../api/task_queue",
     "../api/video:encoded_image",
     "../api/video:video_bitrate_allocation",
     "../api/video:video_frame",

test/fake_encoder.cc

@@ -17,6 +17,7 @@
 #include <string>
 
 #include "absl/memory/memory.h"
+#include "api/task_queue/queued_task.h"
 #include "api/video/video_content_type.h"
 #include "common_types.h"  // NOLINT(build/include)
 #include "modules/video_coding/codecs/h264/include/h264_globals.h"
@@ -383,7 +384,7 @@ int32_t MultithreadedFakeH264Encoder::InitEncode(const VideoCodec* config,
   return FakeH264Encoder::InitEncode(config, number_of_cores, max_payload_size);
 }
 
-class MultithreadedFakeH264Encoder::EncodeTask : public rtc::QueuedTask {
+class MultithreadedFakeH264Encoder::EncodeTask : public QueuedTask {
  public:
   EncodeTask(MultithreadedFakeH264Encoder* encoder,
              const VideoFrame& input_image,
@@ -415,8 +416,8 @@ int32_t MultithreadedFakeH264Encoder::Encode(
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
 
-  queue->PostTask(std::unique_ptr<rtc::QueuedTask>(
-      new EncodeTask(this, input_image, frame_types)));
+  queue->PostTask(
+      absl::make_unique<EncodeTask>(this, input_image, frame_types));
 
   return WEBRTC_VIDEO_CODEC_OK;
 }

video/BUILD.gn

@@ -126,6 +126,7 @@ rtc_source_set("video_stream_decoder_impl") {
   ]
 
   deps = [
+    "../api/task_queue",
     "../api/video:encoded_frame",
     "../api/video:video_frame",
     "../api/video:video_stream_decoder",

video/video_stream_decoder_impl.cc

@@ -11,6 +11,7 @@
 #include "video/video_stream_decoder_impl.h"
 
 #include "absl/memory/memory.h"
+#include "api/task_queue/queued_task.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/mod_ops.h"
 #include "rtc_base/time_utils.h"
@@ -48,7 +49,7 @@ VideoStreamDecoderImpl::~VideoStreamDecoderImpl() {
 void VideoStreamDecoderImpl::OnFrame(
     std::unique_ptr<video_coding::EncodedFrame> frame) {
   if (!bookkeeping_queue_.IsCurrent()) {
-    struct OnFrameTask : rtc::QueuedTask {
+    struct OnFrameTask : QueuedTask {
       OnFrameTask(std::unique_ptr<video_coding::EncodedFrame> frame,
                   VideoStreamDecoderImpl* video_stream_decoder)
           : frame_(std::move(frame)),