Optional: Use nullopt and implicit construction in /api/audio_codecs

Changes places where we explicitly construct an Optional to instead use
nullopt or the requisite value type only.

This CL was uploaded by git cl split.

R=kwiberg@webrtc.org

Bug: None
Change-Id: I30f47ec9b6dbef216ee061a96fad8ca14c041bb5
Reviewed-on: https://webrtc-review.googlesource.com/23566
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Oskar Sundbom <ossu@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20711}

api/audio_codecs/L16/audio_decoder_L16.cc

@@ -25,7 +25,7 @@ rtc::Optional<AudioDecoderL16::Config> AudioDecoderL16::SdpToConfig(
   config.num_channels = rtc::checked_cast<int>(format.num_channels);
   return STR_CASE_CMP(format.name.c_str(), "L16") == 0 && config.IsOk()
              ? rtc::Optional<Config>(config)
-             : rtc::Optional<Config>();
+             : rtc::nullopt;
 }
 
 void AudioDecoderL16::AppendSupportedDecoders(

api/audio_codecs/L16/audio_encoder_L16.cc

@@ -21,14 +21,14 @@ namespace webrtc {
 rtc::Optional<AudioEncoderL16::Config> AudioEncoderL16::SdpToConfig(
     const SdpAudioFormat& format) {
   if (!rtc::IsValueInRangeForNumericType<int>(format.num_channels)) {
-    return rtc::Optional<Config>();
+    return rtc::nullopt;
   }
   Config config;
   config.sample_rate_hz = format.clockrate_hz;
   config.num_channels = rtc::dchecked_cast<int>(format.num_channels);
   return STR_CASE_CMP(format.name.c_str(), "L16") == 0 && config.IsOk()
              ? rtc::Optional<Config>(config)
-             : rtc::Optional<Config>();
+             : rtc::nullopt;
 }
 
 void AudioEncoderL16::AppendSupportedEncoders(

api/audio_codecs/audio_decoder.cc

@@ -39,7 +39,7 @@ class OldStyleEncodedFrame final : public AudioDecoder::EncodedAudioFrame {
     const int ret = decoder_->Decode(
         payload_.data(), payload_.size(), decoder_->SampleRateHz(),
         decoded.size() * sizeof(int16_t), decoded.data(), &speech_type);
-    return ret < 0 ? rtc::Optional<DecodeResult>()
+    return ret < 0 ? rtc::nullopt
                    : rtc::Optional<DecodeResult>(
                          {static_cast<size_t>(ret), speech_type});
   }

api/audio_codecs/audio_encoder.cc

@@ -85,7 +85,7 @@ void AudioEncoder::OnReceivedUplinkRecoverablePacketLossFraction(
     float uplink_recoverable_packet_loss_fraction) {}
 
 void AudioEncoder::OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) {
-  OnReceivedUplinkBandwidth(target_audio_bitrate_bps, rtc::Optional<int64_t>());
+  OnReceivedUplinkBandwidth(target_audio_bitrate_bps, rtc::nullopt);
 }
 
 void AudioEncoder::OnReceivedUplinkBandwidth(

api/audio_codecs/audio_encoder_factory_template.h

@@ -31,7 +31,7 @@ struct Helper<> {
   static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs) {}
   static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
       const SdpAudioFormat& format) {
-    return rtc::Optional<AudioCodecInfo>();
+    return rtc::nullopt;
   }
   static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
       int payload_type,

api/audio_codecs/g711/audio_decoder_g711.cc

@@ -30,9 +30,9 @@ rtc::Optional<AudioDecoderG711::Config> AudioDecoderG711::SdpToConfig(
     config.type = is_pcmu ? Config::Type::kPcmU : Config::Type::kPcmA;
     config.num_channels = rtc::dchecked_cast<int>(format.num_channels);
     RTC_DCHECK(config.IsOk());
-    return rtc::Optional<Config>(config);
+    return config;
   } else {
-    return rtc::Optional<Config>();
+    return rtc::nullopt;
   }
 }
 

api/audio_codecs/g711/audio_encoder_g711.cc

@@ -40,9 +40,9 @@ rtc::Optional<AudioEncoderG711::Config> AudioEncoderG711::SdpToConfig(
       }
     }
     RTC_DCHECK(config.IsOk());
-    return rtc::Optional<Config>(config);
+    return config;
   } else {
-    return rtc::Optional<Config>();
+    return rtc::nullopt;
   }
 }
 

