Fix perf issue when timinig out receivers infos in RTCP.

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 127 matching lines @@
 
   PacketInformation packet_information;
   if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information))
     return false;
   TriggerCallbacksFromRtcpPacket(packet_information);
   return true;
 }
 
 int64_t RTCPReceiver::LastReceivedReceiverReport() const {
   rtc::CritScope lock(&rtcp_receiver_lock_);
-  int64_t last_received_rr = -1;
-  for (const auto& kv : received_infos_)
-    if (kv.second.last_time_received_ms > last_received_rr)
-      last_received_rr = kv.second.last_time_received_ms;
-  return last_received_rr;
+  return last_received_rr_ms_;
 }
 
 void RTCPReceiver::SetRemoteSSRC(uint32_t ssrc) {
   rtc::CritScope lock(&rtcp_receiver_lock_);
   // New SSRC reset old reports.
   memset(&remote_sender_info_, 0, sizeof(remote_sender_info_));
   last_received_sr_ntp_.Reset();
   remote_ssrc_ = ssrc;
 }
 
@@ skipping 275 matching lines @@
 }
 
 void RTCPReceiver::HandleReceiverReport(const CommonHeader& rtcp_block,
                                         PacketInformation* packet_information) {
   rtcp::ReceiverReport receiver_report;
   if (!receiver_report.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
+  last_received_rr_ms_ = clock_->TimeInMilliseconds();
+
   const uint32_t remote_ssrc = receiver_report.sender_ssrc();
 
   packet_information->remote_ssrc = remote_ssrc;
 
   CreateReceiveInformation(remote_ssrc);
 
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
                        "remote_ssrc", remote_ssrc, "ssrc", main_ssrc_);
 
   packet_information->packet_type_flags |= kRtcpRr;
@@ skipping 13 matching lines @@
 
   // |report_block.source_ssrc()| is the SSRC identifier of the source to
   // which the information in this reception report block pertains.
 
   // Filter out all report blocks that are not for us.
   if (registered_ssrcs_.count(report_block.source_ssrc()) == 0)
     return;
 
   ReportBlockWithRtt* report_block_info =
       &received_report_blocks_[report_block.source_ssrc()][remote_ssrc];
-
-  last_received_rr_ms_ = clock_->TimeInMilliseconds();
   report_block_info->report_block.remoteSSRC = remote_ssrc;
   report_block_info->report_block.sourceSSRC = report_block.source_ssrc();
   report_block_info->report_block.fractionLost = report_block.fraction_lost();
   report_block_info->report_block.cumulativeLost =
       report_block.cumulative_lost();
   if (report_block.extended_high_seq_num() >
       report_block_info->report_block.extendedHighSeqNum) {
     // We have successfully delivered new RTP packets to the remote side after
     // the last RR was sent from the remote side.
-    last_increased_sequence_number_ms_ = last_received_rr_ms_;
+    last_increased_sequence_number_ms_ = clock_->TimeInMilliseconds();
   }
   report_block_info->report_block.extendedHighSeqNum =
       report_block.extended_high_seq_num();
   report_block_info->report_block.jitter = report_block.jitter();
   report_block_info->report_block.delaySinceLastSR =
       report_block.delay_since_last_sr();
   report_block_info->report_block.lastSR = report_block.last_sr();
 
   int64_t rtt_ms = 0;
   uint32_t send_time_ntp = report_block.last_sr();
@@ skipping 69 matching lines @@
     // Reset the timer to only trigger one log.
     last_increased_sequence_number_ms_ = 0;
     return true;
   }
   return false;
 }
 
 bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
   rtc::CritScope lock(&rtcp_receiver_lock_);
 
-  bool update_bounding_set = false;
   int64_t now_ms = clock_->TimeInMilliseconds();
   // Use audio define since we don't know what interval the remote peer use.
-  int64_t timeouted_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
+  int64_t timeout_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
 
+  if (oldest_received_info_ms_ >= timeout_ms)
+    return false;
+
+  bool update_bounding_set = false;
+  oldest_received_info_ms_ = -1;
   for (auto receive_info_it = received_infos_.begin();
        receive_info_it != received_infos_.end();) {
     ReceiveInformation* receive_info = &receive_info_it->second;
     if (receive_info->last_time_received_ms > 0) {
-      if (receive_info->last_time_received_ms < timeouted_ms) {
+      if (receive_info->last_time_received_ms < timeout_ms) {
         // No rtcp packet for the last 5 regular intervals, reset limitations.
         receive_info->tmmbr.clear();
         // Prevent that we call this over and over again.
         receive_info->last_time_received_ms = 0;
         // Send new TMMBN to all channels using the default codec.
         update_bounding_set = true;
+      } else if (oldest_received_info_ms_ == -1 ||
+                 receive_info->last_time_received_ms <
+                     oldest_received_info_ms_) {
+        oldest_received_info_ms_ = receive_info->last_time_received_ms;
       }
       ++receive_info_it;
     } else if (receive_info->ready_for_delete) {
       // When we dont have a last_time_received_ms and the object is marked
       // ready_for_delete it's removed from the map.
       receive_info_it = received_infos_.erase(receive_info_it);
     } else {
       ++receive_info_it;
     }
   }
@@ skipping 455 matching lines @@
   cName[length] = 0;
   return 0;
 }
 
 std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() {
   rtc::CritScope lock(&rtcp_receiver_lock_);
   std::vector<rtcp::TmmbItem> candidates;
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   // Use audio define since we don't know what interval the remote peer use.
-  int64_t timeouted_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
+  int64_t timeout_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
 
   for (auto& kv : received_infos_) {
     for (auto it = kv.second.tmmbr.begin(); it != kv.second.tmmbr.end();) {
-      if (it->second.last_updated_ms < timeouted_ms) {
+      if (it->second.last_updated_ms < timeout_ms) {
         // Erase timeout entries.
         it = kv.second.tmmbr.erase(it);
       } else {
         candidates.push_back(it->second.tmmbr_item);
         ++it;
       }
     }
   }
   return candidates;
 }
 
 }  // namespace webrtc