[Chromecast] Disable media::MojoRenderer for some web pages

For some web pages, we'd like to use DefaultRendererFactory, so that we
can render video on graphics plane. This is mainly used to support
playing short video on top of another Cast web page.

Bug: internal b/125912333
Test: Playing video on top of YT doesn't break any pages.
Merge-With: eureka-internal/247900
Change-Id: Ibbcd3ee13e6642aa4d9ab1548a8f64ce95329fdf
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1496008
Commit-Queue: Yuchen Liu <yucliu@chromium.org>
Reviewed-by: Thomas Guilbert <tguilbert@chromium.org>
Reviewed-by: Emily Stark <estark@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Sean Topping <seantopping@chromium.org>
Cr-Commit-Position: refs/heads/master@{#637824}

chromecast/base/chromecast_switches.cc

@@ -190,6 +190,11 @@ extern const char kCastMemoryPressureCriticalFraction[] =
 extern const char kCastMemoryPressureModerateFraction[] =
     "memory-pressure-moderate-fraction";
 
+// Rather than use the renderer hosted remotely in the media service, fall back
+// to the default renderer within content_renderer. Does not change the behavior
+// of the media service.
+const char kDisableMojoRenderer[] = "disable-mojo-renderer";
+
 }  // namespace switches
 
 namespace chromecast {

chromecast/base/chromecast_switches.h

@@ -91,6 +91,8 @@ extern const char kMixerServiceEndpoint[];
 extern const char kCastMemoryPressureCriticalFraction[];
 extern const char kCastMemoryPressureModerateFraction[];
 
+extern const char kDisableMojoRenderer[];
+
 }  // namespace switches
 
 namespace chromecast {

chromecast/browser/DEPS

@@ -44,6 +44,7 @@ include_rules = [
   "+services/network/public/cpp",
   "+services/service_manager/public",
   "+services/service_manager/embedder",
+  "+third_party/blink/public/common",
   "+ui/accessibility",
   "+ui/aura",
   "+ui/base",

chromecast/browser/cast_web_contents.h

@@ -86,6 +86,7 @@ class CastWebContents {
   struct InitParams {
     Delegate* delegate;
     bool enabled_for_dev;
+    bool use_cma_renderer;
   };
 
   // Page state for the main frame.

chromecast/browser/cast_web_contents_impl.cc

@@ -8,8 +8,10 @@
 
 #include "base/bind.h"
 #include "base/threading/sequenced_task_runner_handle.h"
+#include "chromecast/base/chromecast_switches.h"
 #include "chromecast/browser/cast_browser_process.h"
 #include "chromecast/browser/devtools/remote_debugging_server.h"
+#include "chromecast/common/mojom/media_playback_options.mojom.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
@@ -19,6 +21,7 @@
 #include "content/public/common/bindings_policy.h"
 #include "net/base/net_errors.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 #include "url/gurl.h"
 
 namespace chromecast {
@@ -30,6 +33,7 @@ CastWebContentsImpl::CastWebContentsImpl(content::WebContents* web_contents,
       page_state_(PageState::IDLE),
       last_state_(PageState::IDLE),
       enabled_for_dev_(init_params.enabled_for_dev),
+      use_cma_renderer_(init_params.use_cma_renderer),
       remote_debugging_server_(
           shell::CastBrowserProcess::GetInstance()->remote_debugging_server()),
       closing_(false),
@@ -47,6 +51,11 @@ CastWebContentsImpl::CastWebContentsImpl(content::WebContents* web_contents,
     LOG(INFO) << "Enabling dev console for CastWebContentsImpl";
     remote_debugging_server_->EnableWebContentsForDebugging(web_contents_);
   }
+
+  // TODO(yucliu): Change the flag name to kDisableCmaRenderer in a latter diff.
+  if (GetSwitchValueBoolean(switches::kDisableMojoRenderer, false)) {
+    use_cma_renderer_ = false;
+  }
 }
 
 CastWebContentsImpl::~CastWebContentsImpl() {
@@ -214,6 +223,12 @@ void CastWebContentsImpl::RenderFrameCreated(
   chromecast::shell::mojom::FeatureManagerPtr feature_manager_ptr;
   render_frame_host->GetRemoteInterfaces()->GetInterface(&feature_manager_ptr);
   feature_manager_ptr->ConfigureFeatures(GetRendererFeatures());
+
+  chromecast::shell::mojom::MediaPlaybackOptionsAssociatedPtr
+      media_playback_options;
+  render_frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
+      &media_playback_options);
+  media_playback_options->SetUseCmaRenderer(use_cma_renderer_);
 }
 
 std::vector<chromecast::shell::mojom::FeaturePtr>

chromecast/browser/cast_web_contents_impl.h

@@ -89,6 +89,7 @@ class CastWebContentsImpl : public CastWebContents,
   PageState page_state_;
   PageState last_state_;
   const bool enabled_for_dev_;
+  bool use_cma_renderer_;
   shell::RemoteDebuggingServer* const remote_debugging_server_;
 
   base::flat_set<std::unique_ptr<CastWebContents>> inner_contents_;

chromecast/browser/cast_web_view.h

@@ -80,6 +80,9 @@ class CastWebView {
     // Whether this CastWebView is granted media access.
     bool allow_media_access = false;
 
+    // Whether this CastWebView will use CMA for media playback.
+    bool use_cma_renderer = true;
+
     // Enable development mode for this CastWebView. Whitelists certain
     // functionality for the WebContents, like remote debugging and debugging
     // interfaces.

chromecast/browser/cast_web_view_default.cc

@@ -63,8 +63,9 @@ CastWebViewDefault::CastWebViewDefault(
       transparent_(params.transparent),
       allow_media_access_(params.allow_media_access),
       web_contents_(CreateWebContents(browser_context_, site_instance_)),
-      cast_web_contents_(web_contents_.get(),
-                         {delegate_, params.enabled_for_dev}),
+      cast_web_contents_(
+          web_contents_.get(),
+          {delegate_, params.enabled_for_dev, params.use_cma_renderer}),
       window_(shell::CastContentWindow::Create(params.window_params)),
       resize_window_when_navigation_starts_(true) {
   DCHECK(delegate_);

chromecast/browser/cast_web_view_extension.cc

@@ -30,8 +30,9 @@ CastWebViewExtension::CastWebViewExtension(
           initial_url,
           site_instance.get(),
           extensions::VIEW_TYPE_EXTENSION_POPUP)),
-      cast_web_contents_(extension_host_->host_contents(),
-                         {delegate_, params.enabled_for_dev}) {
+      cast_web_contents_(
+          extension_host_->host_contents(),
+          {delegate_, params.enabled_for_dev, params.use_cma_renderer}) {
   DCHECK(delegate_);
   content::WebContentsObserver::Observe(web_contents());
   web_contents()->GetNativeView()->SetName(params.activity_id);

chromecast/common/mojom/media_playback_options.mojom

@@ -11,4 +11,10 @@ interface MediaPlaybackOptions {
   SetMediaLoadingBlocked(bool blocked);
 
   SetBackgroundVideoPlaybackEnabled(bool enabled);
-};
+
\ No newline at end of file
+  // Enable CMA (MojoRenderer) for media playback.
+  // Otherwise, media playback uses RendererImpl, which is the same as other
+  // platforms. For video codec supported by v4l2 (e.g. h264), it's still
+  // accelerated by hardware. Video will be rendererd on graphics plane.
+  SetUseCmaRenderer(bool enabled);
+};

chromecast/renderer/cast_media_playback_options.cc

@@ -79,6 +79,12 @@ void CastMediaPlaybackOptions::SetBackgroundVideoPlaybackEnabled(bool enabled) {
       renderer_media_playback_options_);
 }
 
+void CastMediaPlaybackOptions::SetUseCmaRenderer(bool enable) {
+  renderer_media_playback_options_.is_mojo_renderer_enabled = enable;
+  render_frame()->SetRenderFrameMediaPlaybackOptions(
+      renderer_media_playback_options_);
+}
+
 void CastMediaPlaybackOptions::OnMediaPlaybackOptionsAssociatedRequest(
     chromecast::shell::mojom::MediaPlaybackOptionsAssociatedRequest request) {
   bindings_.AddBinding(this, std::move(request));

chromecast/renderer/cast_media_playback_options.h

@@ -48,6 +48,7 @@ class CastMediaPlaybackOptions
   // MediaPlaybackOptions implementation
   void SetMediaLoadingBlocked(bool blocked) override;
   void SetBackgroundVideoPlaybackEnabled(bool enabled) override;
+  void SetUseCmaRenderer(bool enable) override;
 
   void OnMediaPlaybackOptionsAssociatedRequest(
       chromecast::shell::mojom::MediaPlaybackOptionsAssociatedRequest request);

content/browser/renderer_host/render_process_host_impl.cc

@@ -3089,9 +3089,6 @@ void RenderProcessHostImpl::PropagateBrowserCommandLineToRenderer(
 
 #if BUILDFLAG(ENABLE_PLUGINS)
     switches::kEnablePepperTesting,
-#endif
-#if BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
-    switches::kDisableMojoRenderer,
 #endif
     switches::kDisableWebRtcHWDecoding,
     switches::kDisableWebRtcHWEncoding,

content/public/renderer/render_frame_media_playback_options.h

@@ -28,6 +28,9 @@ struct RenderFrameMediaPlaybackOptions {
 
   // Whether background video optimization is supported on current platform.
   bool is_background_video_track_optimization_supported = true;
+
+  // Whether MojoRenderer should be used for given |render_frame|.
+  bool is_mojo_renderer_enabled = true;
 };
 
 }  // namespace content

content/renderer/media/media_factory.cc

@@ -330,7 +330,10 @@ blink::WebMediaPlayer* MediaFactory::CreateMediaPlayer(
   base::WeakPtr<media::MediaObserver> media_observer;
 
   auto factory_selector = CreateRendererFactorySelector(
-      media_log.get(), use_media_player_renderer, GetDecoderFactory(),
+      media_log.get(), use_media_player_renderer,
+      render_frame_->GetRenderFrameMediaPlaybackOptions()
+          .is_mojo_renderer_enabled,
+      GetDecoderFactory(),
       std::make_unique<media::RemotePlaybackClientWrapperImpl>(client),
       &media_observer);
 
@@ -416,6 +419,7 @@ std::unique_ptr<media::RendererFactorySelector>
 MediaFactory::CreateRendererFactorySelector(
     media::MediaLog* media_log,
     bool use_media_player,
+    bool enable_mojo_renderer,
     media::DecoderFactory* decoder_factory,
     std::unique_ptr<media::RemotePlaybackClientWrapper> client_wrapper,
     base::WeakPtr<media::MediaObserver>* out_media_observer) {
@@ -470,13 +474,7 @@ MediaFactory::CreateRendererFactorySelector(
 
   bool use_mojo_renderer_factory = false;
 #if BUILDFLAG(ENABLE_MOJO_RENDERER)
-#if BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
-  use_mojo_renderer_factory =
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableMojoRenderer);
-#else
-  use_mojo_renderer_factory = true;
-#endif  // BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
+  use_mojo_renderer_factory = enable_mojo_renderer;
   if (use_mojo_renderer_factory) {
     auto mojo_renderer_factory = std::make_unique<media::MojoRendererFactory>(
         base::Bind(&RenderThreadImpl::GetGpuFactories,

content/renderer/media/media_factory.h

@@ -119,6 +119,7 @@ class MediaFactory {
   std::unique_ptr<media::RendererFactorySelector> CreateRendererFactorySelector(
       media::MediaLog* media_log,
       bool use_media_player,
+      bool enable_mojo_renderer,
       media::DecoderFactory* decoder_factory,
       std::unique_ptr<media::RemotePlaybackClientWrapper> client_wrapper,
       base::WeakPtr<media::MediaObserver>* out_media_observer);

media/BUILD.gn

@@ -35,7 +35,6 @@ buildflag_header("media_buildflags") {
     "ENABLE_MEDIA_REMOTING_RPC=$enable_media_remoting_rpc",
     "ENABLE_MPEG_H_AUDIO_DEMUXING=$enable_mpeg_h_audio_demuxing",
     "ENABLE_MSE_MPEG2TS_STREAM_PARSER=$enable_mse_mpeg2ts_stream_parser",
-    "ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION=$enable_runtime_media_renderer_selection",
     "USE_PROPRIETARY_CODECS=$proprietary_codecs",
   ]
 }

media/base/media_switches.cc

@@ -81,13 +81,6 @@ const char kUseCras[] = "use-cras";
 const char kUnsafelyAllowProtectedMediaIdentifierForDomain[] =
     "unsafely-allow-protected-media-identifier-for-domain";
 
-#if BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
-// Rather than use the renderer hosted remotely in the media service, fall back
-// to the default renderer within content_renderer. Does not change the behavior
-// of the media service.
-const char kDisableMojoRenderer[] = "disable-mojo-renderer";
-#endif  // BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
-
 // Use fake device for Media Stream to replace actual camera and microphone.
 const char kUseFakeDeviceForMediaStream[] = "use-fake-device-for-media-stream";
 

media/base/media_switches.h

@@ -56,10 +56,6 @@ MEDIA_EXPORT extern const char kUseCras[];
 MEDIA_EXPORT extern const char
     kUnsafelyAllowProtectedMediaIdentifierForDomain[];
 
-#if BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
-MEDIA_EXPORT extern const char kDisableMojoRenderer[];
-#endif  // BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
-
 MEDIA_EXPORT extern const char kUseFakeDeviceForMediaStream[];
 MEDIA_EXPORT extern const char kUseFileForFakeVideoCapture[];
 MEDIA_EXPORT extern const char kUseFileForFakeAudioCapture[];

media/mojo/BUILD.gn

@@ -36,9 +36,6 @@ buildflag_header("buildflags") {
         assert(false, "Invalid mojo media service: $service")
       }
     }
-    assert(
-        enable_mojo_renderer || !enable_runtime_media_renderer_selection,
-        "The mojo renderer must be enabled to use runtime media renderer selection.")
 
     if (mojo_media_host == "browser") {
       enable_mojo_media_in_browser_process = true