api/audio_codecs/g722/audio_decoder_g722.cc

@@ -27,7 +27,7 @@ rtc::Optional<AudioDecoderG722::Config> AudioDecoderG722::SdpToConfig(
                  (format.num_channels == 1 || format.num_channels == 2)
              ? rtc::Optional<Config>(
                    Config{rtc::dchecked_cast<int>(format.num_channels)})
-             : rtc::Optional<Config>();
+             : rtc::nullopt;
 }
 
 void AudioDecoderG722::AppendSupportedDecoders(

api/audio_codecs/g722/audio_encoder_g722.cc

@@ -26,7 +26,7 @@ rtc::Optional<AudioEncoderG722Config> AudioEncoderG722::SdpToConfig(
     const SdpAudioFormat& format) {
   if (STR_CASE_CMP(format.name.c_str(), "g722") != 0 ||
       format.clockrate_hz != 8000) {
-    return rtc::Optional<AudioEncoderG722Config>();
+    return rtc::nullopt;
   }
 
   AudioEncoderG722Config config;
@@ -40,7 +40,7 @@ rtc::Optional<AudioEncoderG722Config> AudioEncoderG722::SdpToConfig(
     }
   }
   return config.IsOk() ? rtc::Optional<AudioEncoderG722Config>(config)
-                       : rtc::Optional<AudioEncoderG722Config>();
+                       : rtc::nullopt;
 }
 
 void AudioEncoderG722::AppendSupportedEncoders(

api/audio_codecs/ilbc/audio_decoder_ilbc.cc

@@ -24,7 +24,7 @@ rtc::Optional<AudioDecoderIlbc::Config> AudioDecoderIlbc::SdpToConfig(
   return STR_CASE_CMP(format.name.c_str(), "ILBC") == 0 &&
                  format.clockrate_hz == 8000 && format.num_channels == 1
              ? rtc::Optional<Config>(Config())
-             : rtc::Optional<Config>();
+             : rtc::nullopt;
 }
 
 void AudioDecoderIlbc::AppendSupportedDecoders(

api/audio_codecs/ilbc/audio_encoder_ilbc.cc

@@ -42,7 +42,7 @@ rtc::Optional<AudioEncoderIlbcConfig> AudioEncoderIlbc::SdpToConfig(
     const SdpAudioFormat& format) {
   if (STR_CASE_CMP(format.name.c_str(), "ILBC") != 0 ||
       format.clockrate_hz != 8000 || format.num_channels != 1) {
-    return rtc::Optional<AudioEncoderIlbcConfig>();
+    return rtc::nullopt;
   }
 
   AudioEncoderIlbcConfig config;
@@ -55,7 +55,7 @@ rtc::Optional<AudioEncoderIlbcConfig> AudioEncoderIlbc::SdpToConfig(
     }
   }
   return config.IsOk() ? rtc::Optional<AudioEncoderIlbcConfig>(config)
-                       : rtc::Optional<AudioEncoderIlbcConfig>();
+                       : rtc::nullopt;
 }
 
 void AudioEncoderIlbc::AppendSupportedEncoders(

api/audio_codecs/isac/audio_decoder_isac_fix.cc

@@ -21,7 +21,7 @@ rtc::Optional<AudioDecoderIsacFix::Config> AudioDecoderIsacFix::SdpToConfig(
   return STR_CASE_CMP(format.name.c_str(), "ISAC") == 0 &&
                  format.clockrate_hz == 16000 && format.num_channels == 1
              ? rtc::Optional<Config>(Config())
-             : rtc::Optional<Config>();
+             : rtc::nullopt;
 }
 
 void AudioDecoderIsacFix::AppendSupportedDecoders(

api/audio_codecs/isac/audio_decoder_isac_float.cc

@@ -23,9 +23,9 @@ rtc::Optional<AudioDecoderIsacFloat::Config> AudioDecoderIsacFloat::SdpToConfig(
       format.num_channels == 1) {
     Config config;
     config.sample_rate_hz = format.clockrate_hz;
-    return rtc::Optional<Config>(config);
+    return config;
   } else {
-    return rtc::Optional<Config>();
+    return rtc::nullopt;
   }
 }
 

api/audio_codecs/isac/audio_encoder_isac_fix.cc

@@ -29,9 +29,9 @@ rtc::Optional<AudioEncoderIsacFix::Config> AudioEncoderIsacFix::SdpToConfig(
         config.frame_size_ms = 60;
       }
     }
-    return rtc::Optional<Config>(config);
+    return config;
   } else {
-    return rtc::Optional<Config>();
+    return rtc::nullopt;
   }
 }
 

