Refactor TransmissionEncodingInfoHandler

Avoids using wertc's VideoEncoderFactory::QueryVideoEncoder() and
CodecInfo::is_hardware_accelerated, features that webrtc strives to
delete.

Bug: None
Change-Id: Ibcb6cd27b2149669a5bd6fda24e68fe5dd19091c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2338614Reviewed-by: Florent Castelli <orphis@chromium.org>
Commit-Queue: Niels Möller <nisse@chromium.org>
Cr-Commit-Position: refs/heads/master@{#796771}

third_party/blink/renderer/platform/peerconnection/transmission_encoding_info_handler.cc

@@ -76,24 +76,22 @@ TransmissionEncodingInfoHandler* TransmissionEncodingInfoHandler::Instance() {
 // returns software encoder factory only.
 TransmissionEncodingInfoHandler::TransmissionEncodingInfoHandler()
     : TransmissionEncodingInfoHandler(
-          blink::CreateWebrtcVideoEncoderFactory(GetGpuFactories()),
+          blink::CreateHWVideoEncoderFactory(GetGpuFactories()),
           CanCpuEncodeHdSmoothly()) {}
 
 TransmissionEncodingInfoHandler::TransmissionEncodingInfoHandler(
     std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory,
     bool cpu_hd_smooth)
     : cpu_hd_smooth_(cpu_hd_smooth) {
-  std::vector<webrtc::SdpVideoFormat> supported_video_formats =
-      video_encoder_factory->GetSupportedFormats();
-  for (const auto& video_format : supported_video_formats) {
-    const String codec_name = String::FromUTF8(video_format.name).LowerASCII();
-    supported_video_codecs_.insert(codec_name);
-    const auto codec_info =
-        video_encoder_factory->QueryVideoEncoder(video_format);
-    if (codec_info.is_hardware_accelerated)
+  if (video_encoder_factory) {
+    std::vector<webrtc::SdpVideoFormat> supported_video_formats =
+        video_encoder_factory->GetSupportedFormats();
+    for (const auto& video_format : supported_video_formats) {
+      const String codec_name =
+          String::FromUTF8(video_format.name).LowerASCII();
       hardware_accelerated_video_codecs_.insert(codec_name);
+    }
   }
-
   rtc::scoped_refptr<webrtc::AudioEncoderFactory> audio_encoder_factory =
       blink::CreateWebrtcAudioEncoderFactory();
   std::vector<webrtc::AudioCodecSpec> supported_audio_specs =
@@ -103,9 +101,8 @@ TransmissionEncodingInfoHandler::TransmissionEncodingInfoHandler(
         String::FromUTF8(audio_spec.format.name).LowerASCII());
   }
   DVLOG(2) << String::Format(
-      "supported_video_codecs_:[%s] hardware_accelerated_video_codecs_:[%s] "
+      "hardware_accelerated_video_codecs_:[%s] "
       "supported_audio_codecs_:[%s]",
-      StringHashSetToString(supported_video_codecs_).Utf8().c_str(),
       StringHashSetToString(hardware_accelerated_video_codecs_).Utf8().c_str(),
       StringHashSetToString(supported_audio_codecs_).Utf8().c_str());
 }

third_party/blink/renderer/platform/peerconnection/transmission_encoding_info_handler.h

@@ -57,8 +57,6 @@ class PLATFORM_EXPORT TransmissionEncodingInfoHandler {
   bool CanCpuEncodeSmoothly(
       const blink::WebVideoConfiguration& configuration) const;
 
-  // List of supported video codecs.
-  HashSet<String> supported_video_codecs_;
   // List of hardware accelerated codecs.
   HashSet<String> hardware_accelerated_video_codecs_;
   // List of supported audio codecs.

third_party/blink/renderer/platform/peerconnection/transmission_encoding_info_handler_test.cc

@@ -29,29 +29,14 @@ class FakeVideoEncoderFactory : public webrtc::VideoEncoderFactory {
   FakeVideoEncoderFactory() = default;
   ~FakeVideoEncoderFactory() override = default;
 
-  void AddSupportedFormat(const webrtc::SdpVideoFormat& video_format,
-                          bool is_hardware_accelerated = false,
-                          bool has_internal_source = false) {
+  void AddSupportedFormat(const webrtc::SdpVideoFormat& video_format) {
     supported_video_formats_.push_back(video_format);
-    codec_info_.push_back({.is_hardware_accelerated = is_hardware_accelerated,
-                           .has_internal_source = has_internal_source});
   }
 
   std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override {
     return supported_video_formats_;
   }
 
-  CodecInfo QueryVideoEncoder(
-      const webrtc::SdpVideoFormat& format) const override {
-    DCHECK_EQ(supported_video_formats_.size(), codec_info_.size());
-    for (size_t i = 0; i < supported_video_formats_.size(); ++i) {
-      if (supported_video_formats_[i] == format)
-        return codec_info_[i];
-    }
-    NOTREACHED() << "QueryVideoEncoder() assumes |format| is supported.";
-    return CodecInfo();
-  }
-
   std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
       const webrtc::SdpVideoFormat& format) override {
     return std::unique_ptr<webrtc::VideoEncoder>();
@@ -59,7 +44,6 @@ class FakeVideoEncoderFactory : public webrtc::VideoEncoderFactory {
 
  private:
   std::vector<webrtc::SdpVideoFormat> supported_video_formats_;
-  std::vector<CodecInfo> codec_info_;
 };
 
 }  // namespace
@@ -180,11 +164,7 @@ class TransmissionEncodingInfoHandlerTest : public testing::Test {
 };
 
 TEST_F(TransmissionEncodingInfoHandlerTest, SupportedVideoCodec) {
-  auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            false);
-  TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
-                                          false);
+  TransmissionEncodingInfoHandler handler(nullptr, false);
   VerifyEncodingInfo(handler,
                      ComposeWebMediaConfigurationForVideo("video/vp8", ""),
                      true, false, false);
@@ -216,8 +196,7 @@ TEST_F(TransmissionEncodingInfoHandlerTest, SupportedAudioCodec) {
 
 TEST_F(TransmissionEncodingInfoHandlerTest, HardwareAcceleratedVideoCodec) {
   auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            true);
+  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"));
   TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
                                           false);
   VerifyEncodingInfo(handler,
@@ -227,12 +206,8 @@ TEST_F(TransmissionEncodingInfoHandlerTest, HardwareAcceleratedVideoCodec) {
 
 TEST_F(TransmissionEncodingInfoHandlerTest, SmoothVideoCodecPowerfulCpu) {
   // Assume no HW vp8 encoder.
-  auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            false);
   // Assume powerful CPU.
-  TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
-                                          true);
+  TransmissionEncodingInfoHandler handler(nullptr, true);
   VerifyEncodingInfo(handler,
                      ComposeWebMediaConfigurationForVideo("video/vp8", ""),
                      true, true, false);
@@ -240,12 +215,8 @@ TEST_F(TransmissionEncodingInfoHandlerTest, SmoothVideoCodecPowerfulCpu) {
 
 TEST_F(TransmissionEncodingInfoHandlerTest, SmoothVideoCodecVgaResolution) {
   // Assume no HW vp8 encoder.
-  auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            false);
   // Assume no powerful CPU.
-  TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
-                                          false);
+  TransmissionEncodingInfoHandler handler(nullptr, false);
 
   // VP8 encoding for 640x480 video.
   blink::WebMediaConfiguration config(
@@ -257,12 +228,8 @@ TEST_F(TransmissionEncodingInfoHandlerTest, SmoothVideoCodecVgaResolution) {
 
 TEST_F(TransmissionEncodingInfoHandlerTest, SmoothVideoCodecBelowHdResolution) {
   // Assume no HW vp8 encoder.
-  auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            false);
   // Assume no powerful CPU.
-  TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
-                                          false);
+  TransmissionEncodingInfoHandler handler(nullptr, false);
 
   // VP8 encoding for 1024x768 video. Note its area size is below 1280x720).
   blink::WebMediaConfiguration config(
@@ -279,11 +246,7 @@ TEST_F(TransmissionEncodingInfoHandlerTest, AudioAndVideoCodec) {
       ComposeAudioConfiguration("audio/opus", ""),
       ComposeVideoConfiguration("video/vp8", ""));
 
-  auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            false);
-  TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
-                                          false);
+  TransmissionEncodingInfoHandler handler(nullptr, false);
   VerifyEncodingInfo(handler, config, true, false, false);
 }
 
@@ -296,8 +259,7 @@ TEST_F(TransmissionEncodingInfoHandlerTest,
       ComposeVideoConfiguration("video/vp8", ""));
 
   auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            true);
+  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"));
   TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
                                           false);
   VerifyEncodingInfo(handler, config, true, true, true);
@@ -311,12 +273,8 @@ TEST_F(TransmissionEncodingInfoHandlerTest, AudioAndVideoCodecWithPowerfulCpu) {
       ComposeVideoConfiguration("video/vp8", ""));
 
   // Assume no HW vp8 encoder.
-  auto video_encoder_factory = std::make_unique<FakeVideoEncoderFactory>();
-  video_encoder_factory->AddSupportedFormat(webrtc::SdpVideoFormat("vp8"),
-                                            false);
   // Assume powerful CPU.
-  TransmissionEncodingInfoHandler handler(std::move(video_encoder_factory),
-                                          true);
+  TransmissionEncodingInfoHandler handler(nullptr, true);
   VerifyEncodingInfo(handler, config, true, true, false);
 }
 

