Allow injection of custom network models in place of FakeNetworkPipe.

Adds a constructor for DirectTransport that takes a pointer to an instance 
of a class derived from FakeNetworkPipe. Said class can override Process() 
and SendPacket(...) members thereby emulating any desired network behavior.

Bug: b/67487983
Change-Id: I829fd3506124db61587af19192a14fdf62b06ca5
Reviewed-on: https://webrtc-review.googlesource.com/14620
Commit-Queue: Christoffer Rodbro <crodbro@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20443}

test/direct_transport.cc

@@ -46,13 +46,19 @@ DirectTransport::DirectTransport(SingleThreadedTaskQueueForTesting* task_queue,
     : send_call_(send_call),
       clock_(Clock::GetRealTimeClock()),
       task_queue_(task_queue),
-      fake_network_(clock_, config, std::move(demuxer)) {
+      fake_network_(rtc::MakeUnique<FakeNetworkPipe>(clock_, config,
-  RTC_DCHECK(task_queue);
+                                                      std::move(demuxer))) {
-  if (send_call_) {
+  Start();
-    send_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
+}
-    send_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
+
-  }
+DirectTransport::DirectTransport(SingleThreadedTaskQueueForTesting* task_queue,
-  SendPackets();
+                                 std::unique_ptr<FakeNetworkPipe> pipe,
+                                 Call* send_call)
+    : send_call_(send_call),
+      clock_(Clock::GetRealTimeClock()),
+      task_queue_(task_queue),
+      fake_network_(std::move(pipe)) {
+  Start();
 }
 
 DirectTransport::~DirectTransport() {
@@ -63,7 +69,7 @@ DirectTransport::~DirectTransport() {
 }
 
 void DirectTransport::SetConfig(const FakeNetworkPipe::Config& config) {
-  fake_network_.SetConfig(config);
+  fake_network_->SetConfig(config);
 }
 
 void DirectTransport::StopSending() {
@@ -73,7 +79,7 @@ void DirectTransport::StopSending() {
 
 void DirectTransport::SetReceiver(PacketReceiver* receiver) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
-  fake_network_.SetReceiver(receiver);
+  fake_network_->SetReceiver(receiver);
 }
 
 bool DirectTransport::SendRtp(const uint8_t* data,
@@ -84,25 +90,34 @@ bool DirectTransport::SendRtp(const uint8_t* data,
                                 clock_->TimeInMilliseconds());
     send_call_->OnSentPacket(sent_packet);
   }
-  fake_network_.SendPacket(data, length);
+  fake_network_->SendPacket(data, length);
   return true;
 }
 
 bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) {
-  fake_network_.SendPacket(data, length);
+  fake_network_->SendPacket(data, length);
   return true;
 }
 
 int DirectTransport::GetAverageDelayMs() {
-  return fake_network_.AverageDelay();
+  return fake_network_->AverageDelay();
+}
+
+void DirectTransport::Start() {
+  RTC_DCHECK(task_queue_);
+  if (send_call_) {
+    send_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
+    send_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
+  }
+  SendPackets();
 }
 
 void DirectTransport::SendPackets() {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
 
-  fake_network_.Process();
+  fake_network_->Process();
 
-  int64_t delay_ms = fake_network_.TimeUntilNextProcess();
+  int64_t delay_ms = fake_network_->TimeUntilNextProcess();
   next_scheduled_task_ = task_queue_->PostDelayedTask([this]() {
     SendPackets();
   }, delay_ms);

test/direct_transport.h

@@ -46,6 +46,9 @@ class DirectTransport : public Transport {
                   Call* send_call,
                   std::unique_ptr<Demuxer> demuxer);
 
+  DirectTransport(SingleThreadedTaskQueueForTesting* task_queue,
+                  std::unique_ptr<FakeNetworkPipe> pipe, Call* send_call);
+
   ~DirectTransport() override;
 
   void SetConfig(const FakeNetworkPipe::Config& config);
@@ -64,6 +67,7 @@ class DirectTransport : public Transport {
 
  private:
   void SendPackets();
+  void Start();
 
   Call* const send_call_;
   Clock* const clock_;
@@ -72,7 +76,7 @@ class DirectTransport : public Transport {
   SingleThreadedTaskQueueForTesting::TaskId next_scheduled_task_
       RTC_GUARDED_BY(&sequence_checker_);
 
-  FakeNetworkPipe fake_network_;
+  std::unique_ptr<FakeNetworkPipe> fake_network_;
 
   rtc::SequencedTaskChecker sequence_checker_;
 };

test/fake_network_pipe.h

@@ -114,21 +114,20 @@ class FakeNetworkPipe {
                   const FakeNetworkPipe::Config& config,
                   std::unique_ptr<Demuxer> demuxer,
                   uint64_t seed);
-  ~FakeNetworkPipe();
+  virtual ~FakeNetworkPipe();
-
 
   // Sets a new configuration. This won't affect packets already in the pipe.
   void SetConfig(const FakeNetworkPipe::Config& config);
 
   // Sends a new packet to the link.
-  void SendPacket(const uint8_t* packet, size_t packet_length);
+  virtual void SendPacket(const uint8_t* packet, size_t packet_length);
 
   // Must not be called in parallel with SendPacket or Process.
   void SetReceiver(PacketReceiver* receiver);
 
   // Processes the network queues and trigger PacketReceiver::IncomingPacket for
   // packets ready to be delivered.
-  void Process();
+  virtual void Process();
   int64_t TimeUntilNextProcess() const;
 
   // Get statistics.
@@ -137,7 +136,7 @@ class FakeNetworkPipe {
   size_t dropped_packets() { return dropped_packets_; }
   size_t sent_packets() { return sent_packets_; }
 
- private:
+ protected:
   Clock* const clock_;
   rtc::CriticalSection lock_;
   const std::unique_ptr<Demuxer> demuxer_;

test/rtp_rtcp_observer.h

@@ -105,6 +105,14 @@ class PacketTransport : public test::DirectTransport {
         observer_(observer),
         transport_type_(transport_type) {}
 
+  PacketTransport(SingleThreadedTaskQueueForTesting* task_queue,
+                  Call* send_call, RtpRtcpObserver* observer,
+                  TransportType transport_type,
+                  std::unique_ptr<FakeNetworkPipe> nw_pipe)
+      : test::DirectTransport(task_queue, std::move(nw_pipe), send_call),
+        observer_(observer),
+        transport_type_(transport_type) {}
+
  private:
   bool SendRtp(const uint8_t* packet,
                size_t length,