Use SingleThreadedTaskQueue in DirectTransport

webrtc/test/direct_transport.cc

Index: webrtc/test/direct_transport.cc
diff --git a/webrtc/test/direct_transport.cc b/webrtc/test/direct_transport.cc
index 370425c5374930f7562e3f23f71277444a43d2e5..9ed8f850ae317bd17028315161d160a72d6b52b9 100644
--- a/webrtc/test/direct_transport.cc
+++ b/webrtc/test/direct_transport.cc
@@ -11,57 +11,63 @@
 
 #include "webrtc/call/call.h"
 #include "webrtc/system_wrappers/include/clock.h"
+#include "webrtc/test/single_threaded_task_queue.h"
 
 namespace webrtc {
 namespace test {
 
 DirectTransport::DirectTransport(
+    SingleThreadedTaskQueueForTesting* task_queue,
     Call* send_call,
     const std::map<uint8_t, MediaType>& payload_type_map)
-    : DirectTransport(FakeNetworkPipe::Config(), send_call, payload_type_map) {}
+    : DirectTransport(task_queue,
+                      FakeNetworkPipe::Config(),
+                      send_call,
+                      payload_type_map) {
+  RTC_DCHECK(task_queue);
+}
 
 DirectTransport::DirectTransport(
+    SingleThreadedTaskQueueForTesting* task_queue,
     const FakeNetworkPipe::Config& config,
     Call* send_call,
     const std::map<uint8_t, MediaType>& payload_type_map)
     : DirectTransport(
+          task_queue,
           config,
           send_call,
-          std::unique_ptr<Demuxer>(new DemuxerImpl(payload_type_map))) {}
+          std::unique_ptr<Demuxer>(new DemuxerImpl(payload_type_map))) {
+  RTC_DCHECK(task_queue);
+}
 
-DirectTransport::DirectTransport(const FakeNetworkPipe::Config& config,
+DirectTransport::DirectTransport(SingleThreadedTaskQueueForTesting* task_queue,
+                                 const FakeNetworkPipe::Config& config,
                                  Call* send_call,
                                  std::unique_ptr<Demuxer> demuxer)
     : send_call_(send_call),
-      packet_event_(false, false),
-      thread_(NetworkProcess, this, "NetworkProcess"),
       clock_(Clock::GetRealTimeClock()),
-      shutting_down_(false),
+      task_queue_(task_queue),
       fake_network_(clock_, config, std::move(demuxer)) {
-  thread_.Start();
   if (send_call_) {
     send_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
     send_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
   }
+  SendPackets();
 }
 
-DirectTransport::~DirectTransport() { StopSending(); }
+DirectTransport::~DirectTransport() {
+  RTC_DCHECK_RUN_ON(&thread_checker_);
+  // Constructor updates |next_scheduled_task_|, so it's guaranteed to
+  // be initialized.
+  task_queue_->CancelTask(next_scheduled_task_);

[nisse-webrtc, 2017/08/18 11:08:29]

So we only need Cancel for tasks which were posted with a delay?

[eladalon, 2017/08/18 12:12:37]

The delay doesn't matter. What matters is that we can only delay tasks which
were posted (asynchronous), not ones that were sent (synchronous).
1. The reason is mostly that we don't really ever need to cancel the latter, and
since this class will only be used in tests, there's no reason to support more
than we need.
2. An additional reason is that an asynchronous task has an obvious entity to
provide the cancellation handle to - the caller of Post(). But a synchronous
task won't be able to do that until the task has already been executed, meaning
it's un-cancellable. Ways around this would be significant overkill, especially
given that it isn't used.

+}
 
 void DirectTransport::SetConfig(const FakeNetworkPipe::Config& config) {
   fake_network_.SetConfig(config);
 }
 
-void DirectTransport::StopSending() {
-  {
-    rtc::CritScope crit(&lock_);
-    shutting_down_ = true;
-  }
-
-  packet_event_.Set();
-  thread_.Stop();
-}
-
 void DirectTransport::SetReceiver(PacketReceiver* receiver) {
+  RTC_DCHECK_RUN_ON(&thread_checker_);
   fake_network_.SetReceiver(receiver);
 }
 
@@ -74,13 +80,11 @@ bool DirectTransport::SendRtp(const uint8_t* data,
     send_call_->OnSentPacket(sent_packet);
   }
   fake_network_.SendPacket(data, length);
-  packet_event_.Set();
   return true;
 }
 
 bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) {
   fake_network_.SendPacket(data, length);
-  packet_event_.Set();
   return true;
 }
 
@@ -104,18 +108,15 @@ void DirectTransport::ForceDemuxer::DeliverPacket(
                                   packet->data_length(), packet_time);
 }
 
-bool DirectTransport::NetworkProcess(void* transport) {
-  return static_cast<DirectTransport*>(transport)->SendPackets();
-}
+void DirectTransport::SendPackets() {
+  RTC_DCHECK_RUN_ON(&thread_checker_);
 
-bool DirectTransport::SendPackets() {
   fake_network_.Process();
-  int64_t wait_time_ms = fake_network_.TimeUntilNextProcess();
-  if (wait_time_ms > 0) {
-    packet_event_.Wait(static_cast<int>(wait_time_ms));
-  }
-  rtc::CritScope crit(&lock_);
-  return shutting_down_ ? false : true;
+
+  int64_t delay_ms = fake_network_.TimeUntilNextProcess();
+  next_scheduled_task_ = task_queue_->PostDelayedTask([this]() {
+    SendPackets();
+  }, delay_ms);
 }
 }  // namespace test
 }  // namespace webrtc