api/audio_codecs/isac/audio_encoder_isac_float.cc

@@ -35,9 +35,9 @@ rtc::Optional<AudioEncoderIsacFloat::Config> AudioEncoderIsacFloat::SdpToConfig(
         }
       }
     }
-    return rtc::Optional<Config>(config);
+    return config;
   } else {
-    return rtc::Optional<Config>();
+    return rtc::nullopt;
   }
 }
 

api/audio_codecs/opus/audio_decoder_opus.cc

@@ -22,25 +22,25 @@ namespace webrtc {
 
 rtc::Optional<AudioDecoderOpus::Config> AudioDecoderOpus::SdpToConfig(
     const SdpAudioFormat& format) {
-  const rtc::Optional<int> num_channels = [&] {
+  const auto num_channels = [&]() -> rtc::Optional<int> {
     auto stereo = format.parameters.find("stereo");
     if (stereo != format.parameters.end()) {
       if (stereo->second == "0") {
-        return rtc::Optional<int>(1);
+        return 1;
       } else if (stereo->second == "1") {
-        return rtc::Optional<int>(2);
+        return 2;
       } else {
-        return rtc::Optional<int>();  // Bad stereo parameter.
+        return rtc::nullopt;  // Bad stereo parameter.
       }
     }
-    return rtc::Optional<int>(1);  // Default to mono.
+    return 1;  // Default to mono.
   }();
   if (STR_CASE_CMP(format.name.c_str(), "opus") == 0 &&
       format.clockrate_hz == 48000 && format.num_channels == 2 &&
       num_channels) {
-    return rtc::Optional<Config>(Config{*num_channels});
+    return Config{*num_channels};
   } else {
-    return rtc::Optional<Config>();
+    return rtc::nullopt;
   }
 }
 

api/audio_codecs/test/audio_decoder_factory_template_unittest.cc

@@ -47,9 +47,9 @@ struct AudioDecoderFakeApi {
       const SdpAudioFormat& audio_format) {
     if (Params::AudioFormat() == audio_format) {
       MyLittleConfig config = {audio_format};
-      return rtc::Optional<MyLittleConfig>(config);
+      return config;
     } else {
-      return rtc::Optional<MyLittleConfig>();
+      return rtc::nullopt;
     }
   }
 

api/audio_codecs/test/audio_encoder_factory_template_unittest.cc

@@ -47,9 +47,9 @@ struct AudioEncoderFakeApi {
       const SdpAudioFormat& audio_format) {
     if (Params::AudioFormat() == audio_format) {
       MyLittleConfig config = {audio_format};
-      return rtc::Optional<MyLittleConfig>(config);
+      return config;
     } else {
-      return rtc::Optional<MyLittleConfig>();
+      return rtc::nullopt;
     }
   }
 
@@ -78,8 +78,7 @@ TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) {
       new rtc::RefCountedObject<
           audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>());
   EXPECT_THAT(factory->GetSupportedEncoders(), testing::IsEmpty());
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
-            factory->QueryAudioEncoder({"foo", 8000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
 }
 
@@ -88,9 +87,8 @@ TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
   EXPECT_THAT(factory->GetSupportedEncoders(),
               testing::ElementsAre(
                   AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
-            factory->QueryAudioEncoder({"foo", 8000, 1}));
+  EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 12345}),
             factory->QueryAudioEncoder({"bogus", 8000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
   auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1});
@@ -106,12 +104,11 @@ TEST(AudioEncoderFactoryTemplateTest, TwoEncoderTypes) {
                   AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}},
                   AudioCodecSpec{{"sham", 16000, 2, {{"param", "value"}}},
                                  {16000, 2, 23456}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
-            factory->QueryAudioEncoder({"foo", 8000, 1}));
+  EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 12345}),
             factory->QueryAudioEncoder({"bogus", 8000, 1}));
   EXPECT_EQ(
-      rtc::Optional<AudioCodecInfo>({16000, 2, 23456}),
+      AudioCodecInfo(16000, 2, 23456),
       factory->QueryAudioEncoder({"sham", 16000, 2, {{"param", "value"}}}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
   auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1});
