Cleanup merge differences from upstream

Co-authored-by: Rashad Sookram <rashad@signal.org>

BUILD.gn

@@ -651,7 +651,6 @@ if (rtc_include_tests && !build_with_chromium) {
       "test:test_common",
       "test:test_main",
       "test:video_test_common",
-      "video:video_legacy_tests",
       "video:video_tests",
       "video/adaptation:video_adaptation_tests",
     ]

api/DEPS

@@ -248,13 +248,6 @@ specific_include_rules = {
     "+rtc_base/ref_counted_object.h",
   ],
 
-  "fake_metronome\.h": [
-    "+rtc_base/synchronization/mutex.h",
-    "+rtc_base/task_queue.h",
-    "+rtc_base/task_utils/repeating_task.h",
-    "+rtc_base/thread_annotations.h",
-  ],
-
   "mock.*\.h": [
     "+test/gmock.h",
   ],

api/metronome/BUILD.gn

@@ -16,21 +16,4 @@ rtc_source_set("metronome") {
     "../task_queue",
     "../units:time_delta",
   ]
-  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
-}
-
-if (rtc_include_tests) {
-  rtc_library("timestamp_extrapolator_unittests") {
-    testonly = true
-    sources = [ "timestamp_extrapolator_unittest.cc" ]
-    deps = [
-      ":timestamp_extrapolator",
-      "../../api/units:frequency",
-      "../../api/units:time_delta",
-      "../../api/units:timestamp",
-      "../../system_wrappers",
-      "../../test:test_support",
-    ]
-    absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
-  }
 }

audio/channel_receive.cc

@@ -713,9 +713,8 @@ void ChannelReceive::ReceivePacket(const uint8_t* packet,
     payload = decrypted_audio_payload.data();
     payload_data_length = decrypted_audio_payload.size();
   } else if (crypto_options_.sframe.require_frame_encryption) {
-    // RingRTC change to avoid spurious log.
+    RTC_DLOG(LS_ERROR)
-    // RTC_DLOG(LS_ERROR)
+        << "FrameDecryptor required but not set, dropping packet";
-    //     << "FrameDecryptor required but not set, dropping packet";
     payload_data_length = 0;
   }
 

call/bitrate_allocator.cc

