Remove dead code

webrtc/modules/audio_coding/main/acm2/codec_manager.cc

Index: webrtc/modules/audio_coding/main/acm2/codec_manager.cc
diff --git a/webrtc/modules/audio_coding/main/acm2/codec_manager.cc b/webrtc/modules/audio_coding/main/acm2/codec_manager.cc
index 47bbbde1d5bc482b34ff8565650c9efe18f02aa7..54cf13b8e92066da4ddb2a1ed37de9eeea65928a 100644
--- a/webrtc/modules/audio_coding/main/acm2/codec_manager.cc
+++ b/webrtc/modules/audio_coding/main/acm2/codec_manager.cc
@@ -19,23 +19,15 @@ namespace webrtc {
 namespace acm2 {
 
 namespace {
-bool IsCodecRED(const CodecInst& codec) {
-  return (STR_CASE_CMP(codec.plname, "RED") == 0);
-}
-
-bool IsCodecCN(const CodecInst& codec) {
-  return (STR_CASE_CMP(codec.plname, "CN") == 0);
-}
 
 // Check if the given codec is a valid to be registered as send codec.
-int IsValidSendCodec(const CodecInst& send_codec, bool is_primary_encoder) {
+int IsValidSendCodec(const CodecInst& send_codec) {
   int dummy_id = 0;
   if ((send_codec.channels != 1) && (send_codec.channels != 2)) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
                  "Wrong number of channels (%d, only mono and stereo are "
-                 "supported) for %s encoder",
-                 send_codec.channels,
-                 is_primary_encoder ? "primary" : "secondary");
+                 "supported)",
+                 send_codec.channels);
     return -1;
   }
 
@@ -60,22 +52,6 @@ int IsValidSendCodec(const CodecInst& send_codec, bool is_primary_encoder) {
                  send_codec.channels, send_codec.plname);
     return -1;
   }
-
-  if (!is_primary_encoder) {
-    // If registering the secondary encoder, then RED and CN are not valid
-    // choices as encoder.
-    if (IsCodecRED(send_codec)) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
-                   "RED cannot be secondary codec");
-      return -1;
-    }
-
-    if (IsCodecCN(send_codec)) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
-                   "DTX cannot be secondary codec");
-      return -1;
-    }
-  }
   return RentACodec::CodecIndexFromId(*maybe_codec_id).value_or(-1);
 }
 
@@ -132,33 +108,16 @@ const CodecInst kEmptyCodecInst = {-1, "noCodecRegistered", 0, 0, 0, 0};
 }  // namespace
 
 CodecManager::CodecManager()
-    : cng_nb_pltype_(255),
-      cng_wb_pltype_(255),
-      cng_swb_pltype_(255),
-      cng_fb_pltype_(255),
-      red_nb_pltype_(255),
-      dtx_enabled_(false),
+    : dtx_enabled_(false),
       vad_mode_(VADNormal),
       send_codec_inst_(kEmptyCodecInst),
       red_enabled_(false),
       codec_fec_enabled_(false),
       encoder_is_opus_(false) {
-  // Register the default payload type for RED and for CNG at sampling rates of
-  // 8, 16, 32 and 48 kHz.
+  // Register the default payload types for RED and CNG.
   for (const CodecInst& ci : RentACodec::Database()) {
-    if (IsCodecRED(ci) && ci.plfreq == 8000) {
-      red_nb_pltype_ = static_cast<uint8_t>(ci.pltype);
-    } else if (IsCodecCN(ci)) {
-      if (ci.plfreq == 8000) {
-        cng_nb_pltype_ = static_cast<uint8_t>(ci.pltype);
-      } else if (ci.plfreq == 16000) {
-        cng_wb_pltype_ = static_cast<uint8_t>(ci.pltype);
-      } else if (ci.plfreq == 32000) {
-        cng_swb_pltype_ = static_cast<uint8_t>(ci.pltype);
-      } else if (ci.plfreq == 48000) {
-        cng_fb_pltype_ = static_cast<uint8_t>(ci.pltype);
-      }
-    }
+    RentACodec::RegisterCngPayloadType(&cng_payload_types_, ci);
+    RentACodec::RegisterRedPayloadType(&red_payload_types_, ci);
   }
   thread_checker_.DetachFromThread();
 }
@@ -167,7 +126,7 @@ CodecManager::~CodecManager() = default;
 
 int CodecManager::RegisterEncoder(const CodecInst& send_codec) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  int codec_id = IsValidSendCodec(send_codec, true);
