admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removes unused keep-alive from RtpTransportControllerSend.

Browse Source 
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}
This commit is contained in:
Sebastian Jansson 2019-02-27 19:06:03 +01:00 committed by Commit Bot
parent 8452a9ec1d
commit 2997ec9a7a
7 changed files with 2 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
call/rtp_transport_controller_send.cc
View File

@ -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;

3
call/rtp_transport_controller_send.h
View File

@ -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_;

1
call/rtp_transport_controller_send_interface.h
View File

@ -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.

3
call/rtp_video_sender.cc
View File

@ -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),

1
call/test/mock_rtp_transport_controller_send.h
View File

@ -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));

2
video/video_send_stream_impl_unittest.cc
View File

@ -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_,

46
video/video_send_stream_tests.cc
View File

@ -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,