Android: Honor disabling legacy video HW codec acceleration

This CL is a forward fix of
https://webrtc-review.googlesource.com/c/src/+/83729. That CL
accidentally changed the behavior in a specific case when a client would
both explicitly call setEnableVideoHwAcceleration(false) and also not
inject neither a encoder nor a decoder factory.
This CL restores the behavior for that specific case.

Bug: webrtc:7925
Change-Id: I7653453d5dceb2e61fede164216ff2c879d760ed
Reviewed-on: https://webrtc-review.googlesource.com/87847
Reviewed-by: Anders Carlsson <andersc@webrtc.org>
Commit-Queue: Magnus Jedvert <magjed@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23909}

sdk/android/BUILD.gn

@@ -336,6 +336,8 @@ rtc_static_library("video_jni") {
     "../..:webrtc_common",
     "../../api:libjingle_peerconnection_api",
     "../../api/video:video_frame",
+    "../../api/video_codecs:builtin_video_decoder_factory",
+    "../../api/video_codecs:builtin_video_encoder_factory",
     "../../api/video_codecs:rtc_software_fallback_wrappers",
     "../../api/video_codecs:video_codecs_api",
     "../../common_video:common_video",

sdk/android/src/jni/pc/peerconnectionfactory.cc

@@ -243,9 +243,21 @@ jlong CreatePeerConnectionFactoryForJava(
 
   VideoEncoderFactory* legacy_video_encoder_factory = nullptr;
   VideoDecoderFactory* legacy_video_decoder_factory = nullptr;
+  std::unique_ptr<VideoEncoderFactory> video_encoder_factory;
+  std::unique_ptr<VideoDecoderFactory> video_decoder_factory;
   std::unique_ptr<cricket::MediaEngineInterface> media_engine;
 
-  std::unique_ptr<VideoEncoderFactory> video_encoder_factory = nullptr;
+  if (jencoder_factory.is_null() && jdecoder_factory.is_null() &&
+      !video_hw_acceleration_enabled) {
+    // Legacy path for clients that are explicitly calling
+    // setEnableVideoHwAcceleration(false) and not injecting neither encoder nor
+    // decoder. These clients should be migrated to only pass in
+    // SoftwareVideoEncoderFactory instead.
+    video_encoder_factory =
+        WrapLegacyVideoEncoderFactory(/* legacy_encoder_factory= */ nullptr);
+    video_decoder_factory =
+        WrapLegacyVideoDecoderFactory(/* legacy_decoder_factory= */ nullptr);
+  } else {
     if (jencoder_factory.is_null()) {
       // TODO(bugs.webrtc.org/7925): When all clients switched to injectable
       // factories, remove the legacy codec factories
@@ -259,7 +271,6 @@ jlong CreatePeerConnectionFactoryForJava(
           CreateVideoEncoderFactory(jni, jencoder_factory));
     }
 
-  std::unique_ptr<VideoDecoderFactory> video_decoder_factory = nullptr;
     if (jdecoder_factory.is_null()) {
       // TODO(bugs.webrtc.org/7925): When all clients switched to injectable
       // factories, remove the legacy codec factories
@@ -272,7 +283,7 @@ jlong CreatePeerConnectionFactoryForJava(
       video_decoder_factory = std::unique_ptr<VideoDecoderFactory>(
           CreateVideoDecoderFactory(jni, jdecoder_factory));
     }
-
+  }
   media_engine.reset(CreateMediaEngine(
       audio_device_module, audio_encoder_factory, audio_decoder_factory,
       std::move(video_encoder_factory), std::move(video_decoder_factory),

sdk/android/src/jni/pc/video.cc

@@ -13,6 +13,8 @@
 #include <jni.h>
 #include <memory>
 
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder_factory.h"
 #include "api/videosourceproxy.h"
@@ -88,14 +90,18 @@ std::unique_ptr<VideoDecoderFactory> CreateLegacyVideoDecoderFactory() {
 
 std::unique_ptr<VideoEncoderFactory> WrapLegacyVideoEncoderFactory(
     std::unique_ptr<VideoEncoderFactory> legacy_encoder_factory) {
-  return std::unique_ptr<VideoEncoderFactory>(
+  return legacy_encoder_factory ? std::unique_ptr<VideoEncoderFactory>(
-      cricket::ConvertVideoEncoderFactory(std::move(legacy_encoder_factory)));
+                                      cricket::ConvertVideoEncoderFactory(
+                                          std::move(legacy_encoder_factory)))
+                                : CreateBuiltinVideoEncoderFactory();
 }
 
 std::unique_ptr<VideoDecoderFactory> WrapLegacyVideoDecoderFactory(
     std::unique_ptr<VideoDecoderFactory> legacy_decoder_factory) {
-  return std::unique_ptr<VideoDecoderFactory>(
+  return legacy_decoder_factory ? std::unique_ptr<VideoDecoderFactory>(
-      cricket::ConvertVideoDecoderFactory(std::move(legacy_decoder_factory)));
+                                      cricket::ConvertVideoDecoderFactory(
+                                          std::move(legacy_decoder_factory)))
+                                : CreateBuiltinVideoDecoderFactory();
 }
 
 }  // namespace jni