commit 800e121dcaf45d1aa60d2ac5c9db3438b9629d0c
author Sebastian Jansson <srte@webrtc.org> Mon Oct 22 11:49:03 2018 +0200
committer Commit Bot <commit-bot@chromium.org> Mon Oct 22 11:14:37 2018 +0000
tree b97c11d75f889b037302452ede5dfd33f6d1d76c
parent 8d33c0c1044a091b2f70f7a542d8148086fd32f4

Adds support to change transport routes in Scenario tests.

This CL makes it possible to change transport routes while running
a scenario based test.

To make this possible in a consistent manner, the scenario test
framework is modified to only allow shared transport for all streams
between two CallClients. This is what typically is done in practice and
it is quite complex to even reason about the implications of using
mixed transports for a single call.

Bug: webrtc:9718
Change-Id: Ib836928feed98aa2bbbe0295e158157a6518348b
Reviewed-on: https://webrtc-review.googlesource.com/c/107200
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25287}

test/scenario/network_node.cc

diff --git a/test/scenario/network_node.cc b/test/scenario/network_node.cc
index 87fc32a..b39d67b 100644
--- a/test/scenario/network_node.cc
+++ b/test/scenario/network_node.cc
@@ -170,21 +170,16 @@
       simulated_network_(simulation),
       config_(config) {}
 
-NetworkNodeTransport::NetworkNodeTransport(CallClient* sender,
-                                           NetworkNode* send_net,
-                                           uint64_t receiver,
-                                           DataSize packet_overhead)
-    : sender_(sender),
-      send_net_(send_net),
-      receiver_id_(receiver),
-      packet_overhead_(packet_overhead) {}
+NetworkNodeTransport::NetworkNodeTransport(const Clock* sender_clock,
+                                           Call* sender_call)
+    : sender_clock_(sender_clock), sender_call_(sender_call) {}
 
 NetworkNodeTransport::~NetworkNodeTransport() = default;
 
 bool NetworkNodeTransport::SendRtp(const uint8_t* packet,
                                    size_t length,
                                    const PacketOptions& options) {
-  int64_t send_time_ms = sender_->clock_->TimeInMilliseconds();
+  int64_t send_time_ms = sender_clock_->TimeInMilliseconds();
   rtc::SentPacket sent_packet;
   sent_packet.packet_id = options.packet_id;
   sent_packet.info.included_in_feedback = options.included_in_feedback;
@@ -192,9 +187,12 @@
   sent_packet.send_time_ms = send_time_ms;
   sent_packet.info.packet_size_bytes = length;
   sent_packet.info.packet_type = rtc::PacketType::kData;
-  sender_->call_->OnSentPacket(sent_packet);
+  sender_call_->OnSentPacket(sent_packet);
 
   Timestamp send_time = Timestamp::ms(send_time_ms);
+  rtc::CritScope crit(&crit_sect_);
+  if (!send_net_)
+    return false;
   rtc::CopyOnWriteBuffer buffer(packet, length,
                                 length + packet_overhead_.bytes());
   buffer.SetSize(length + packet_overhead_.bytes());
@@ -203,13 +201,29 @@
 
 bool NetworkNodeTransport::SendRtcp(const uint8_t* packet, size_t length) {
   rtc::CopyOnWriteBuffer buffer(packet, length);
-  Timestamp send_time = Timestamp::ms(sender_->clock_->TimeInMilliseconds());
+  Timestamp send_time = Timestamp::ms(sender_clock_->TimeInMilliseconds());
+  rtc::CritScope crit(&crit_sect_);
   buffer.SetSize(length + packet_overhead_.bytes());
+  if (!send_net_)
+    return false;
   return send_net_->TryDeliverPacket(buffer, receiver_id_, send_time);
 }
 
-uint64_t NetworkNodeTransport::ReceiverId() const {
-  return receiver_id_;
+void NetworkNodeTransport::Connect(NetworkNode* send_node,
+                                   uint64_t receiver_id,
+                                   DataSize packet_overhead) {
+  rtc::CritScope crit(&crit_sect_);
+  send_net_ = send_node;
+  receiver_id_ = receiver_id;
+  packet_overhead_ = packet_overhead;
+
+  rtc::NetworkRoute route;
+  route.connected = true;
+  route.local_network_id = receiver_id;
+  route.remote_network_id = receiver_id;
+  std::string transport_name = "dummy";
+  sender_call_->GetTransportControllerSend()->OnNetworkRouteChanged(
+      transport_name, route);
 }
 
 CrossTrafficSource::CrossTrafficSource(NetworkReceiverInterface* target,