RtpDataEngine, FindCodecByName: Don't reassign codecs

webrtc/media/base/rtpdataengine.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.
  */
 
 #include "webrtc/media/base/rtpdataengine.h"
 
 #include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/ratelimiter.h"
+#include "webrtc/base/stringutils.h"
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/media/base/streamparams.h"
 
 namespace cricket {
 
 // We want to avoid IP fragmentation.
 static const size_t kDataMaxRtpPacketLen = 1200U;
 // We reserve space after the RTP header for future wiggle room.
@@ skipping 12 matching lines @@
 }
 
 DataMediaChannel* RtpDataEngine::CreateChannel(
     DataChannelType data_channel_type) {
   if (data_channel_type != DCT_RTP) {
     return NULL;
   }
   return new RtpDataMediaChannel();
 }
 
-bool FindCodecByName(const std::vector<DataCodec>& codecs,
-                     const std::string& name, DataCodec* codec_out) {
-  std::vector<DataCodec>::const_iterator iter;
-  for (iter = codecs.begin(); iter != codecs.end(); ++iter) {
-    if (iter->name == name) {
-      *codec_out = *iter;
-      return true;
-    }
+static const DataCodec* FindCodecByName(const std::vector<DataCodec>& codecs,
+                                        const std::string& name) {
+  for (const DataCodec& codec : codecs) {
+    if (_stricmp(name.c_str(), codec.name.c_str()) == 0)
+      return &codec;
   }
-  return false;
+  return nullptr;
 }
 
 RtpDataMediaChannel::RtpDataMediaChannel() {
   Construct();
 }
 
 void RtpDataMediaChannel::Construct() {
   sending_ = false;
   receiving_ = false;
   send_limiter_.reset(new rtc::RateLimiter(kDataMaxBandwidth / 8, 1.0));
@@ skipping 216 matching lines @@
   }
 
   const StreamParams* found_stream =
       GetStreamBySsrc(send_streams_, params.ssrc);
   if (!found_stream) {
     LOG(LS_WARNING) << "Not sending data because ssrc is unknown: "
                     << params.ssrc;
     return false;
   }
 
-  DataCodec found_codec;
-  if (!FindCodecByName(send_codecs_, kGoogleRtpDataCodecName, &found_codec)) {
+  const DataCodec* found_codec =
+      FindCodecByName(send_codecs_, kGoogleRtpDataCodecName);
+  if (!found_codec) {
     LOG(LS_WARNING) << "Not sending data because codec is unknown: "
                     << kGoogleRtpDataCodecName;
     return false;
   }
 
   size_t packet_len = (kMinRtpPacketLen + sizeof(kReservedSpace) +
                        payload.size() + kMaxSrtpHmacOverhead);
   if (packet_len > kDataMaxRtpPacketLen) {
     return false;
   }
 
   double now =
       rtc::TimeMicros() / static_cast<double>(rtc::kNumMicrosecsPerSec);
 
   if (!send_limiter_->CanUse(packet_len, now)) {
     LOG(LS_VERBOSE) << "Dropped data packet of len=" << packet_len
                     << "; already sent " << send_limiter_->used_in_period()
                     << "/" << send_limiter_->max_per_period();
     return false;
   }
 
   RtpHeader header;
-  header.payload_type = found_codec.id;
+  header.payload_type = found_codec->id;
   header.ssrc = params.ssrc;
   rtp_clock_by_send_ssrc_[header.ssrc]->Tick(
       now, &header.seq_num, &header.timestamp);
 
   rtc::CopyOnWriteBuffer packet(kMinRtpPacketLen, packet_len);
   if (!SetRtpHeader(packet.data(), packet.size(), header)) {
     return false;
   }
   packet.AppendData(kReservedSpace);
   packet.AppendData(payload);
 
   LOG(LS_VERBOSE) << "Sent RTP data packet: "
                   << " stream=" << found_stream->id << " ssrc=" << header.ssrc
                   << ", seqnum=" << header.seq_num
                   << ", timestamp=" << header.timestamp
                   << ", len=" << payload.size();
 
   MediaChannel::SendPacket(&packet, rtc::PacketOptions());
   send_limiter_->Use(packet_len, now);
   if (result) {
     *result = SDR_SUCCESS;
   }
   return true;
 }
 
 }  // namespace cricket