@@ -130,9 +127,8 @@ TEST(AudioEncoderFactoryTemplateTest, G711) {
               testing::ElementsAre(
                   AudioCodecSpec{{"PCMU", 8000, 1}, {8000, 1, 64000}},
                   AudioCodecSpec{{"PCMA", 8000, 1}, {8000, 1, 64000}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"PCMA", 16000, 1}));
-            factory->QueryAudioEncoder({"PCMA", 16000, 1}));
+  EXPECT_EQ(AudioCodecInfo(8000, 1, 64000),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 64000}),
             factory->QueryAudioEncoder({"PCMA", 8000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"PCMU", 16000, 1}));
   auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1});
@@ -148,9 +144,8 @@ TEST(AudioEncoderFactoryTemplateTest, G722) {
   EXPECT_THAT(factory->GetSupportedEncoders(),
               testing::ElementsAre(
                   AudioCodecSpec{{"G722", 8000, 1}, {16000, 1, 64000}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
-            factory->QueryAudioEncoder({"foo", 8000, 1}));
+  EXPECT_EQ(AudioCodecInfo(16000, 1, 64000),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({16000, 1, 64000}),
             factory->QueryAudioEncoder({"G722", 8000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
   auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1});
@@ -163,9 +158,8 @@ TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
   EXPECT_THAT(factory->GetSupportedEncoders(),
               testing::ElementsAre(
                   AudioCodecSpec{{"ILBC", 8000, 1}, {8000, 1, 13333}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
-            factory->QueryAudioEncoder({"foo", 8000, 1}));
+  EXPECT_EQ(AudioCodecInfo(8000, 1, 13333),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 13333}),
             factory->QueryAudioEncoder({"ilbc", 8000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 8000, 1}));
   auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1});
@@ -178,12 +172,10 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFix) {
   EXPECT_THAT(factory->GetSupportedEncoders(),
               testing::ElementsAre(AudioCodecSpec{
                   {"ISAC", 16000, 1}, {16000, 1, 32000, 10000, 32000}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 16000, 2}));
-            factory->QueryAudioEncoder({"isac", 16000, 2}));
+  EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({16000, 1, 32000, 10000, 32000}),
             factory->QueryAudioEncoder({"isac", 16000, 1}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 32000, 1}));
-            factory->QueryAudioEncoder({"isac", 32000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"isac", 8000, 1}));
   auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1});
   ASSERT_NE(nullptr, enc1);
@@ -202,11 +194,10 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFloat) {
       testing::ElementsAre(
           AudioCodecSpec{{"ISAC", 16000, 1}, {16000, 1, 32000, 10000, 32000}},
           AudioCodecSpec{{"ISAC", 32000, 1}, {32000, 1, 56000, 10000, 56000}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 16000, 2}));
-            factory->QueryAudioEncoder({"isac", 16000, 2}));
+  EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({16000, 1, 32000, 10000, 32000}),
             factory->QueryAudioEncoder({"isac", 16000, 1}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({32000, 1, 56000, 10000, 56000}),
+  EXPECT_EQ(AudioCodecInfo(32000, 1, 56000, 10000, 56000),
             factory->QueryAudioEncoder({"isac", 32000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"isac", 8000, 1}));
   auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1});
@@ -228,9 +219,8 @@ TEST(AudioEncoderFactoryTemplateTest, L16) {
           AudioCodecSpec{{"L16", 8000, 2}, {8000, 2, 8000 * 16 * 2}},
           AudioCodecSpec{{"L16", 16000, 2}, {16000, 2, 16000 * 16 * 2}},
           AudioCodecSpec{{"L16", 32000, 2}, {32000, 2, 32000 * 16 * 2}}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"L16", 8000, 0}));
-            factory->QueryAudioEncoder({"L16", 8000, 0}));
+  EXPECT_EQ(AudioCodecInfo(48000, 1, 48000 * 16),
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>({48000, 1, 48000 * 16}),
             factory->QueryAudioEncoder({"L16", 48000, 1}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"L16", 8000, 0}));
   auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2});
@@ -248,10 +238,9 @@ TEST(AudioEncoderFactoryTemplateTest, Opus) {
       testing::ElementsAre(AudioCodecSpec{
           {"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}},
           info}));
-  EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
+  EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
-            factory->QueryAudioEncoder({"foo", 8000, 1}));
   EXPECT_EQ(
-      rtc::Optional<AudioCodecInfo>(info),
+      info,
       factory->QueryAudioEncoder(
           {"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}}));
   EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));