third_party/blink/renderer/platform/peerconnection/video_codec_factory.cc

@@ -185,7 +185,7 @@ class DecoderAdapter : public webrtc::VideoDecoderFactory {
 
 }  // namespace
 
-std::unique_ptr<webrtc::VideoEncoderFactory> CreateWebrtcVideoEncoderFactory(
+std::unique_ptr<webrtc::VideoEncoderFactory> CreateHWVideoEncoderFactory(
     media::GpuVideoAcceleratorFactories* gpu_factories) {
   std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory;
 
@@ -199,7 +199,13 @@ std::unique_ptr<webrtc::VideoEncoderFactory> CreateWebrtcVideoEncoderFactory(
     encoder_factory.reset();
 #endif
 
-  return std::make_unique<EncoderAdapter>(std::move(encoder_factory));
+  return encoder_factory;
+}
+
+std::unique_ptr<webrtc::VideoEncoderFactory> CreateWebrtcVideoEncoderFactory(
+    media::GpuVideoAcceleratorFactories* gpu_factories) {
+  return std::make_unique<EncoderAdapter>(
+      CreateHWVideoEncoderFactory(gpu_factories));
 }
 
 std::unique_ptr<webrtc::VideoDecoderFactory> CreateWebrtcVideoDecoderFactory(

third_party/blink/renderer/platform/peerconnection/video_codec_factory.h

@@ -15,6 +15,10 @@ class GpuVideoAcceleratorFactories;
 
 namespace blink {
 
+// Creates a factory representing available and enabled hardware encoders.
+PLATFORM_EXPORT std::unique_ptr<webrtc::VideoEncoderFactory>
+CreateHWVideoEncoderFactory(media::GpuVideoAcceleratorFactories* gpu_factories);
+
 PLATFORM_EXPORT std::unique_ptr<webrtc::VideoEncoderFactory>
 CreateWebrtcVideoEncoderFactory(
     media::GpuVideoAcceleratorFactories* gpu_factories);