From 0a5ed896e2c4f38c182ff4ddef9b86004f55c789 Mon Sep 17 00:00:00 2001 From: Sebastian Jansson Date: Wed, 18 Sep 2019 15:37:31 +0200 Subject: [PATCH] Adds remote estimates to rtc event log. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:10742 Change-Id: I0db998a05492603fcdeedca780d9ee3d64aa00d4 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/151651 Reviewed-by: Björn Terelius Reviewed-by: Per Kjellander Commit-Queue: Sebastian Jansson Cr-Commit-Position: refs/heads/master@{#29233} --- api/rtc_event_log/rtc_event.h | 1 + call/rtp_transport_controller_send.cc | 5 ++ logging/BUILD.gn | 3 + .../encoder/rtc_event_log_encoder_legacy.cc | 1 + .../rtc_event_log_encoder_new_format.cc | 81 +++++++++++++++++++ .../rtc_event_log_encoder_new_format.h | 3 + .../encoder/rtc_event_log_encoder_unittest.cc | 22 +++++ .../events/rtc_event_remote_estimate.h | 34 ++++++++ logging/rtc_event_log/logged_events.h | 11 +++ logging/rtc_event_log/rtc_event_log2.proto | 18 +++++ logging/rtc_event_log/rtc_event_log_parser.cc | 67 ++++++++++++++- logging/rtc_event_log/rtc_event_log_parser.h | 6 ++ .../rtc_event_log/rtc_event_log_unittest.cc | 1 + .../rtc_event_log_unittest_helper.cc | 16 ++++ .../rtc_event_log_unittest_helper.h | 6 ++ 15 files changed, 274 insertions(+), 1 deletion(-) create mode 100644 logging/rtc_event_log/events/rtc_event_remote_estimate.h diff --git a/api/rtc_event_log/rtc_event.h b/api/rtc_event_log/rtc_event.h index 1b7fa5593a..101f78f255 100644 --- a/api/rtc_event_log/rtc_event.h +++ b/api/rtc_event_log/rtc_event.h @@ -30,6 +30,7 @@ class RtcEvent { enum class Type { AlrStateEvent, RouteChangeEvent, + RemoteEstimateEvent, AudioNetworkAdaptation, AudioPlayout, AudioReceiveStreamConfig, diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc index 36385d0370..3b3394de3b 100644 --- a/call/rtp_transport_controller_send.cc +++ b/call/rtp_transport_controller_send.cc @@ -20,6 +20,7 @@ #include "api/units/time_delta.h" #include "api/units/timestamp.h" #include "call/rtp_video_sender.h" +#include "logging/rtc_event_log/events/rtc_event_remote_estimate.h" #include "logging/rtc_event_log/events/rtc_event_route_change.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" @@ -472,6 +473,10 @@ void RtpTransportControllerSend::OnTransportFeedback( void RtpTransportControllerSend::OnRemoteNetworkEstimate( NetworkStateEstimate estimate) { + if (event_log_) { + event_log_->Log(std::make_unique( + estimate.link_capacity_lower, estimate.link_capacity_upper)); + } estimate.update_time = Timestamp::ms(clock_->TimeInMilliseconds()); task_queue_.PostTask([this, estimate] { RTC_DCHECK_RUN_ON(&task_queue_); diff --git a/logging/BUILD.gn b/logging/BUILD.gn index 190b411b62..2876899e23 100644 --- a/logging/BUILD.gn +++ b/logging/BUILD.gn @@ -95,6 +95,7 @@ rtc_source_set("rtc_event_bwe") { "rtc_event_log/events/rtc_event_probe_result_failure.h", "rtc_event_log/events/rtc_event_probe_result_success.cc", "rtc_event_log/events/rtc_event_probe_result_success.h", + "rtc_event_log/events/rtc_event_remote_estimate.h", "rtc_event_log/events/rtc_event_route_change.cc", "rtc_event_log/events/rtc_event_route_change.h", ] @@ -102,8 +103,10 @@ rtc_source_set("rtc_event_bwe") { deps = [ "../api:scoped_refptr", "../api/rtc_event_log", + "../api/units:data_rate", "../modules/remote_bitrate_estimator", "//third_party/abseil-cpp/absl/memory", + "//third_party/abseil-cpp/absl/types:optional", ] } diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc index 2d19c3bf81..7b3548508f 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_legacy.cc @@ -363,6 +363,7 @@ std::string RtcEventLogEncoderLegacy::Encode(const RtcEvent& event) { return EncodeVideoSendStreamConfig(rtc_event); } case RtcEvent::Type::RouteChangeEvent: + case RtcEvent::Type::RemoteEstimateEvent: case RtcEvent::Type::GenericPacketReceived: case RtcEvent::Type::GenericPacketSent: case RtcEvent::Type::GenericAckReceived: diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc index d397680d2b..70c7f37356 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc @@ -32,6 +32,7 @@ #include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h" #include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h" #include "logging/rtc_event_log/events/rtc_event_probe_result_success.h" +#include "logging/rtc_event_log/events/rtc_event_remote_estimate.h" #include "logging/rtc_event_log/events/rtc_event_route_change.h" #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h" #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h" @@ -686,6 +687,7 @@ std::string RtcEventLogEncoderNewFormat::EncodeBatch( std::vector probe_result_failure_events; std::vector probe_result_success_events; std::vector route_change_events; + std::vector remote_estimate_events; std::vector incoming_rtcp_packets; std::vector outgoing_rtcp_packets; std::map> @@ -779,6 +781,12 @@ std::string RtcEventLogEncoderNewFormat::EncodeBatch( route_change_events.push_back(rtc_event); break; } + case RtcEvent::Type::RemoteEstimateEvent: { + auto* rtc_event = + static_cast(it->get()); + remote_estimate_events.push_back(rtc_event); + break; + } case RtcEvent::Type::RtcpPacketIncoming: { auto* rtc_event = static_cast(it->get()); @@ -873,6 +881,7 @@ std::string RtcEventLogEncoderNewFormat::EncodeBatch( EncodeProbeResultFailure(probe_result_failure_events, &event_stream); EncodeProbeResultSuccess(probe_result_success_events, &event_stream); EncodeRouteChange(route_change_events, &event_stream); + EncodeRemoteEstimate(remote_estimate_events, &event_stream); EncodeRtcpPacketIncoming(incoming_rtcp_packets, &event_stream); EncodeRtcpPacketOutgoing(outgoing_rtcp_packets, &event_stream); EncodeRtpPacketIncoming(incoming_rtp_packets, &event_stream); @@ -1322,6 +1331,78 @@ void RtcEventLogEncoderNewFormat::EncodeRouteChange( // TODO(terelius): Should we delta-compress this event type? } +void RtcEventLogEncoderNewFormat::EncodeRemoteEstimate( + rtc::ArrayView batch, + rtclog2::EventStream* event_stream) { + if (batch.empty()) + return; + + // Base event + const auto* const base_event = batch[0]; + rtclog2::RemoteEstimates* proto_batch = event_stream->add_remote_estimates(); + + proto_batch->set_timestamp_ms(base_event->timestamp_ms()); + + absl::optional base_link_capacity_lower; + if (base_event->link_capacity_lower_.IsFinite()) { + base_link_capacity_lower = + base_event->link_capacity_lower_.kbps(); + proto_batch->set_link_capacity_lower_kbps(*base_link_capacity_lower); + } + absl::optional base_link_capacity_upper; + if (base_event->link_capacity_upper_.IsFinite()) { + base_link_capacity_upper = + base_event->link_capacity_upper_.kbps(); + proto_batch->set_link_capacity_upper_kbps(*base_link_capacity_upper); + } + + if (batch.size() == 1) + return; + + // Delta encoding + proto_batch->set_number_of_deltas(batch.size() - 1); + std::vector> values(batch.size() - 1); + std::string encoded_deltas; + + // timestamp_ms + for (size_t i = 0; i < values.size(); ++i) { + const auto* event = batch[i + 1]; + values[i] = ToUnsigned(event->timestamp_ms()); + } + encoded_deltas = EncodeDeltas(ToUnsigned(base_event->timestamp_ms()), values); + if (!encoded_deltas.empty()) { + proto_batch->set_timestamp_ms_deltas(encoded_deltas); + } + + // link_capacity_lower_kbps + for (size_t i = 0; i < values.size(); ++i) { + const auto* event = batch[i + 1]; + if (base_event->link_capacity_lower_.IsFinite()) { + values[i] = event->link_capacity_lower_.kbps(); + } else { + values[i].reset(); + } + } + encoded_deltas = EncodeDeltas(base_link_capacity_lower, values); + if (!encoded_deltas.empty()) { + proto_batch->set_link_capacity_lower_kbps_deltas(encoded_deltas); + } + + // link_capacity_upper_kbps + for (size_t i = 0; i < values.size(); ++i) { + const auto* event = batch[i + 1]; + if (base_event->link_capacity_upper_.IsFinite()) { + values[i] = event->link_capacity_upper_.kbps(); + } else { + values[i].reset(); + } + } + encoded_deltas = EncodeDeltas(base_link_capacity_upper, values); + if (!encoded_deltas.empty()) { + proto_batch->set_link_capacity_upper_kbps_deltas(encoded_deltas); + } +} + void RtcEventLogEncoderNewFormat::EncodeRtcpPacketIncoming( rtc::ArrayView batch, rtclog2::EventStream* event_stream) { diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h index 7b410e54b6..d25184ec4a 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.h @@ -28,6 +28,7 @@ class EventStream; // Auto-generated from protobuf. class RtcEventAlrState; class RtcEventRouteChange; +class RtcEventRemoteEstimate; class RtcEventAudioNetworkAdaptation; class RtcEventAudioPlayout; class RtcEventAudioReceiveStreamConfig; @@ -123,6 +124,8 @@ class RtcEventLogEncoderNewFormat final : public RtcEventLogEncoder { rtclog2::EventStream* event_stream); void EncodeRouteChange(rtc::ArrayView batch, rtclog2::EventStream* event_stream); + void EncodeRemoteEstimate(rtc::ArrayView batch, + rtclog2::EventStream* event_stream); void EncodeRtcpPacketIncoming( rtc::ArrayView batch, rtclog2::EventStream* event_stream); diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc index 0bea93dcd0..2bd77d940e 100644 --- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc +++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc @@ -239,6 +239,28 @@ TEST_P(RtcEventLogEncoderTest, RtcEventRouteChange) { } } +TEST_P(RtcEventLogEncoderTest, RtcEventRemoteEstimate) { + if (!new_encoding_) { + return; + } + std::vector> events(event_count_); + for (size_t i = 0; i < event_count_; ++i) { + events[i] = (i == 0 || !force_repeated_fields_) + ? gen_.NewRemoteEstimate() + : std::make_unique(*events[0]); + history_.push_back(std::make_unique(*events[i])); + } + + std::string encoded = encoder_->EncodeBatch(history_.begin(), history_.end()); + ASSERT_TRUE(parsed_log_.ParseString(encoded)); + const auto& parsed_events = parsed_log_.remote_estimate_events(); + + ASSERT_EQ(parsed_events.size(), event_count_); + for (size_t i = 0; i < event_count_; ++i) { + verifier_.VerifyLoggedRemoteEstimateEvent(*events[i], parsed_events[i]); + } +} + TEST_P(RtcEventLogEncoderTest, RtcEventAudioNetworkAdaptationBitrate) { std::vector> events( event_count_); diff --git a/logging/rtc_event_log/events/rtc_event_remote_estimate.h b/logging/rtc_event_log/events/rtc_event_remote_estimate.h new file mode 100644 index 0000000000..b7919483cc --- /dev/null +++ b/logging/rtc_event_log/events/rtc_event_remote_estimate.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ +#ifndef LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_REMOTE_ESTIMATE_H_ +#define LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_REMOTE_ESTIMATE_H_ + +#include + +#include "absl/types/optional.h" +#include "api/rtc_event_log/rtc_event.h" +#include "api/units/data_rate.h" + +namespace webrtc { + +class RtcEventRemoteEstimate final : public RtcEvent { + public: + RtcEventRemoteEstimate(DataRate link_capacity_lower, + DataRate link_capacity_upper) + : link_capacity_lower_(link_capacity_lower), + link_capacity_upper_(link_capacity_upper) {} + Type GetType() const override { return RtcEvent::Type::RemoteEstimateEvent; } + bool IsConfigEvent() const override { return false; } + + const DataRate link_capacity_lower_; + const DataRate link_capacity_upper_; +}; +} // namespace webrtc +#endif // LOGGING_RTC_EVENT_LOG_EVENTS_RTC_EVENT_REMOTE_ESTIMATE_H_ diff --git a/logging/rtc_event_log/logged_events.h b/logging/rtc_event_log/logged_events.h index a67f17b46d..4706742ab2 100644 --- a/logging/rtc_event_log/logged_events.h +++ b/logging/rtc_event_log/logged_events.h @@ -239,6 +239,17 @@ struct LoggedRouteChangeEvent { uint32_t overhead; }; +struct LoggedRemoteEstimateEvent { + LoggedRemoteEstimateEvent() = default; + + int64_t log_time_us() const { return timestamp_ms * 1000; } + int64_t log_time_ms() const { return timestamp_ms; } + + int64_t timestamp_ms; + absl::optional link_capacity_lower; + absl::optional link_capacity_upper; +}; + struct LoggedRtpPacket { LoggedRtpPacket(uint64_t timestamp_us, RTPHeader header, diff --git a/logging/rtc_event_log/rtc_event_log2.proto b/logging/rtc_event_log/rtc_event_log2.proto index 64c9d24d30..0cdb2a43c7 100644 --- a/logging/rtc_event_log/rtc_event_log2.proto +++ b/logging/rtc_event_log/rtc_event_log2.proto @@ -38,6 +38,7 @@ message EventStream { repeated GenericPacketReceived generic_packets_received = 30; repeated GenericAckReceived generic_acks_received = 31; repeated RouteChange route_changes = 32; + repeated RemoteEstimates remote_estimates = 33; repeated AudioRecvStreamConfig audio_recv_stream_configs = 101; repeated AudioSendStreamConfig audio_send_stream_configs = 102; @@ -664,3 +665,20 @@ message RouteChange { // required - The per packet data overhead for this route. optional uint32 overhead = 3; } + +message RemoteEstimates { + // required + optional int64 timestamp_ms = 1; + // optional - value used as a safe measure of available capacity. + optional uint32 link_capacity_lower_kbps = 2; + // optional - value used as limit for increasing bitrate. + optional uint32 link_capacity_upper_kbps = 3; + + // optional - required if the batch contains delta encoded events. + optional uint32 number_of_deltas = 4; + + // Delta encodings. + optional bytes timestamp_ms_deltas = 101; + optional bytes link_capacity_lower_kbps_deltas = 102; + optional bytes link_capacity_upper_kbps_deltas = 103; +} diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc index 45d4ea430f..6b9f9d85c2 100644 --- a/logging/rtc_event_log/rtc_event_log_parser.cc +++ b/logging/rtc_event_log/rtc_event_log_parser.cc @@ -2147,7 +2147,8 @@ void ParsedRtcEventLog::StoreParsedNewFormatEvent( stream.audio_network_adaptations_size() + stream.probe_clusters_size() + stream.probe_success_size() + stream.probe_failure_size() + stream.alr_states_size() + - stream.route_changes_size() + stream.ice_candidate_configs_size() + + stream.route_changes_size() + stream.remote_estimates_size() + + stream.ice_candidate_configs_size() + stream.ice_candidate_events_size() + stream.audio_recv_stream_configs_size() + stream.audio_send_stream_configs_size() + @@ -2192,6 +2193,8 @@ void ParsedRtcEventLog::StoreParsedNewFormatEvent( StoreAlrStateEvent(stream.alr_states(0)); } else if (stream.route_changes_size() == 1) { StoreRouteChangeEvent(stream.route_changes(0)); + } else if (stream.remote_estimates_size() == 1) { + StoreRemoteEstimateEvent(stream.remote_estimates(0)); } else if (stream.ice_candidate_configs_size() == 1) { StoreIceCandidatePairConfig(stream.ice_candidate_configs(0)); } else if (stream.ice_candidate_events_size() == 1) { @@ -2240,6 +2243,68 @@ void ParsedRtcEventLog::StoreRouteChangeEvent( // TODO(terelius): Should we delta encode this event type? } +void ParsedRtcEventLog::StoreRemoteEstimateEvent( + const rtclog2::RemoteEstimates& proto) { + RTC_CHECK(proto.has_timestamp_ms()); + // Base event + LoggedRemoteEstimateEvent base_event; + base_event.timestamp_ms = proto.timestamp_ms(); + + absl::optional base_link_capacity_lower_kbps; + if (proto.has_link_capacity_lower_kbps()) { + base_link_capacity_lower_kbps = proto.link_capacity_lower_kbps(); + base_event.link_capacity_lower = + DataRate::kbps(proto.link_capacity_lower_kbps()); + } + + absl::optional base_link_capacity_upper_kbps; + if (proto.has_link_capacity_upper_kbps()) { + base_link_capacity_upper_kbps = proto.link_capacity_upper_kbps(); + base_event.link_capacity_upper = + DataRate::kbps(proto.link_capacity_upper_kbps()); + } + + remote_estimate_events_.push_back(base_event); + + const size_t number_of_deltas = + proto.has_number_of_deltas() ? proto.number_of_deltas() : 0u; + if (number_of_deltas == 0) { + return; + } + + // timestamp_ms + auto timestamp_ms_values = + DecodeDeltas(proto.timestamp_ms_deltas(), + ToUnsigned(proto.timestamp_ms()), number_of_deltas); + RTC_CHECK_EQ(timestamp_ms_values.size(), number_of_deltas); + + // link_capacity_lower_kbps + auto link_capacity_lower_kbps_values = + DecodeDeltas(proto.link_capacity_lower_kbps_deltas(), + base_link_capacity_lower_kbps, number_of_deltas); + RTC_CHECK_EQ(link_capacity_lower_kbps_values.size(), number_of_deltas); + + // link_capacity_upper_kbps + auto link_capacity_upper_kbps_values = + DecodeDeltas(proto.link_capacity_upper_kbps_deltas(), + base_link_capacity_upper_kbps, number_of_deltas); + RTC_CHECK_EQ(link_capacity_upper_kbps_values.size(), number_of_deltas); + + // Delta decoding + for (size_t i = 0; i < number_of_deltas; ++i) { + LoggedRemoteEstimateEvent event; + RTC_CHECK(timestamp_ms_values[i].has_value()); + event.timestamp_ms = *timestamp_ms_values[i]; + if (link_capacity_lower_kbps_values[i]) + event.link_capacity_lower = + DataRate::kbps(*link_capacity_lower_kbps_values[i]); + if (link_capacity_upper_kbps_values[i]) + event.link_capacity_upper = + DataRate::kbps(*link_capacity_upper_kbps_values[i]); + remote_estimate_events_.push_back(event); + } +} + void ParsedRtcEventLog::StoreAudioPlayoutEvent( const rtclog2::AudioPlayoutEvents& proto) { RTC_CHECK(proto.has_timestamp_ms()); diff --git a/logging/rtc_event_log/rtc_event_log_parser.h b/logging/rtc_event_log/rtc_event_log_parser.h index 72eff98e1b..5d605b8965 100644 --- a/logging/rtc_event_log/rtc_event_log_parser.h +++ b/logging/rtc_event_log/rtc_event_log_parser.h @@ -426,6 +426,10 @@ class ParsedRtcEventLog { return route_change_events_; } + const std::vector& remote_estimate_events() const { + return remote_estimate_events_; + } + // RTP const std::vector& incoming_rtp_packets_by_ssrc() const { @@ -656,6 +660,7 @@ class ParsedRtcEventLog { void StoreOutgoingRtpPackets(const rtclog2::OutgoingRtpPackets& proto); void StoreParsedNewFormatEvent(const rtclog2::EventStream& event); void StoreRouteChangeEvent(const rtclog2::RouteChange& proto); + void StoreRemoteEstimateEvent(const rtclog2::RemoteEstimates& proto); void StoreStartEvent(const rtclog2::BeginLogEvent& proto); void StoreStopEvent(const rtclog2::EndLogEvent& proto); void StoreVideoRecvConfig(const rtclog2::VideoRecvStreamConfig& proto); @@ -771,6 +776,7 @@ class ParsedRtcEventLog { std::vector generic_acks_received_; std::vector route_change_events_; + std::vector remote_estimate_events_; uint8_t last_incoming_rtcp_packet_[IP_PACKET_SIZE]; uint8_t last_incoming_rtcp_packet_length_; diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc index eb5aa97090..98bdb42d55 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest.cc @@ -177,6 +177,7 @@ class RtcEventLogSession std::vector> probe_failure_list_; std::vector> probe_success_list_; std::vector> route_change_list_; + std::vector> remote_estimate_list_; std::vector> incoming_rtcp_list_; std::vector> outgoing_rtcp_list_; std::map>> diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc index 56b1f6570d..aead430063 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc @@ -355,6 +355,12 @@ std::unique_ptr EventGenerator::NewRouteChange() { prng_.Rand(0, 128)); } +std::unique_ptr EventGenerator::NewRemoteEstimate() { + return std::make_unique( + DataRate::kbps(prng_.Rand(0, 100000)), + DataRate::kbps(prng_.Rand(0, 100000))); +} + std::unique_ptr EventGenerator::NewRtcpPacketIncoming() { enum class SupportedRtcpTypes { @@ -932,6 +938,16 @@ void EventVerifier::VerifyLoggedRouteChangeEvent( EXPECT_EQ(original_event.overhead(), logged_event.overhead); } +void EventVerifier::VerifyLoggedRemoteEstimateEvent( + const RtcEventRemoteEstimate& original_event, + const LoggedRemoteEstimateEvent& logged_event) const { + EXPECT_EQ(original_event.timestamp_ms(), logged_event.log_time_ms()); + EXPECT_EQ(original_event.link_capacity_lower_, + logged_event.link_capacity_lower); + EXPECT_EQ(original_event.link_capacity_upper_, + logged_event.link_capacity_upper); +} + void EventVerifier::VerifyLoggedRtpPacketIncoming( const RtcEventRtpPacketIncoming& original_event, const LoggedRtpPacketIncoming& logged_event) const { diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.h b/logging/rtc_event_log/rtc_event_log_unittest_helper.h index 5efcdcab87..6f0a9c9afe 100644 --- a/logging/rtc_event_log/rtc_event_log_unittest_helper.h +++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.h @@ -33,6 +33,7 @@ #include "logging/rtc_event_log/events/rtc_event_probe_cluster_created.h" #include "logging/rtc_event_log/events/rtc_event_probe_result_failure.h" #include "logging/rtc_event_log/events/rtc_event_probe_result_success.h" +#include "logging/rtc_event_log/events/rtc_event_remote_estimate.h" #include "logging/rtc_event_log/events/rtc_event_route_change.h" #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h" #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h" @@ -79,6 +80,7 @@ class EventGenerator { std::unique_ptr NewProbeResultFailure(); std::unique_ptr NewProbeResultSuccess(); std::unique_ptr NewRouteChange(); + std::unique_ptr NewRemoteEstimate(); std::unique_ptr NewRtcpPacketIncoming(); std::unique_ptr NewRtcpPacketOutgoing(); @@ -199,6 +201,10 @@ class EventVerifier { const RtcEventRouteChange& original_event, const LoggedRouteChangeEvent& logged_event) const; + void VerifyLoggedRemoteEstimateEvent( + const RtcEventRemoteEstimate& original_event, + const LoggedRemoteEstimateEvent& logged_event) const; + void VerifyLoggedRtpPacketIncoming( const RtcEventRtpPacketIncoming& original_event, const LoggedRtpPacketIncoming& logged_event) const;