Removes unused keep-alive from RtpTransportControllerSend.

This prepares for future cleanup of how RtpTransportControllerSend is
used.

Bug: webrtc:10365
Change-Id: Idefc7e60f83819627c83b397949c8434d93491b3
Reviewed-on: https://webrtc-review.googlesource.com/c/124783
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26923}

call/rtp_transport_controller_send.cc

@@ -156,10 +156,6 @@ RtpPacketSender* RtpTransportControllerSend::packet_sender() {
   return &pacer_;
 }
 
-const RtpKeepAliveConfig& RtpTransportControllerSend::keepalive_config() const {
-  return keepalive_;
-}
-
 void RtpTransportControllerSend::SetAllocatedSendBitrateLimits(
     int min_send_bitrate_bps,
     int max_padding_bitrate_bps,
@@ -171,11 +167,6 @@ void RtpTransportControllerSend::SetAllocatedSendBitrateLimits(
       DataRate::bps(max_total_bitrate_bps);
   UpdateStreamsConfig();
 }
-
-void RtpTransportControllerSend::SetKeepAliveConfig(
-    const RtpKeepAliveConfig& config) {
-  keepalive_ = config;
-}
 void RtpTransportControllerSend::SetPacingFactor(float pacing_factor) {
   RTC_DCHECK_RUN_ON(&task_queue_);
   streams_config_.pacing_factor = pacing_factor;

call/rtp_transport_controller_send.h

@@ -71,13 +71,11 @@ class RtpTransportControllerSend final
 
   TransportFeedbackObserver* transport_feedback_observer() override;
   RtpPacketSender* packet_sender() override;
-  const RtpKeepAliveConfig& keepalive_config() const override;
 
   void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
                                      int max_padding_bitrate_bps,
                                      int max_total_bitrate_bps) override;
 
-  void SetKeepAliveConfig(const RtpKeepAliveConfig& config);
   void SetPacingFactor(float pacing_factor) override;
   void SetQueueTimeLimit(int limit_ms) override;
   void RegisterPacketFeedbackObserver(
@@ -133,7 +131,6 @@ class RtpTransportControllerSend final
   PacketRouter packet_router_;
   std::vector<std::unique_ptr<RtpVideoSenderInterface>> video_rtp_senders_;
   PacedSender pacer_;
-  RtpKeepAliveConfig keepalive_;
   RtpBitrateConfigurator bitrate_configurator_;
   std::map<std::string, rtc::NetworkRoute> network_routes_;
   const std::unique_ptr<ProcessThread> process_thread_;

call/rtp_transport_controller_send_interface.h

@@ -116,7 +116,6 @@ class RtpTransportControllerSendInterface {
   virtual TransportFeedbackObserver* transport_feedback_observer() = 0;
 
   virtual RtpPacketSender* packet_sender() = 0;
-  virtual const RtpKeepAliveConfig& keepalive_config() const = 0;
 
   // SetAllocatedSendBitrateLimits sets bitrates limits imposed by send codec
   // settings.

call/rtp_video_sender.cc

@@ -213,7 +213,8 @@ RtpVideoSender::RtpVideoSender(
                                         event_log,
                                         retransmission_limiter,
                                         this,
-                                        transport->keepalive_config(),
+                                        // TODO(srte): Remove this argument.
+                                        RtpKeepAliveConfig(),
                                         frame_encryptor,
                                         crypto_options)),
       rtp_config_(rtp_config),

call/test/mock_rtp_transport_controller_send.h

@@ -48,7 +48,6 @@ class MockRtpTransportControllerSend
   MOCK_METHOD0(packet_router, PacketRouter*());
   MOCK_METHOD0(transport_feedback_observer, TransportFeedbackObserver*());
   MOCK_METHOD0(packet_sender, RtpPacketSender*());
-  MOCK_CONST_METHOD0(keepalive_config, RtpKeepAliveConfig&());
   MOCK_METHOD3(SetAllocatedSendBitrateLimits, void(int, int, int));
   MOCK_METHOD1(SetPacingFactor, void(float));
   MOCK_METHOD1(SetQueueTimeLimit, void(int));

video/video_send_stream_impl_unittest.cc

@@ -95,8 +95,6 @@ class VideoSendStreamImplTest : public ::testing::Test {
     config_.rtp.ssrcs.push_back(8080);
     config_.rtp.payload_type = 1;
 
-    EXPECT_CALL(transport_controller_, keepalive_config())
-        .WillRepeatedly(ReturnRef(keepalive_config_));
     EXPECT_CALL(transport_controller_, packet_router())
         .WillRepeatedly(Return(&packet_router_));
     EXPECT_CALL(transport_controller_,

video/video_send_stream_tests.cc

@@ -3719,52 +3719,6 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
   RunBaseTest(&test);
 }
 
-TEST_F(VideoSendStreamTest, SendsKeepAlive) {
-  const int kTimeoutMs = 50;  // Really short timeout for testing.
-
-  class KeepaliveObserver : public test::SendTest {
-   public:
-    KeepaliveObserver() : SendTest(kDefaultTimeoutMs) {}
-
-    void OnRtpTransportControllerSendCreated(
-        RtpTransportControllerSend* controller) override {
-      RtpKeepAliveConfig config;
-      config.timeout_interval_ms = kTimeoutMs;
-      config.payload_type = CallTest::kDefaultKeepalivePayloadType;
-      controller->SetKeepAliveConfig(config);
-    }
-
-   private:
-    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, length, &header));
-
-      if (header.payloadType != CallTest::kDefaultKeepalivePayloadType) {
-        // The video stream has started. Stop it now.
-        if (capturer_)
-          capturer_->Stop();
-      } else {
-        observation_complete_.Set();
-      }
-
-      return SEND_PACKET;
-    }
-
-    void PerformTest() override {
-      EXPECT_TRUE(Wait()) << "Timed out while waiting for keep-alive packet.";
-    }
-
-    void OnFrameGeneratorCapturerCreated(
-        test::FrameGeneratorCapturer* frame_generator_capturer) override {
-      capturer_ = frame_generator_capturer;
-    }
-
-    test::FrameGeneratorCapturer* capturer_ = nullptr;
-  } test;
-
-  RunBaseTest(&test);
-}
-
 class PacingFactorObserver : public test::SendTest {
  public:
   PacingFactorObserver(bool configure_send_side,