Adds network update state cache to scenario tests.

Bug: webrtc:9510
Change-Id: I1ffbc21770f0442086491a07ac7970eaf594a05f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/141400
Reviewed-by: Jonas Olsson <jonasolsson@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28223}

test/scenario/call_client.cc

@@ -86,6 +86,67 @@ std::unique_ptr<RtcEventLog> CreateEventLog(
   return event_log;
 }
 }
+NetworkControleUpdateCache::NetworkControleUpdateCache(
+    std::unique_ptr<NetworkControllerInterface> controller)
+    : controller_(std::move(controller)) {}
+NetworkControlUpdate NetworkControleUpdateCache::OnNetworkAvailability(
+    NetworkAvailability msg) {
+  return Update(controller_->OnNetworkAvailability(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnNetworkRouteChange(
+    NetworkRouteChange msg) {
+  return Update(controller_->OnNetworkRouteChange(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnProcessInterval(
+    ProcessInterval msg) {
+  return Update(controller_->OnProcessInterval(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnRemoteBitrateReport(
+    RemoteBitrateReport msg) {
+  return Update(controller_->OnRemoteBitrateReport(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnRoundTripTimeUpdate(
+    RoundTripTimeUpdate msg) {
+  return Update(controller_->OnRoundTripTimeUpdate(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnSentPacket(SentPacket msg) {
+  return Update(controller_->OnSentPacket(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnReceivedPacket(
+    ReceivedPacket msg) {
+  return Update(controller_->OnReceivedPacket(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnStreamsConfig(
+    StreamsConfig msg) {
+  return Update(controller_->OnStreamsConfig(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnTargetRateConstraints(
+    TargetRateConstraints msg) {
+  return Update(controller_->OnTargetRateConstraints(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnTransportLossReport(
+    TransportLossReport msg) {
+  return Update(controller_->OnTransportLossReport(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::OnTransportPacketsFeedback(
+    TransportPacketsFeedback msg) {
+  return Update(controller_->OnTransportPacketsFeedback(msg));
+}
+NetworkControlUpdate NetworkControleUpdateCache::update_state() const {
+  return update_state_;
+}
+NetworkControlUpdate NetworkControleUpdateCache::Update(
+    NetworkControlUpdate update) {
+  if (update.target_rate)
+    update_state_.target_rate = update.target_rate;
+  if (update.pacer_config)
+    update_state_.pacer_config = update.pacer_config;
+  if (update.congestion_window)
+    update_state_.congestion_window = update.congestion_window;
+  if (!update.probe_cluster_configs.empty())
+    update_state_.probe_cluster_configs = update.probe_cluster_configs;
+  return update;
+}
 
 LoggingNetworkControllerFactory::LoggingNetworkControllerFactory(
     LogWriterFactoryInterface* log_writer_factory,
@@ -114,9 +175,18 @@ void LoggingNetworkControllerFactory::LogCongestionControllerStats(
     goog_cc_factory_.PrintState(at_time);
 }
 
+NetworkControlUpdate LoggingNetworkControllerFactory::GetUpdate() const {
+  if (last_controller_)
+    return last_controller_->update_state();
+  return NetworkControlUpdate();
+}
+
 std::unique_ptr<NetworkControllerInterface>
 LoggingNetworkControllerFactory::Create(NetworkControllerConfig config) {
-  return cc_factory_->Create(config);
+  auto controller = absl::make_unique<NetworkControleUpdateCache>(
+      cc_factory_->Create(config));
+  last_controller_ = controller.get();
+  return controller;
 }
 
 TimeDelta LoggingNetworkControllerFactory::GetProcessInterval() const {
@@ -172,6 +242,19 @@ Call::Stats CallClient::GetStats() {
   return call_->GetStats();
 }
 
+DataRate CallClient::target_rate() const {
+  return network_controller_factory_.GetUpdate().target_rate->target_rate;
+}
+
+DataRate CallClient::link_capacity() const {
+  return network_controller_factory_.GetUpdate()
+      .target_rate->network_estimate.bandwidth;
+}
+
+DataRate CallClient::padding_rate() const {
+  return network_controller_factory_.GetUpdate().pacer_config->pad_rate();
+}
+
 void CallClient::OnPacketReceived(EmulatedIpPacket packet) {
   // Removes added overhead before delivering packet to sender.
   size_t size =

test/scenario/call_client.h

@@ -33,6 +33,34 @@
 namespace webrtc {
 
 namespace test {
+// Helper class to capture network controller state.
+class NetworkControleUpdateCache : public NetworkControllerInterface {
+ public:
+  explicit NetworkControleUpdateCache(
+      std::unique_ptr<NetworkControllerInterface> controller);
+
+  NetworkControlUpdate OnNetworkAvailability(NetworkAvailability msg) override;
+  NetworkControlUpdate OnNetworkRouteChange(NetworkRouteChange msg) override;
+  NetworkControlUpdate OnProcessInterval(ProcessInterval msg) override;
+  NetworkControlUpdate OnRemoteBitrateReport(RemoteBitrateReport msg) override;
+  NetworkControlUpdate OnRoundTripTimeUpdate(RoundTripTimeUpdate msg) override;
+  NetworkControlUpdate OnSentPacket(SentPacket msg) override;
+  NetworkControlUpdate OnReceivedPacket(ReceivedPacket msg) override;
+  NetworkControlUpdate OnStreamsConfig(StreamsConfig msg) override;
+  NetworkControlUpdate OnTargetRateConstraints(
+      TargetRateConstraints msg) override;
+  NetworkControlUpdate OnTransportLossReport(TransportLossReport msg) override;
+  NetworkControlUpdate OnTransportPacketsFeedback(
+      TransportPacketsFeedback msg) override;
+
+  NetworkControlUpdate update_state() const;
+
+ private:
+  NetworkControlUpdate Update(NetworkControlUpdate update);
+  const std::unique_ptr<NetworkControllerInterface> controller_;
+  NetworkControlUpdate update_state_;
+};
+
 class LoggingNetworkControllerFactory
     : public NetworkControllerFactoryInterface {
  public:
@@ -46,10 +74,13 @@ class LoggingNetworkControllerFactory
   // TODO(srte): Consider using the Columnprinter interface for this.
   void LogCongestionControllerStats(Timestamp at_time);
 
+  NetworkControlUpdate GetUpdate() const;
+
  private:
   GoogCcDebugFactory goog_cc_factory_;
   NetworkControllerFactoryInterface* cc_factory_ = nullptr;
   bool print_cc_state_ = false;
+  NetworkControleUpdateCache* last_controller_ = nullptr;
 };
 
 struct CallClientFakeAudio {
@@ -73,6 +104,9 @@ class CallClient : public EmulatedNetworkReceiverInterface {
   DataRate send_bandwidth() {
     return DataRate::bps(GetStats().send_bandwidth_bps);
   }
+  DataRate target_rate() const;
+  DataRate link_capacity() const;
+  DataRate padding_rate() const;
 
   void OnPacketReceived(EmulatedIpPacket packet) override;
   std::unique_ptr<RtcEventLogOutput> GetLogWriter(std::string name);