@@ -380,7 +380,6 @@ void BitrateAllocator::OnNetworkEstimateChanged(TargetTransferRate msg) {
   RTC_DCHECK_RUN_ON(&sequenced_checker_);
   last_target_bps_ = msg.target_rate.bps();
   last_stable_target_bps_ = msg.stable_target_rate.bps();
-
   last_non_zero_bitrate_bps_ =
       last_target_bps_ > 0 ? last_target_bps_ : last_non_zero_bitrate_bps_;
 

call/rtp_demuxer.cc

@@ -113,12 +113,11 @@ std::string RtpDemuxer::DescribePacket(const RtpPacketReceived& packet) {
 RtpDemuxer::RtpDemuxer(bool use_mid /* = true*/) : use_mid_(use_mid) {}
 
 RtpDemuxer::~RtpDemuxer() {
-  // RingRTC change to avoid spurious crashes
+  RTC_DCHECK(sink_by_mid_.empty());
-  // RTC_DCHECK(sink_by_mid_.empty());
+  RTC_DCHECK(sink_by_ssrc_.empty());
-  // RTC_DCHECK(sink_by_ssrc_.empty());
+  RTC_DCHECK(sinks_by_pt_.empty());
-  // RTC_DCHECK(sinks_by_pt_.empty());
+  RTC_DCHECK(sink_by_mid_and_rsid_.empty());
-  // RTC_DCHECK(sink_by_mid_and_rsid_.empty());
+  RTC_DCHECK(sink_by_rsid_.empty());
-  // RTC_DCHECK(sink_by_rsid_.empty());
 }
 
 bool RtpDemuxer::AddSink(const RtpDemuxerCriteria& criteria,

media/engine/webrtc_video_engine_unittest.cc

@@ -5556,7 +5556,7 @@ TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportWithoutSubStreams) {
   EXPECT_EQ(sender.total_encoded_bytes_target,
             stats.total_encoded_bytes_target);
   // Comes from substream only.
-  EXPECT_EQ(sender.total_packet_send_delay_ms, 0u);
+  EXPECT_EQ(sender.total_packet_send_delay, webrtc::TimeDelta::Zero());
   EXPECT_EQ(sender.qp_sum, absl::nullopt);
 
   EXPECT_EQ(sender.has_entered_low_resolution,
@@ -5583,7 +5583,8 @@ TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportForSubStreams) {
   substream.retransmit_bitrate_bps = 6;
   substream.avg_delay_ms = 7;
   substream.max_delay_ms = 8;
-  substream.total_packet_send_delay_ms = 9;
+  substream.rtp_stats.transmitted.total_packet_delay =
+      webrtc::TimeDelta::Millis(9);
   substream.rtp_stats.transmitted.header_bytes = 10;
   substream.rtp_stats.transmitted.padding_bytes = 11;
   substream.rtp_stats.retransmitted.payload_bytes = 12;
@@ -5629,6 +5630,8 @@ TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportForSubStreams) {
             static_cast<int>(2 * substream.rtp_stats.transmitted.packets));
   EXPECT_EQ(sender.retransmitted_packets_sent,
             2u * substream.rtp_stats.retransmitted.packets);
+  EXPECT_EQ(sender.total_packet_send_delay,
+            2 * substream.rtp_stats.transmitted.total_packet_delay);
   EXPECT_EQ(sender.packets_lost,
             2 * substream.report_block_data->report_block().packets_lost);
   EXPECT_EQ(sender.fraction_lost,
@@ -5678,8 +5681,6 @@ TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportForSubStreams) {
   EXPECT_EQ(sender.total_encode_time_ms, 2u * substream.total_encode_time_ms);
   EXPECT_EQ(sender.total_encoded_bytes_target,
             2u * substream.total_encoded_bytes_target);
-  EXPECT_EQ(sender.total_packet_send_delay_ms,
-            2u * substream.total_packet_send_delay_ms);
   EXPECT_EQ(sender.has_entered_low_resolution,
             stats.has_entered_low_resolution);
   EXPECT_EQ(sender.qp_sum, 2u * *substream.qp_sum);
@@ -5705,7 +5706,8 @@ TEST_F(WebRtcVideoChannelTest, GetPerLayerStatsReportForSubStreams) {
   substream.retransmit_bitrate_bps = 6;
   substream.avg_delay_ms = 7;
   substream.max_delay_ms = 8;
-  substream.total_packet_send_delay_ms = 9;
+  substream.rtp_stats.transmitted.total_packet_delay =
+      webrtc::TimeDelta::Millis(9);
   substream.rtp_stats.transmitted.header_bytes = 10;
   substream.rtp_stats.transmitted.padding_bytes = 11;
   substream.rtp_stats.retransmitted.payload_bytes = 12;
@@ -5749,6 +5751,8 @@ TEST_F(WebRtcVideoChannelTest, GetPerLayerStatsReportForSubStreams) {
             substream.rtp_stats.retransmitted.payload_bytes);
   EXPECT_EQ(sender.packets_sent,
             static_cast<int>(substream.rtp_stats.transmitted.packets));
+  EXPECT_EQ(sender.total_packet_send_delay,
+            substream.rtp_stats.transmitted.total_packet_delay);
   EXPECT_EQ(sender.retransmitted_packets_sent,
             substream.rtp_stats.retransmitted.packets);
   EXPECT_EQ(sender.packets_lost,
@@ -5799,8 +5803,6 @@ TEST_F(WebRtcVideoChannelTest, GetPerLayerStatsReportForSubStreams) {
   EXPECT_EQ(sender.total_encode_time_ms, substream.total_encode_time_ms);
   EXPECT_EQ(sender.total_encoded_bytes_target,
             substream.total_encoded_bytes_target);
-  EXPECT_EQ(sender.total_packet_send_delay_ms,
-            substream.total_packet_send_delay_ms);
   EXPECT_EQ(sender.has_entered_low_resolution,
             stats.has_entered_low_resolution);
   EXPECT_EQ(sender.qp_sum, *substream.qp_sum);

media/engine/webrtc_voice_engine.cc

@@ -585,12 +585,10 @@ WebRtcVoiceEngine::GetRtpHeaderExtensions() const {
   std::vector<webrtc::RtpHeaderExtensionCapability> result;
   int id = 1;
   // RingRTC change to disable unused header extensions
-  for (const auto& uri :
+  for (const auto& uri : {// webrtc::RtpExtension::kAudioLevelUri,
-       {// webrtc::RtpExtension::kAudioLevelUri,
+                          webrtc::RtpExtension::kAbsSendTimeUri,
-        webrtc::RtpExtension::kAbsSendTimeUri,
+                          webrtc::RtpExtension::kTransportSequenceNumberUri,
-        webrtc::RtpExtension::kTransportSequenceNumberUri,
+                          webrtc::RtpExtension::kMidUri}) {
-        webrtc::RtpExtension::kMidUri,
-        }) {
     result.emplace_back(uri, id++, webrtc::RtpTransceiverDirection::kSendRecv);
   }
   return result;

media/engine/webrtc_voice_engine_unittest.cc

@@ -1019,10 +1019,8 @@ TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) {
   EXPECT_TRUE(channel_->SetRecvParameters(parameters));
 }
 
-// Test that we enable Opus/Red with the field trial.
+// Test that we do allow setting Opus/Red by default.
-TEST_P(WebRtcVoiceEngineTestFake, RecvRed) {
+TEST_P(WebRtcVoiceEngineTestFake, RecvRedDefault) {
-  webrtc::test::ScopedFieldTrials override_field_trials(
-      "WebRTC-Audio-Red-For-Opus/Enabled/");
   EXPECT_TRUE(SetupRecvStream());
   cricket::AudioRecvParameters parameters;
   parameters.codecs.push_back(kOpusCodec);

modules/audio_device/audio_device_impl.cc

@@ -664,7 +664,6 @@ int32_t AudioDeviceModuleImpl::MinMicrophoneVolume(uint32_t* minVolume) const {
   return 0;
 }
 
-// RingRTC changes to add some useful logging
 int16_t AudioDeviceModuleImpl::PlayoutDevices() {
   RTC_LOG(LS_INFO) << __FUNCTION__;
   CHECKinitialized_();

modules/audio_processing/aec3/matched_filter.h

@@ -89,9 +89,6 @@ void MatchedFilterCore(size_t x_start_index,
 // Find largest peak of squared values in array.
 size_t MaxSquarePeakIndex(rtc::ArrayView<const float> h);
 
-// Find largest peak of squared values in array.
-size_t MaxSquarePeakIndex(rtc::ArrayView<const float> h);
-
 }  // namespace aec3
 
 // Produces recursively updated cross-correlation estimates for several signal

modules/congestion_controller/goog_cc/robust_throughput_estimator.h

@@ -15,7 +15,6 @@
 #include <vector>
 
 #include "absl/types/optional.h"
-#include "api/field_trials_view.h"
 #include "api/transport/network_types.h"
 #include "api/units/data_rate.h"
 #include "api/units/timestamp.h"

modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc

@@ -10,7 +10,6 @@
 
 #include "modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.h"
 
-#include "api/network_state_predictor.h"
 #include "api/rtc_event_log/rtc_event.h"
 #include "logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h"
 #include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
@@ -55,8 +54,7 @@ void TestProbing(bool use_delay_based) {
   // Initial REMB applies immediately.
   if (use_delay_based) {
     bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms),
-                                 DataRate::BitsPerSec(kRembBps),
+                                 DataRate::BitsPerSec(kRembBps));
-                                 BandwidthUsage::kBwNormal);
   } else {
     bwe.UpdateReceiverEstimate(Timestamp::Millis(now_ms),
                                DataRate::BitsPerSec(kRembBps));
@@ -68,8 +66,7 @@ void TestProbing(bool use_delay_based) {
   now_ms += 2001;
   if (use_delay_based) {
     bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms),
-                                 DataRate::BitsPerSec(kSecondRembBps),
+                                 DataRate::BitsPerSec(kSecondRembBps));
-                                 BandwidthUsage::kBwNormal);
   } else {
     bwe.UpdateReceiverEstimate(Timestamp::Millis(now_ms),
                                DataRate::BitsPerSec(kSecondRembBps));
@@ -160,8 +157,7 @@ TEST(SendSideBweTest, SettingSendBitrateOverridesDelayBasedEstimate) {
                      Timestamp::Millis(now_ms));
 
   bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms),
-                               DataRate::BitsPerSec(kDelayBasedBitrateBps),
+                               DataRate::BitsPerSec(kDelayBasedBitrateBps));
-                               BandwidthUsage::kBwNormal);
   bwe.UpdateEstimate(Timestamp::Millis(now_ms));
   EXPECT_GE(bwe.target_rate().bps(), kInitialBitrateBps);
   EXPECT_LE(bwe.target_rate().bps(), kDelayBasedBitrateBps);

modules/desktop_capture/desktop_frame.cc

@@ -45,13 +45,9 @@ void DesktopFrame::CopyPixelsFrom(const uint8_t* src_buffer,
   RTC_CHECK(DesktopRect::MakeSize(size()).ContainsRect(dest_rect));
 
   uint8_t* dest = GetFrameDataAtPos(dest_rect.top_left());
-  // TODO(crbug.com/1330019): Temporary workaround for a known libyuv crash when
+  libyuv::CopyPlane(src_buffer, src_stride, dest, stride(),
-  // the height or width is 0. Remove this once this change has been merged.
+                    DesktopFrame::kBytesPerPixel * dest_rect.width(),
-  if (dest_rect.width() && dest_rect.height()) {
+                    dest_rect.height());
-    libyuv::CopyPlane(src_buffer, src_stride, dest, stride(),
-                      DesktopFrame::kBytesPerPixel * dest_rect.width(),
-                      dest_rect.height());
-  }
 }
 
 void DesktopFrame::CopyPixelsFrom(const DesktopFrame& src_frame,

modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.cc

@@ -90,7 +90,6 @@ DEPRECATED_RtpSenderEgress::DEPRECATED_RtpSenderEgress(
       timestamp_offset_(0),
       max_delay_it_(send_delays_.end()),
       sum_delays_ms_(0),
-      total_packet_send_delay_ms_(0),
       send_rates_(kNumMediaTypes,
                   {kBitrateStatisticsWindowMs, RateStatistics::kBpsScale}),
       rtp_sequence_number_map_(need_rtp_packet_infos_
@@ -341,7 +340,6 @@ void DEPRECATED_RtpSenderEgress::UpdateDelayStatistics(int64_t capture_time_ms,
 
   int avg_delay_ms = 0;
   int max_delay_ms = 0;
-  uint64_t total_packet_send_delay_ms = 0;
   {
     MutexLock lock(&lock_);
     // Compute the max and average of the recent capture-to-send delays.
@@ -392,8 +390,6 @@ void DEPRECATED_RtpSenderEgress::UpdateDelayStatistics(int64_t capture_time_ms,
       max_delay_it_ = it;
     }
     sum_delays_ms_ += new_send_delay;
-    total_packet_send_delay_ms_ += new_send_delay;
-    total_packet_send_delay_ms = total_packet_send_delay_ms_;
 
     size_t num_delays = send_delays_.size();
     RTC_DCHECK(max_delay_it_ != send_delays_.end());
@@ -405,8 +401,8 @@ void DEPRECATED_RtpSenderEgress::UpdateDelayStatistics(int64_t capture_time_ms,
     avg_delay_ms =
         rtc::dchecked_cast<int>((sum_delays_ms_ + num_delays / 2) / num_delays);
   }
-  send_side_delay_observer_->SendSideDelayUpdated(
+  send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
-      avg_delay_ms, max_delay_ms, total_packet_send_delay_ms, ssrc);
+                                                  ssrc);
 }
 
 void DEPRECATED_RtpSenderEgress::RecomputeMaxSendDelay() {

modules/rtp_rtcp/source/rtp_packet_history.h

@@ -18,7 +18,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/attributes.h"
 #include "api/function_view.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"

modules/video_coding/svc/create_scalability_structure.h

@@ -30,11 +30,6 @@ std::unique_ptr<ScalableVideoController> CreateScalabilityStructure(
 absl::optional<ScalableVideoController::StreamLayersConfig>
 ScalabilityStructureConfig(ScalabilityMode name);
 
-// Returns descrption of the scalability structure identified by 'name',
-// Return nullopt for unknown name.
-absl::optional<ScalableVideoController::StreamLayersConfig>
-ScalabilityStructureConfig(absl::string_view name);
-
 }  // namespace webrtc
 
 #endif  // MODULES_VIDEO_CODING_SVC_CREATE_SCALABILITY_STRUCTURE_H_

net/dcsctp/socket/dcsctp_socket.h

@@ -292,8 +292,6 @@ class DcSctpSocket : public DcSctpSocketInterface {
   State state_ = State::kClosed;
   // If the connection is established, contains a transmission control block.
   std::unique_ptr<TransmissionControlBlock> tcb_;
-
-  SctpImplementation peer_implementation_ = SctpImplementation::kUnknown;
 };
 }  // namespace dcsctp
 

net/dcsctp/socket/state_cookie_test.cc

@@ -55,18 +55,5 @@ TEST(StateCookieTest, ValidateMagicValue) {
   EXPECT_EQ(magic, "dcSCTP00");
 }
 
-TEST(StateCookieTest, ValidateMagicValue) {
-  Capabilities capabilities = {/*partial_reliability=*/true,
-                               /*message_interleaving=*/false,
-                               /*reconfig=*/true};
-  StateCookie cookie(VerificationTag(123), TSN(456),
-                     /*a_rwnd=*/789, TieTag(101112), capabilities);
-  std::vector<uint8_t> serialized = cookie.Serialize();
-  ASSERT_THAT(serialized, SizeIs(StateCookie::kCookieSize));
-
-  absl::string_view magic(reinterpret_cast<const char*>(serialized.data()), 8);
-  EXPECT_EQ(magic, "dcSCTP00");
-}
-
 }  // namespace
 }  // namespace dcsctp

p2p/base/fake_port_allocator.h

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "api/make_ref_counted.h"
 #include "p2p/base/basic_packet_socket_factory.h"
 #include "p2p/base/ice_credentials_iterator.h"
 #include "p2p/base/ice_gatherer.h"
@@ -218,7 +219,6 @@ class FakePortAllocatorSession : public PortAllocatorSession {
 
 class FakePortAllocator : public cricket::PortAllocator {
  public:
-  // TODO(bugs.webrtc.org/13145): Require non-null `factory`.
   FakePortAllocator(rtc::Thread* network_thread,
                     rtc::PacketSocketFactory* factory)
       : FakePortAllocator(network_thread, factory, nullptr) {}
@@ -236,7 +236,7 @@ class FakePortAllocator : public cricket::PortAllocator {
       absl::string_view ice_pwd) override {
     return new FakePortAllocatorSession(
         this, network_thread_, factory_.get(), std::string(content_name),
-        component, std::string(ice_ufrag), std::string(ice_pwd, field_trials_);
+        component, std::string(ice_ufrag), std::string(ice_pwd), field_trials_);
   }
 
   rtc::scoped_refptr<webrtc::IceGathererInterface> CreateIceGatherer(
@@ -248,7 +248,7 @@ class FakePortAllocator : public cricket::PortAllocator {
     auto session = new_allocator->CreateSession(
         content_name, 1, parameters.ufrag, parameters.pwd);
     return rtc::make_ref_counted<cricket::BasicIceGatherer>(
-        network_thread_, std::move(new_allocator), std::move(session)), field_trials_);
+        network_thread_, std::move(new_allocator), std::move(session));
   }
 
   bool initialized() const { return initialized_; }

p2p/base/p2p_transport_channel_unittest.cc

@@ -1282,16 +1282,6 @@ const P2PTransportChannelMatrixTest::Result*
          LTRT},
 };
 
-class P2PTransportChannelTestWithFieldTrials
-    : public P2PTransportChannelTest,
-      public ::testing::WithParamInterface<std::string> {
- public:
-  void Test(const Result& expected) override {
-    webrtc::test::ScopedFieldTrials field_trials(GetParam());
-    P2PTransportChannelTest::Test(expected);
-  }
-};
-
 // The actual tests that exercise all the various configurations.
 // Test names are of the form P2PTransportChannelTest_TestOPENToNAT_FULL_CONE
 #define P2P_TEST_DECLARATION(x, y, z)                            \

p2p/base/port.cc

@@ -101,8 +101,10 @@ std::string Port::ComputeFoundation(absl::string_view type,
                                     absl::string_view protocol,
                                     absl::string_view relay_protocol,
                                     const rtc::SocketAddress& base_address) {
+  // TODO(bugs.webrtc.org/14605): ensure IceTiebreaker() is set.
   rtc::StringBuilder sb;
-  sb << type << base_address.ipaddr().ToString() << protocol << relay_protocol;
+  sb << type << base_address.ipaddr().ToString() << protocol << relay_protocol
+     << rtc::ToString(IceTiebreaker());
   return rtc::ToString(rtc::ComputeCrc32(sb.Release()));
 }
 

p2p/base/port_allocator.h

@@ -100,6 +100,9 @@ enum class IceRegatheringReason {
   MAX_VALUE
 };
 
+// RingRTC change to avoid incorrect use of flag (enable for test builds)
+//const uint32_t kDefaultPortAllocatorFlags = 0;
+
 const uint32_t kDefaultStepDelay = 1000;  // 1 sec step delay.
 // As per RFC 5245 Appendix B.1, STUN transactions need to be paced at certain
 // internal. Less than 20ms is not acceptable. We choose 50ms as our default.

pc/media_session.cc

@@ -1657,7 +1657,7 @@ std::unique_ptr<SessionDescription> MediaSessionDescriptionFactory::CreateOffer(
                   session_options.media_description_options.size());
   }
 
-  // RingRTC change to configure OPUS
+  // RingRTC change to add ICE forking
   IceCredentialsIterator ice_credentials(session_options.ice_credentials);
 
   std::vector<const ContentInfo*> current_active_contents;
@@ -1795,7 +1795,7 @@ MediaSessionDescriptionFactory::CreateAnswer(
   RTC_DCHECK_EQ(offer->contents().size(),
                 session_options.media_description_options.size());
 
-  // RingRTC change to configure OPUS
+  // RingRTC change to add ICE forking
   IceCredentialsIterator ice_credentials(session_options.ice_credentials);
 
   std::vector<const ContentInfo*> current_active_contents;

pc/peer_connection_integrationtest.cc

@@ -21,7 +21,6 @@
 #include <memory>
 #include <string>
 #include <tuple>
-#include <type_traits>
 #include <utility>
 #include <vector>
 

pc/rtc_stats_collector_unittest.cc

@@ -38,6 +38,7 @@
 #include "api/video/video_frame.h"
 #include "api/video/video_sink_interface.h"
 #include "api/video/video_source_interface.h"
+#include "api/video/video_timing.h"
 #include "common_video/include/quality_limitation_reason.h"
 #include "media/base/media_channel.h"
 #include "modules/audio_processing/include/audio_processing_statistics.h"
@@ -2703,6 +2704,42 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
   EXPECT_TRUE(report->Get(*expected_video.codec_id));
 }
 
+TEST_F(RTCStatsCollectorTest, CollectGoogTimingFrameInfo) {
+  cricket::VideoMediaInfo video_media_info;
+
+  video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
+  video_media_info.receivers[0].local_stats.push_back(
+      cricket::SsrcReceiverInfo());
+  video_media_info.receivers[0].local_stats[0].ssrc = 1;
+  TimingFrameInfo timing_frame_info;
+  timing_frame_info.rtp_timestamp = 1;
+  timing_frame_info.capture_time_ms = 2;
+  timing_frame_info.encode_start_ms = 3;
+  timing_frame_info.encode_finish_ms = 4;
+  timing_frame_info.packetization_finish_ms = 5;
+  timing_frame_info.pacer_exit_ms = 6;
+  timing_frame_info.network_timestamp_ms = 7;
+  timing_frame_info.network2_timestamp_ms = 8;
+  timing_frame_info.receive_start_ms = 9;
+  timing_frame_info.receive_finish_ms = 10;
+  timing_frame_info.decode_start_ms = 11;
+  timing_frame_info.decode_finish_ms = 12;
+  timing_frame_info.render_time_ms = 13;
+  timing_frame_info.flags = 14;
+  video_media_info.receivers[0].timing_frame_info = timing_frame_info;
+
+  pc_->AddVideoChannel("Mid0", "Transport0", video_media_info);
+  stats_->SetupRemoteTrackAndReceiver(
+      cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 1);
+
+  rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
+  auto inbound_rtps = report->GetStatsOfType<RTCInboundRTPStreamStats>();
+  ASSERT_EQ(inbound_rtps.size(), 1u);
+  ASSERT_TRUE(inbound_rtps[0]->goog_timing_frame_info.is_defined());
+  EXPECT_EQ(*inbound_rtps[0]->goog_timing_frame_info,
+            "1,2,3,4,5,6,7,8,9,10,11,12,13,1,0");
+}
+
 TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
   cricket::VoiceMediaInfo voice_media_info;
 
@@ -2787,7 +2824,8 @@ TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
   video_media_info.senders[0].key_frames_encoded = 3;
   video_media_info.senders[0].total_encode_time_ms = 9000;
   video_media_info.senders[0].total_encoded_bytes_target = 1234;
-  video_media_info.senders[0].total_packet_send_delay_ms = 10000;
+  video_media_info.senders[0].total_packet_send_delay =
+      webrtc::TimeDelta::Seconds(10);
   video_media_info.senders[0].quality_limitation_reason =
       QualityLimitationReason::kBandwidth;
   video_media_info.senders[0].quality_limitation_durations_ms

pc/rtc_stats_integrationtest.cc

@@ -936,6 +936,7 @@ class RTCStatsReportVerifier {
           inbound_stream.total_interruption_duration);
       verifier.TestMemberIsNonNegative<double>(
           inbound_stream.min_playout_delay);
+      verifier.TestMemberIsDefined(inbound_stream.goog_timing_frame_info);
     } else {
       verifier.TestMemberIsUndefined(inbound_stream.frames_decoded);
       verifier.TestMemberIsUndefined(inbound_stream.key_frames_decoded);
@@ -964,6 +965,7 @@ class RTCStatsReportVerifier {
       verifier.TestMemberIsNonNegative<double>(
           inbound_stream.total_interruption_duration);
       verifier.TestMemberIsUndefined(inbound_stream.min_playout_delay);
+      verifier.TestMemberIsUndefined(inbound_stream.goog_timing_frame_info);
     }
     return verifier.ExpectAllMembersSuccessfullyTested();
   }

rtc_base/event_tracer.cc

@@ -204,6 +204,7 @@ class EventLogger final {
     RTC_CHECK(g_event_logging_active.compare_exchange_strong(zero, 1));
 
     // Finally start, everything should be set up now.
+    // RingRTC change to keep the tracing thread priority low
     logging_thread_ =
         PlatformThread::SpawnJoinable([this] { Log(); }, "EventTracingThread", 
                         ThreadAttributes().SetPriority(ThreadPriority::kLow));

rtc_base/network.cc

@@ -1001,14 +1001,6 @@ void BasicNetworkManager::StopNetworkMonitor() {
 IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const {
   RTC_DCHECK(family == AF_INET || family == AF_INET6);
 
-  // TODO(bugs.webrtc.org/13145): Delete support for null `socket_factory_`,
-  // require socket factory to be provided to constructor.
-  SocketFactory* socket_factory = socket_factory_;
-  if (!socket_factory) {
-    socket_factory = thread_->socketserver();
-  }
-  RTC_DCHECK(socket_factory);
-
   std::unique_ptr<Socket> socket(
       socket_factory_->CreateSocket(family, SOCK_DGRAM));
   if (!socket) {

rtc_base/physical_socket_server.cc

@@ -750,8 +750,6 @@ bool SocketDispatcher::IsDescriptorClosed() {
         return true;
       // The normal blocking error; don't log anything.
       case EWOULDBLOCK:
-      // Interrupted system call.
-      case EINTR:
         return false;
       default:
         // Assume that all other errors are just blocking errors, meaning the

sdk/android/OWNERS

@@ -7,6 +7,3 @@ ssilkin@webrtc.org
 magjed@webrtc.org
 xalep@webrtc.org
 per-file ...Audio*.java=henrika@webrtc.org
-
-per-file PRESUBMIT.py=jansson@webrtc.org
-per-file PRESUBMIT.py=jleconte@webrtc.org

sdk/android/tests/src/org/webrtc/FakeMediaCodecWrapper.java

@@ -306,11 +306,6 @@ public class FakeMediaCodecWrapper implements MediaCodecWrapper {
     return inputFormat;
   }
 
-  @Override
-  public MediaFormat getInputFormat() {
-    return inputFormat;
-  }
-
   @Override
   public MediaFormat getOutputFormat() {
     return outputFormat;

test/fuzzers/vp9_encoder_references_fuzzer.cc

@@ -34,8 +34,6 @@ using test::FuzzDataHelper;
 
 constexpr int kBitrateEnabledBps = 100'000;
 
-constexpr int kBitrateEnabledBps = 100'000;
-
 class FrameValidator : public EncodedImageCallback {
  public:
   ~FrameValidator() override = default;

video/send_statistics_proxy_unittest.cc

@@ -322,26 +322,18 @@ TEST_F(SendStatisticsProxyTest, SendSideDelay) {
     // stream.
     int avg_delay_ms = ssrc;
     int max_delay_ms = ssrc + 1;
-    uint64_t total_packet_send_delay_ms = ssrc + 2;
+    observer->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc);
-    observer->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
-                                   total_packet_send_delay_ms, ssrc);
     expected_.substreams[ssrc].avg_delay_ms = avg_delay_ms;
     expected_.substreams[ssrc].max_delay_ms = max_delay_ms;
-    expected_.substreams[ssrc].total_packet_send_delay_ms =
-        total_packet_send_delay_ms;
   }
   for (const auto& ssrc : config_.rtp.rtx.ssrcs) {
     // Use ssrc as avg_delay_ms and max_delay_ms to get a unique value for each
     // stream.
     int avg_delay_ms = ssrc;
     int max_delay_ms = ssrc + 1;
-    uint64_t total_packet_send_delay_ms = ssrc + 2;
+    observer->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc);
-    observer->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
-                                   total_packet_send_delay_ms, ssrc);
     expected_.substreams[ssrc].avg_delay_ms = avg_delay_ms;
     expected_.substreams[ssrc].max_delay_ms = max_delay_ms;
-    expected_.substreams[ssrc].total_packet_send_delay_ms =
-        total_packet_send_delay_ms;
   }
   VideoSendStream::Stats stats = statistics_proxy_->GetStats();
   ExpectEqual(expected_, stats);