Style cleanup in UpdateTmmbr:

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 1192 matching lines @@
     RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
   rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
   RTC_DCHECK(packet != nullptr);
   rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
   rtcp_packet_information->transport_feedback_.reset(
       static_cast<rtcp::TransportFeedback*>(packet));
 
   rtcp_parser->Iterate();
 }
 
-int32_t RTCPReceiver::UpdateTMMBR() {
-  // Find bounding set
+void RTCPReceiver::UpdateTmmbr() {
+  // Find bounding set.
   std::vector<rtcp::TmmbItem> bounding =
-      TMMBRHelp::FindBoundingSet(TMMBRReceived());
-  // Set bounding set
-  // Inform remote clients about the new bandwidth
-  // inform the remote client
-  _rtpRtcp.SetTMMBN(&bounding);
+      TMMBRHelp::FindBoundingSet(TmmbrReceived());
 
-  // might trigger a TMMBN
-  if (bounding.empty()) {
-    // owner of max bitrate request has timed out
-    // empty bounding set has been sent
-    return 0;
-  }
-  // We have a new bandwidth estimate on this channel.
-  if (_cbRtcpBandwidthObserver) {
+  if (!bounding.empty() && _cbRtcpBandwidthObserver) {
+    // We have a new bandwidth estimate on this channel.
     uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding);
     if (bitrate_bps <= std::numeric_limits<uint32_t>::max())
       _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(bitrate_bps);
   }
-  return 0;
+
+  // Set bounding set: inform remote clients about the new bandwidth.
+  _rtpRtcp.SetTmmbn(std::move(bounding));
 }
 
 void RTCPReceiver::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   rtc::CritScope cs(&_criticalSectionFeedbacks);
   stats_callback_ = callback;
 }
 
 RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
   rtc::CritScope cs(&_criticalSectionFeedbacks);
   return stats_callback_;
 }
 
 // Holding no Critical section
 void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
     RTCPPacketInformation& rtcpPacketInformation) {
   // Process TMMBR and REMB first to avoid multiple callbacks
   // to OnNetworkChanged.
   if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTmmbr) {
     // Might trigger a OnReceivedBandwidthEstimateUpdate.
-    UpdateTMMBR();
+    UpdateTmmbr();
   }
   uint32_t local_ssrc;
   std::set<uint32_t> registered_ssrcs;
   {
     // We don't want to hold this critsect when triggering the callbacks below.
     rtc::CritScope lock(&_criticalSectionRTCPReceiver);
     local_ssrc = main_ssrc_;
     registered_ssrcs = registered_ssrcs_;
   }
   if (!receiver_only_ &&
@@ skipping 93 matching lines @@
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   RTCPCnameInformation* cnameInfo = GetCnameInformation(remoteSSRC);
   if (cnameInfo == NULL) {
     return -1;
   }
   cName[RTCP_CNAME_SIZE - 1] = 0;
   strncpy(cName, cnameInfo->name, RTCP_CNAME_SIZE - 1);
   return 0;
 }
 
-std::vector<rtcp::TmmbItem> RTCPReceiver::TMMBRReceived() const {
+std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   std::vector<rtcp::TmmbItem> candidates;
 
   int64_t now_ms = _clock->TimeInMilliseconds();
 
   for (const auto& kv : _receivedInfoMap) {
     RTCPReceiveInformation* receive_info = kv.second;
     RTC_DCHECK(receive_info);
     receive_info->GetTmmbrSet(now_ms, &candidates);
   }
   return candidates;
 }
 
 }  // namespace webrtc