media: Refactor bypass bridge for StarboardRenderer (#11262)

Move the media bypass bridge logic out of the core MojoRenderer and
MojoRendererService classes. This logic is now encapsulated within
StarboardRendererClient and StarboardRendererWrapper.

By moving InitializeWithBypassBridge to the StarboardRendererExtension
mojom interface, this refactor keeps Starboard-specific optimizations
separated from the generic Chromium Mojo media implementation. This
improves code maintainability while preserving support for
single-process media bypass.

This PR also aligns the order of functions in StarboardRendererClient
and StarboardRendererWrapper.

Issue: 513254071

Author: borongc

media/mojo/clients/mojo_renderer.cc

@@ -4,11 +4,6 @@
 
 #include "media/mojo/clients/mojo_renderer.h"
 
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-#include <atomic>
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-#include <utility>
-
 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "base/location.h"
@@ -24,36 +19,16 @@
 #include "media/mojo/common/media_type_converters.h"
 #include "media/renderers/video_overlay_factory.h"
 
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-#include "base/command_line.h"
-#include "base/feature_list.h"
-#include "media/base/media_switches.h"
-#endif
-
 namespace media {
 
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-namespace {
-std::atomic<uint32_t> g_next_bypass_id{1};
-}  // namespace
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-
 MojoRenderer::MojoRenderer(
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
     std::unique_ptr<VideoOverlayFactory> video_overlay_factory,
     VideoRendererSink* video_renderer_sink,
-    mojo::PendingRemote<mojom::Renderer> remote_renderer
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-    ,
-    bool bypass_mojo_for_media
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-)
+    mojo::PendingRemote<mojom::Renderer> remote_renderer)
     : task_runner_(task_runner),
       video_overlay_factory_(std::move(video_overlay_factory)),
       video_renderer_sink_(video_renderer_sink),
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-      bypass_mojo_for_media_(bypass_mojo_for_media),
-#endif
       remote_renderer_pending_remote_(std::move(remote_renderer)),
       media_time_interpolator_(base::DefaultTickClock::GetInstance()) {
   DVLOG(1) << __func__;
@@ -63,13 +38,6 @@ MojoRenderer::~MojoRenderer() {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-  if (bypass_bridge_) {
-    bypass_bridge_->Invalidate();
-    BypassBridgeRegistry::Unregister(bypass_id_);
-  }
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-
   CancelPendingCallbacks();
 }
 
@@ -90,36 +58,6 @@ void MojoRenderer::Initialize(MediaResource* media_resource,
   media_resource_ = media_resource;
   init_cb_ = std::move(init_cb);
 
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-  if ((base::FeatureList::IsEnabled(kCobaltBypassMojoForMedia)
-       || bypass_mojo_for_media_) &&
-      base::CommandLine::ForCurrentProcess()->HasSwitch("single-process")) {
-
-    // Create the bypass bridge to manage shared state and callbacks.
-    bypass_bridge_ = base::MakeRefCounted<MojoRendererBypassBridge>(
-        task_runner_,
-        base::BindRepeating(&MojoRenderer::OnTimeUpdate,
-          weak_factory_.GetWeakPtr()),
-        base::BindRepeating(&MojoRenderer::OnStatisticsUpdate,
-          weak_factory_.GetWeakPtr()));
-    // Set the actual streams in the bridge.
-    DemuxerStream* audio_stream = media_resource_->GetFirstStream(
-      DemuxerStream::AUDIO);
-    DemuxerStream* video_stream = media_resource_->GetFirstStream(
-      DemuxerStream::VIDEO);
-    bypass_bridge_->SetStreams(audio_stream, video_stream);
-    // Generate a unique ID and register the bridge.
-    bypass_id_ = g_next_bypass_id.fetch_add(1);
-    BypassBridgeRegistry::Register(bypass_id_, bypass_bridge_);
-    BindRemoteRendererIfNeeded();
-    remote_renderer_->InitializeWithBypassBridge(
-        client_receiver_.BindNewEndpointAndPassRemote(),
-        bypass_id_, base::BindOnce(&MojoRenderer::OnInitialized,
-                                   base::Unretained(this), client));
-    return;
-  }
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-
   // Create mojom::DemuxerStream for each demuxer stream and bind its lifetime
   // to the pipe.
   std::vector<DemuxerStream*> streams = media_resource_->GetAllStreams();

media/mojo/clients/mojo_renderer.h

@@ -23,10 +23,6 @@
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
 
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-#include "media/mojo/common/starboard/mojo_renderer_bypass_bridge.h"
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-
 namespace media {
 
 class MediaResource;
@@ -49,12 +45,7 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   MojoRenderer(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
                std::unique_ptr<VideoOverlayFactory> video_overlay_factory,
                VideoRendererSink* video_renderer_sink,
-               mojo::PendingRemote<mojom::Renderer> remote_renderer
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-               ,
-               bool bypass_mojo_for_media = false
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-               );
+               mojo::PendingRemote<mojom::Renderer> remote_renderer);
 
   MojoRenderer(const MojoRenderer&) = delete;
   MojoRenderer& operator=(const MojoRenderer&) = delete;
@@ -74,13 +65,11 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   base::TimeDelta GetMediaTime() override;
   RendererType GetRendererType() override;
 
+ private:
 #if BUILDFLAG(USE_STARBOARD_MEDIA)
-  scoped_refptr<base::SequencedTaskRunner> task_runner() const {
-    return task_runner_;
-  }
+  friend class StarboardRendererClient;
 #endif
 
- private:
   // mojom::RendererClient implementation, dispatched on the |task_runner_|.
   void OnTimeUpdate(base::TimeDelta time,
                     base::TimeDelta max_time,
@@ -137,12 +126,6 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   // Client of |this| renderer passed in Initialize.
   raw_ptr<media::RendererClient> client_ = nullptr;
 
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-  bool bypass_mojo_for_media_ = false;
-  scoped_refptr<MojoRendererBypassBridge> bypass_bridge_;
-  uint32_t bypass_id_ = 0;
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
-
   // Mojo demuxer streams.
   // Owned by MojoRenderer instead of remote mojom::Renderer
   // because these demuxer streams need to be destroyed as soon as |this| is
@@ -176,10 +159,6 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   media::TimeDeltaInterpolator media_time_interpolator_;
 
   std::optional<PipelineStatistics> pending_stats_;
-
-#if BUILDFLAG(USE_STARBOARD_MEDIA)
-  base::WeakPtrFactory<MojoRenderer> weak_factory_{this};
-#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 };
 
 }  // namespace media

media/mojo/clients/mojo_renderer_factory.cc

@@ -130,8 +130,7 @@ std::unique_ptr<MojoRenderer> MojoRendererFactory::CreateStarboardRenderer(
 
   return std::make_unique<MojoRenderer>(
       media_task_runner, nullptr, video_renderer_sink,
-      std::move(renderer_remote),
-      config.experimental_features.GetBool(kMediaBypassMojoForMedia));
+      std::move(renderer_remote));
 }
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 

media/mojo/clients/mojo_renderer_wrapper.h

@@ -38,6 +38,11 @@ class MojoRendererWrapper : public Renderer {
   void SetVolume(float volume) override;
   base::TimeDelta GetMediaTime() override;
 
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+ protected:
+  MojoRenderer* mojo_renderer() { return mojo_renderer_.get(); }
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+
  private:
   std::unique_ptr<MojoRenderer> mojo_renderer_;
 };

media/mojo/clients/starboard/starboard_renderer_client.cc

@@ -14,15 +14,20 @@
 
 #include "media/mojo/clients/starboard/starboard_renderer_client.h"
 
+#include <atomic>
+
+#include "base/feature_list.h"
 #include "base/functional/bind.h"
 #include "base/time/time.h"
 #include "base/unguessable_token.h"
 #include "media/base/media_log.h"
 #include "media/base/media_resource.h"
+#include "media/base/media_switches.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/clients/mojo_renderer.h"
 #include "media/renderers/video_overlay_factory.h"
 #include "media/video/gpu_video_accelerator_factories.h"
+#include "mojo/public/cpp/bindings/callback_helpers.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 
 #if BUILDFLAG(IS_ANDROID)
@@ -31,6 +36,10 @@
 
 namespace media {
 
+namespace {
+std::atomic<uint32_t> g_next_bypass_id{1};
+}  // namespace
+
 StarboardRendererClient::StarboardRendererClient(
     const scoped_refptr<base::SequencedTaskRunner>& media_task_runner,
     std::unique_ptr<MediaLog> media_log,
@@ -45,7 +54,8 @@ StarboardRendererClient::StarboardRendererClient(
     ,
     RequestOverlayInfoCB request_overlay_info_cb
 #endif  // BUILDFLAG(IS_ANDROID)
-    )
+    ,
+    bool bypass_mojo_for_media)
     : MojoRendererWrapper(std::move(mojo_renderer)),
       media_task_runner_(media_task_runner),
       media_log_(std::move(media_log)),
@@ -60,7 +70,8 @@ StarboardRendererClient::StarboardRendererClient(
       ,
       request_overlay_info_cb_(std::move(request_overlay_info_cb))
 #endif  // BUILDFLAG(IS_ANDROID)
-{
+      ,
+      bypass_mojo_for_media_(bypass_mojo_for_media) {
   DCHECK(media_task_runner_);
   DCHECK(video_renderer_sink_);
   DCHECK(video_overlay_factory_);
@@ -71,6 +82,11 @@ StarboardRendererClient::~StarboardRendererClient() {
   SetPlayingState(false);
   DCHECK(!video_renderer_sink_started_);
 
+  if (bypass_bridge_) {
+    bypass_bridge_->Invalidate();
+    BypassBridgeRegistry::Unregister(bypass_id_);
+  }
+
 #if BUILDFLAG(IS_ANDROID)
   if (request_overlay_info_cb_ && overlay_info_requested_) {
     request_overlay_info_cb_.Run(false, base::NullCallback());
@@ -334,6 +350,72 @@ void StarboardRendererClient::InitializeMojoRenderer(
     PipelineStatusCallback init_cb) {
   DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(AreMojoPipesConnected());
+
+  if (base::FeatureList::IsEnabled(kCobaltBypassMojoForMedia) ||
+      bypass_mojo_for_media_) {
+    bypass_bridge_ = base::MakeRefCounted<MojoRendererBypassBridge>(
+        media_task_runner_,
+        base::BindRepeating(&StarboardRendererClient::OnTimeUpdateFromBridge,
+                            weak_factory_.GetWeakPtr()),
+        base::BindRepeating(
+            &StarboardRendererClient::OnStatisticsUpdateFromBridge,
+            weak_factory_.GetWeakPtr()));
+    DemuxerStream* audio_stream =
+        media_resource->GetFirstStream(DemuxerStream::AUDIO);
+    DemuxerStream* video_stream =
+        media_resource->GetFirstStream(DemuxerStream::VIDEO);
+    bypass_bridge_->SetStreams(audio_stream, video_stream);
+    bypass_id_ = g_next_bypass_id.fetch_add(1);
+    BypassBridgeRegistry::Register(bypass_id_, bypass_bridge_);
+    renderer_extension_->InitializeWithBypassBridge(
+        bypass_id_,
+        mojo::WrapCallbackWithDefaultInvokeIfNotRun(
+            base::BindOnce(
+                &StarboardRendererClient::OnExtensionBypassInitialized,
+                weak_factory_.GetWeakPtr(), media_resource, client,
+                std::move(init_cb)),
+            false));
+    return;
+  }
+
+  MojoRendererWrapper::Initialize(media_resource, client, std::move(init_cb));
+}
+
+void StarboardRendererClient::OnTimeUpdateFromBridge(
+    base::TimeDelta time,
+    base::TimeDelta max_time,
+    base::TimeTicks capture_time) {
+  DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
+  if (mojo_renderer()) {
+    mojo_renderer()->OnTimeUpdate(time, max_time, capture_time);
+  }
+}
+
+void StarboardRendererClient::OnStatisticsUpdateFromBridge(
+    const PipelineStatistics& stats) {
+  DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
+  if (mojo_renderer()) {
+    mojo_renderer()->OnStatisticsUpdate(stats);
+  }
+}
+
+void StarboardRendererClient::OnExtensionBypassInitialized(
+    MediaResource* media_resource,
+    RendererClient* client,
+    PipelineStatusCallback init_cb,
+    bool success) {
+  DCHECK(media_task_runner_->RunsTasksInCurrentSequence());
+  if (!success) {
+    if (bypass_bridge_) {
+      bypass_bridge_->Invalidate();
+      BypassBridgeRegistry::Unregister(bypass_id_);
+      bypass_bridge_ = nullptr;
+    }
+    if (init_cb) {
+      std::move(init_cb).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    }
+    return;
+  }
   MojoRendererWrapper::Initialize(media_resource, client, std::move(init_cb));
 }
 

media/mojo/clients/starboard/starboard_renderer_client.h

@@ -26,6 +26,7 @@
 #include "media/base/starboard/starboard_rendering_mode.h"
 #include "media/base/video_renderer_sink.h"
 #include "media/mojo/clients/mojo_renderer_wrapper.h"
+#include "media/mojo/common/starboard/mojo_renderer_bypass_bridge.h"
 #include "media/mojo/mojom/renderer_extensions.mojom.h"
 #include "media/starboard/starboard_callbacks.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
@@ -68,7 +69,8 @@ class MEDIA_EXPORT StarboardRendererClient
       ,
       RequestOverlayInfoCB request_overlay_info_cb
 #endif  // BUILDFLAG(IS_ANDROID)
-  );
+      ,
+      bool bypass_mojo_for_media = false);
 
   StarboardRendererClient(const StarboardRendererClient&) = delete;
   StarboardRendererClient& operator=(const StarboardRendererClient&) = delete;
@@ -121,6 +123,14 @@ class MEDIA_EXPORT StarboardRendererClient
   void InitializeMojoRenderer(MediaResource* media_resource,
                               RendererClient* client,
                               PipelineStatusCallback init_cb);
+  void OnTimeUpdateFromBridge(base::TimeDelta time,
+                              base::TimeDelta max_time,
+                              base::TimeTicks capture_time);
+  void OnStatisticsUpdateFromBridge(const PipelineStatistics& stats);
+  void OnExtensionBypassInitialized(MediaResource* media_resource,
+                                    RendererClient* client,
+                                    PipelineStatusCallback init_cb,
+                                    bool success);
   void InitAndConstructMojoRenderer(mojom::CommandBufferIdPtr command_buffer_id,
                                     base::OnceClosure complete_cb);
   bool AreMojoPipesConnected() const {
@@ -152,6 +162,9 @@ class MEDIA_EXPORT StarboardRendererClient
 #if BUILDFLAG(IS_ANDROID)
   RequestOverlayInfoCB request_overlay_info_cb_;
 #endif  // BUILDFLAG(IS_ANDROID)
+  bool bypass_mojo_for_media_ = false;
+  scoped_refptr<MojoRendererBypassBridge> bypass_bridge_;
+  uint32_t bypass_id_ = 0;
 
   mojo::Remote<RendererExtension> renderer_extension_;
 

media/mojo/clients/starboard/starboard_renderer_client_factory.cc

@@ -125,7 +125,8 @@ std::unique_ptr<Renderer> StarboardRendererClientFactory::CreateRenderer(
       ,
       std::move(request_overlay_info_cb)
 #endif  // BUILDFLAG(IS_ANDROID)
-  );
+          ,
+      config.experimental_features.GetBool(kMediaBypassMojoForMedia));
 }
 
 }  // namespace media