RTCPReceiver store cname as std::string.

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 31 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
 #include "webrtc/system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
 namespace {
 
 using rtcp::CommonHeader;
 using rtcp::ReportBlock;
 using RTCPHelp::RTCPReceiveInformation;
 using RTCPHelp::RTCPReportBlockInformation;
-using RTCPUtility::RTCPCnameInformation;
-using RTCPUtility::RTCPPacketReportBlockItem;
-using RTCPUtility::RTCPPacketTypes;
 
 // The number of RTCP time intervals needed to trigger a timeout.
 const int kRrTimeoutIntervals = 3;
 
 const int64_t kMaxWarningLogIntervalMs = 10000;
 
 }  // namespace
 
 struct RTCPReceiver::PacketInformation {
   uint32_t packet_type_flags = 0;  // RTCPPacketTypeFlags bit field.
@@ skipping 50 matching lines @@
       delete it_info->second;
       info_map->erase(it_info);
     }
   }
   while (!_receivedInfoMap.empty()) {
     std::map<uint32_t, RTCPReceiveInformation*>::iterator first =
         _receivedInfoMap.begin();
     delete first->second;
     _receivedInfoMap.erase(first);
   }
-  while (!_receivedCnameMap.empty()) {
-    std::map<uint32_t, RTCPCnameInformation*>::iterator first =
-        _receivedCnameMap.begin();
-    delete first->second;
-    _receivedCnameMap.erase(first);
-  }
 }
 
 bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
   if (packet_size == 0) {
     LOG(LS_WARNING) << "Incoming empty RTCP packet";
     return false;
   }
 
   PacketInformation packet_information;
   if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information))
@@ skipping 463 matching lines @@
     return NULL;
   }
   const ReportBlockInfoMap* info_map = &(it->second);
   ReportBlockInfoMap::const_iterator it_info = info_map->find(remote_ssrc);
   if (it_info == info_map->end()) {
     return NULL;
   }
   return it_info->second;
 }
 
-RTCPCnameInformation* RTCPReceiver::CreateCnameInformation(
-    uint32_t remoteSSRC) {
-  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-
-  std::map<uint32_t, RTCPCnameInformation*>::iterator it =
-      _receivedCnameMap.find(remoteSSRC);
-
-  if (it != _receivedCnameMap.end()) {
-    return it->second;
-  }
-  RTCPCnameInformation* cnameInfo = new RTCPCnameInformation;
-  memset(cnameInfo->name, 0, RTCP_CNAME_SIZE);
-  _receivedCnameMap[remoteSSRC] = cnameInfo;
-  return cnameInfo;
-}
-
-RTCPCnameInformation* RTCPReceiver::GetCnameInformation(
-    uint32_t remoteSSRC) const {
-  rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-
-  std::map<uint32_t, RTCPCnameInformation*>::const_iterator it =
-      _receivedCnameMap.find(remoteSSRC);
-
-  if (it == _receivedCnameMap.end()) {
-    return NULL;
-  }
-  return it->second;
-}
-
 RTCPReceiveInformation* RTCPReceiver::CreateReceiveInformation(
     uint32_t remoteSSRC) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
       _receivedInfoMap.find(remoteSSRC);
 
   if (it != _receivedInfoMap.end()) {
     return it->second;
   }
@@ skipping 105 matching lines @@
 
 void RTCPReceiver::HandleSDES(const CommonHeader& rtcp_block,
                               PacketInformation* packet_information) {
   rtcp::Sdes sdes;
   if (!sdes.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   for (const rtcp::Sdes::Chunk& chunk : sdes.chunks()) {
-    RTCPCnameInformation* cnameInfo = CreateCnameInformation(chunk.ssrc);
-    RTC_DCHECK(cnameInfo);
-
-    cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0;
-    strncpy(cnameInfo->name, chunk.cname.c_str(), RTCP_CNAME_SIZE - 1);
+    received_cnames_[chunk.ssrc] = chunk.cname;
     {
       rtc::CritScope lock(&_criticalSectionFeedbacks);
       if (stats_callback_)
         stats_callback_->CNameChanged(chunk.cname.c_str(), chunk.ssrc);
     }
   }
   packet_information->packet_type_flags |= kRtcpSdes;
 }
 
 void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block,
@@ skipping 37 matching lines @@
     }
   }
 
   //  we can't delete it due to TMMBR
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(bye.sender_ssrc());
 
   if (receiveInfoIt != _receivedInfoMap.end())
     receiveInfoIt->second->ready_for_delete = true;
 
-  std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt =
-      _receivedCnameMap.find(bye.sender_ssrc());
-
-  if (cnameInfoIt != _receivedCnameMap.end()) {
-    delete cnameInfoIt->second;
-    _receivedCnameMap.erase(cnameInfoIt);
-  }
+  received_cnames_.erase(bye.sender_ssrc());
   xr_rr_rtt_ms_ = 0;
 }
 
 void RTCPReceiver::HandleXr(const CommonHeader& rtcp_block,
                             PacketInformation* packet_information) {
   rtcp::ExtendedReports xr;
   if (!xr.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
@@ skipping 332 matching lines @@
         stats.jitter = report_block.jitter;
 
         stats_callback_->StatisticsUpdated(stats, report_block.sourceSSRC);
       }
     }
   }
 }
 
 int32_t RTCPReceiver::CNAME(uint32_t remoteSSRC,
                             char cName[RTCP_CNAME_SIZE]) const {
-  assert(cName);
+  RTC_DCHECK(cName);
 
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
-  RTCPCnameInformation* cnameInfo = GetCnameInformation(remoteSSRC);
-  if (cnameInfo == NULL) {
+  auto received_cname_it = received_cnames_.find(remoteSSRC);
+  if (received_cname_it == received_cnames_.end())
     return -1;
-  }
-  cName[RTCP_CNAME_SIZE - 1] = 0;
-  strncpy(cName, cnameInfo->name, RTCP_CNAME_SIZE - 1);
+
+  size_t length = received_cname_it->second.copy(cName, RTCP_CNAME_SIZE - 1);
+  cName[length] = 0;
   return 0;
 }
 
 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