+  int codec_id = IsValidSendCodec(send_codec);
 
   // Check for reported errors from function IsValidSendCodec().
   if (codec_id < 0) {
@@ -175,58 +134,27 @@ int CodecManager::RegisterEncoder(const CodecInst& send_codec) {
   }
 
   int dummy_id = 0;
-  // RED can be registered with other payload type. If not registered a default
-  // payload type is used.
-  if (IsCodecRED(send_codec)) {
-    // TODO(tlegrand): Remove this check. Already taken care of in
-    // ACMCodecDB::CodecNumber().
-    // Check if the payload-type is valid
-    if (!RentACodec::IsPayloadTypeValid(send_codec.pltype)) {
+  switch (RentACodec::RegisterRedPayloadType(&red_payload_types_, send_codec)) {
+    case RentACodec::RegistrationResult::kOk:
+      return 0;
+    case RentACodec::RegistrationResult::kBadFreq:
       WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
-                   "Invalid payload-type %d for %s.", send_codec.pltype,
-                   send_codec.plname);
+                   "RegisterSendCodec() failed, invalid frequency for RED"
+                   " registration");
       return -1;
-    }
-    // Set RED payload type.
-    if (send_codec.plfreq == 8000) {
-      red_nb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-    } else {
+    case RentACodec::RegistrationResult::kSkip:
+      break;
+  }
+  switch (RentACodec::RegisterCngPayloadType(&cng_payload_types_, send_codec)) {
+    case RentACodec::RegistrationResult::kOk:
+      return 0;
+    case RentACodec::RegistrationResult::kBadFreq:
       WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
-                   "RegisterSendCodec() failed, invalid frequency for RED "
-                   "registration");
+                   "RegisterSendCodec() failed, invalid frequency for CNG"
+                   " registration");
       return -1;
-    }
-    return 0;
-  }
-
-  // CNG can be registered with other payload type. If not registered the
-  // default payload types from codec database will be used.
-  if (IsCodecCN(send_codec)) {
-    // CNG is registered.
-    switch (send_codec.plfreq) {
-      case 8000: {
-        cng_nb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        return 0;
-      }
-      case 16000: {
-        cng_wb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        return 0;
-      }
-      case 32000: {
-        cng_swb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        return 0;
-      }
-      case 48000: {
-        cng_fb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        return 0;
-      }
-      default: {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
-                     "RegisterSendCodec() failed, invalid frequency for CNG "
-                     "registration");
-        return -1;
-      }
-    }
+    case RentACodec::RegistrationResult::kSkip:
+      break;
   }
 
   // Set Stereo, and make sure VAD and DTX is turned off.
@@ -418,34 +346,20 @@ AudioDecoder* CodecManager::GetAudioDecoder(const CodecInst& codec) {
   return IsIsac(codec) ? rent_a_codec_.RentIsacDecoder() : nullptr;
 }
 
-int CodecManager::CngPayloadType(int sample_rate_hz) const {
-  switch (sample_rate_hz) {
-    case 8000:
-      return cng_nb_pltype_;
-    case 16000:
-      return cng_wb_pltype_;
-    case 32000:
-      return cng_swb_pltype_;
-    case 48000:
-      return cng_fb_pltype_;
-    default:
-      FATAL() << sample_rate_hz << " Hz is not supported";
-      return -1;
-  }
+int CodecManager::CngPayloadType(int rtp_timestamp_rate_hz) const {
+  RTC_CHECK(rtp_timestamp_rate_hz == 8000 || rtp_timestamp_rate_hz == 16000 ||
+            rtp_timestamp_rate_hz == 32000 || rtp_timestamp_rate_hz == 48000)
+      << rtp_timestamp_rate_hz << " Hz is not supported";
+  auto it = cng_payload_types_.find(rtp_timestamp_rate_hz);
+  return it == cng_payload_types_.end() ? -1 : it->second;
 }
 
-int CodecManager::RedPayloadType(int sample_rate_hz) const {
-  switch (sample_rate_hz) {
-    case 8000:
-      return red_nb_pltype_;
-    case 16000:
-    case 32000:
-    case 48000:
-      return -1;
-    default:
-      FATAL() << sample_rate_hz << " Hz is not supported";
-      return -1;
-  }
+int CodecManager::RedPayloadType(int rtp_timestamp_rate_hz) const {
+  RTC_CHECK(rtp_timestamp_rate_hz == 8000 || rtp_timestamp_rate_hz == 16000 ||
+            rtp_timestamp_rate_hz == 32000 || rtp_timestamp_rate_hz == 48000)
+      << rtp_timestamp_rate_hz << " Hz is not supported";
+  auto it = red_payload_types_.find(rtp_timestamp_rate_hz);
+  return it == red_payload_types_.end() ? -1 : it->second;
 }
 
 void CodecManager::RentEncoderStack(AudioEncoder* speech_encoder,