cobalt: Move VideoGeometrySetterService on gpu thread (#8962)

Relocate the VideoGeometrySetterService from the browser process to
the GPU process. This change instantiates the service within the
CobaltContentGpuClient, allowing it to be managed directly on the GPU
thread.

This improves performance and reduces IPC overhead for video geometry
updates by co-locating the service closer to the GPU and compositing
operations. The StarboardRendererWrapper now directly subscribes to
video geometry changes from this local service.

Mojo communications:
- Before: viz (gpu) --> browser thread --> StarboardRendererClient
(media) --> StarboardRendererWrapper (gpu)
- After: viz (gpu) --> StarboardRendererWrapper (gpu)

Note this is called nearly per UI frame update.

Issue: 405424096
(cherry picked from commit d1376b1)

Author: borongc

cobalt/browser/cobalt_content_browser_client.cc

@@ -36,8 +36,6 @@
 #include "cobalt/browser/mojom/h5vcc_settings.mojom.h"
 #include "cobalt/browser/user_agent/user_agent_platform_info.h"
 #include "cobalt/common/features/starboard_features_initialization.h"
-#include "cobalt/media/service/mojom/video_geometry_setter.mojom.h"
-#include "cobalt/media/service/video_geometry_setter_service.h"
 #include "cobalt/shell/browser/shell.h"
 #include "cobalt/shell/browser/shell_paths.h"
 #include "cobalt/shell/common/shell_switches.h"
@@ -153,12 +151,7 @@ blink::UserAgentMetadata GetCobaltUserAgentMetadata() {
   return metadata;
 }
 
-CobaltContentBrowserClient::CobaltContentBrowserClient()
-    : video_geometry_setter_service_(
-          std::unique_ptr<cobalt::media::VideoGeometrySetterService,
-                          base::OnTaskRunnerDeleter>(
-              nullptr,
-              base::OnTaskRunnerDeleter(nullptr))) {
+CobaltContentBrowserClient::CobaltContentBrowserClient() {
   DETACH_FROM_THREAD(thread_checker_);
 }
 
@@ -340,43 +333,16 @@ void CobaltContentBrowserClient::RegisterBrowserInterfaceBindersForFrame(
       render_frame_host, map);
 }
 
-void CobaltContentBrowserClient::CreateVideoGeometrySetterService() {
-  DCHECK(!video_geometry_setter_service_);
-  video_geometry_setter_service_ =
-      std::unique_ptr<cobalt::media::VideoGeometrySetterService,
-                      base::OnTaskRunnerDeleter>(
-          new media::VideoGeometrySetterService,
-          base::OnTaskRunnerDeleter(
-              base::SingleThreadTaskRunner::GetCurrentDefault()));
-}
-
 void CobaltContentBrowserClient::ExposeInterfacesToRenderer(
     service_manager::BinderRegistry* registry,
     blink::AssociatedInterfaceRegistry* associated_registry,
     content::RenderProcessHost* render_process_host) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (!video_geometry_setter_service_) {
-    CreateVideoGeometrySetterService();
-  }
-  registry->AddInterface<cobalt::media::mojom::VideoGeometryChangeSubscriber>(
-      video_geometry_setter_service_->GetBindSubscriberCallback(),
-      base::SingleThreadTaskRunner::GetCurrentDefault());
   registry->AddInterface<cobalt::mojom::H5vccSettings>(
       base::BindRepeating(&H5vccSettingsImpl::Create),
       base::SingleThreadTaskRunner::GetCurrentDefault());
 }
 
-void CobaltContentBrowserClient::BindGpuHostReceiver(
-    mojo::GenericPendingReceiver receiver) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (!video_geometry_setter_service_) {
-    CreateVideoGeometrySetterService();
-  }
-  if (auto r = receiver.As<media::mojom::VideoGeometrySetter>()) {
-    video_geometry_setter_service_->GetVideoGeometrySetter(std::move(r));
-  }
-}
-
 bool CobaltContentBrowserClient::WillCreateURLLoaderFactory(
     content::BrowserContext* browser_context,
     content::RenderFrameHost* frame,

cobalt/browser/cobalt_content_browser_client.h

@@ -41,10 +41,6 @@ class BinderMapWithContext;
 
 namespace cobalt {
 
-namespace media {
-class VideoGeometrySetterService;
-}  // namespace media
-
 class CobaltMetricsServicesManagerClient;
 class CobaltWebContentsObserver;
 
@@ -98,7 +94,6 @@ class CobaltContentBrowserClient : public content::ShellContentBrowserClient {
       service_manager::BinderRegistry* registry,
       blink::AssociatedInterfaceRegistry* associated_registry,
       content::RenderProcessHost* render_process_host) override;
-  void BindGpuHostReceiver(mojo::GenericPendingReceiver receiver) override;
 
   // Initializes all necessary parameters to create the feature list and calls
   // base::FeatureList::SetInstance() to set the global instance.
@@ -128,11 +123,7 @@ class CobaltContentBrowserClient : public content::ShellContentBrowserClient {
   void DispatchFocus();
 
  private:
-  void CreateVideoGeometrySetterService();
-
   std::unique_ptr<CobaltWebContentsObserver> web_contents_observer_;
-  std::unique_ptr<media::VideoGeometrySetterService, base::OnTaskRunnerDeleter>
-      video_geometry_setter_service_;
 
   THREAD_CHECKER(thread_checker_);
 };

cobalt/gpu/BUILD.gn

@@ -20,6 +20,7 @@ source_set("gpu") {
 
   deps = [
     "//base",
+    "//cobalt/media/service",
     "//cobalt/media/service/mojom",
     "//components/viz/common",
     "//components/viz/service",

cobalt/gpu/cobalt_content_gpu_client.cc

@@ -16,23 +16,36 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/task/single_thread_task_runner.h"
+#include "cobalt/media/service/mojom/video_geometry_setter.mojom.h"
+#include "cobalt/media/service/video_geometry_setter_service.h"
 #include "components/viz/service/display/starboard/overlay_strategy_underlay_starboard.h"
 #include "content/public/child/child_thread.h"
 
 namespace cobalt {
 
-CobaltContentGpuClient::CobaltContentGpuClient() = default;
+CobaltContentGpuClient::CobaltContentGpuClient()
+    : video_geometry_setter_service_(
+          std::unique_ptr<cobalt::media::VideoGeometrySetterService,
+                          base::OnTaskRunnerDeleter>(
+              nullptr,
+              base::OnTaskRunnerDeleter(nullptr))) {}
+
 CobaltContentGpuClient::~CobaltContentGpuClient() = default;
 
 void CobaltContentGpuClient::PostCompositorThreadCreated(
     base::SingleThreadTaskRunner* task_runner) {
+  if (!video_geometry_setter_service_) {
+    CreateVideoGeometrySetterService();
+  }
   // Initialize PendingRemote for VideoGeometrySetter and post it
   // to compositor thread (viz service). This is called on gpu thread
   // right after the compositor thread is created.
   mojo::PendingRemote<cobalt::media::mojom::VideoGeometrySetter>
       video_geometry_setter;
-  content::ChildThread::Get()->BindHostReceiver(
-      video_geometry_setter.InitWithNewPipeAndPassReceiver());
+  mojo::PendingReceiver<cobalt::media::mojom::VideoGeometrySetter>
+      pending_receiver = video_geometry_setter.InitWithNewPipeAndPassReceiver();
+  video_geometry_setter_service_->GetVideoGeometrySetter(
+      std::move(pending_receiver));
 
   task_runner->PostTask(
       FROM_HERE,
@@ -41,4 +54,22 @@ void CobaltContentGpuClient::PostCompositorThreadCreated(
           std::move(video_geometry_setter)));
 }
 
+media::VideoGeometrySetterService*
+CobaltContentGpuClient::GetVideoGeometrySetterService() {
+  if (!video_geometry_setter_service_) {
+    CreateVideoGeometrySetterService();
+  }
+  return video_geometry_setter_service_.get();
+}
+
+void CobaltContentGpuClient::CreateVideoGeometrySetterService() {
+  DCHECK(!video_geometry_setter_service_);
+  video_geometry_setter_service_ =
+      std::unique_ptr<cobalt::media::VideoGeometrySetterService,
+                      base::OnTaskRunnerDeleter>(
+          new media::VideoGeometrySetterService,
+          base::OnTaskRunnerDeleter(
+              base::SingleThreadTaskRunner::GetCurrentDefault()));
+}
+
 }  // namespace cobalt

cobalt/gpu/cobalt_content_gpu_client.h

@@ -22,6 +22,10 @@
 
 namespace cobalt {
 
+namespace media {
+class VideoGeometrySetterService;
+}  // namespace media
+
 // This class utilizes embedder API for participating in gpu logic.
 // It allows Cobalt to interact with viz service and compositor thread.
 class CobaltContentGpuClient : public content::ContentGpuClient {
@@ -36,6 +40,13 @@ class CobaltContentGpuClient : public content::ContentGpuClient {
   // content::ContentGpuClient:
   void PostCompositorThreadCreated(
       base::SingleThreadTaskRunner* task_runner) override;
+  media::VideoGeometrySetterService* GetVideoGeometrySetterService() override;
+
+ private:
+  void CreateVideoGeometrySetterService();
+
+  std::unique_ptr<media::VideoGeometrySetterService, base::OnTaskRunnerDeleter>
+      video_geometry_setter_service_;
 };
 
 }  // namespace cobalt

cobalt/renderer/cobalt_content_renderer_client.cc

@@ -23,9 +23,7 @@
 #include "media/base/media_switches.h"
 #include "media/base/renderer_factory.h"
 #include "media/mojo/clients/starboard/starboard_renderer_client_factory.h"
-#include "media/starboard/bind_host_receiver_callback.h"
 #include "media/starboard/decoder_buffer_allocator.h"
-#include "mojo/public/cpp/bindings/generic_pending_receiver.h"
 #include "starboard/media.h"
 #include "starboard/player.h"
 #include "third_party/blink/public/platform/web_string.h"
@@ -121,10 +119,6 @@ ::media::SupportedCodecs GetStarboardEmeSupportedCodecs() {
   return codecs;
 }
 
-void BindHostReceiverWithValuation(mojo::GenericPendingReceiver receiver) {
-  content::RenderThread::Get()->BindHostReceiver(std::move(receiver));
-}
-
 // TODO: b/460292554 - This code is a tentative solution, and will be replaced
 // once base::Feature is fully supported.
 //
@@ -254,11 +248,6 @@ ExperimentalFeatures ProcessH5vccSettings(
 
 }  // namespace
 
-static_assert(std::is_same<::media::BindHostReceiverCallback,
-                           base::RepeatingCallback<
-                               decltype(BindHostReceiverWithValuation)>>::value,
-              "These two types must be the same");
-
 CobaltContentRendererClient::CobaltContentRendererClient() {
   DETACH_FROM_THREAD(thread_checker_);
 }
@@ -363,12 +352,6 @@ void CobaltContentRendererClient::RunScriptsAtDocumentStart(
   communication->RunScriptsAtDocumentStart();
 }
 
-void CobaltContentRendererClient::BindHostReceiver(
-    mojo::GenericPendingReceiver receiver) {
-  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  BindHostReceiverWithValuation(std::move(receiver));
-}
-
 void CobaltContentRendererClient::GetStarboardRendererFactoryTraits(
     media::RendererFactoryTraits* renderer_factory_traits) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
@@ -392,11 +375,6 @@ void CobaltContentRendererClient::GetStarboardRendererFactoryTraits(
   renderer_factory_traits->experimental_features = experimental_features;
 
   renderer_factory_traits->viewport_size = viewport_size_;
-  // TODO(b/405424096) - Cobalt: Move VideoGeometrySetterService to Gpu thread.
-  renderer_factory_traits->bind_host_receiver_callback =
-      base::BindPostTaskToCurrentDefault(
-          base::BindRepeating(&CobaltContentRendererClient::BindHostReceiver,
-                              weak_factory_.GetWeakPtr()));
 }
 
 void CobaltContentRendererClient::PostSandboxInitialized() {

cobalt/renderer/cobalt_content_renderer_client.h

@@ -26,10 +26,6 @@ class MediaLog;
 class RendererFactory;
 }  // namespace media
 
-namespace mojo {
-class GenericPendingReceiver;
-}  // namespace mojo
-
 namespace cobalt {
 // This class utilizes embedder API for participating in renderer logic.
 // It allows Cobalt to customize content Renderer module.
@@ -55,11 +51,6 @@ class CobaltContentRendererClient : public content::ContentRendererClient {
       ::media::RendererFactoryTraits* traits) override;
   void PostSandboxInitialized() override;
 
-  // Bind Host Receiver to VideoGeometryChangeSubscriber on Browser thread.
-  // This is called from StarboardRenderer with |BindPostTaskToCurrentDefault|
-  // on media thread to post the task on Renderer thread.
-  void BindHostReceiver(mojo::GenericPendingReceiver receiver);
-
  private:
   // Registers a custom content::AudioDeviceFactory
   ::media::CobaltAudioDeviceFactory cobalt_audio_device_factory_;

content/gpu/gpu_service_factory.cc

@@ -26,6 +26,11 @@
 #include "ui/gl/gl_angle_util_win.h"
 #endif
 
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+#include "content/public/common/content_client.h"
+#include "content/public/gpu/content_gpu_client.h"
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+
 namespace content {
 
 GpuServiceFactory::GpuServiceFactory(
@@ -81,13 +86,27 @@ void GpuServiceFactory::RunMediaService(
 #endif
   }
 
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+  content::ContentGpuClient* client = GetContentClient()->gpu();
+  cobalt::media::VideoGeometrySetterService* video_geometry_setter_service = nullptr;
+  if (client) {
+    video_geometry_setter_service =
+        client->GetVideoGeometrySetterService();
+  }
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+
   using FactoryCallback =
       base::OnceCallback<std::unique_ptr<media::MediaService>()>;
   FactoryCallback factory =
       base::BindOnce(&media::CreateGpuMediaService, std::move(receiver),
                      gpu_preferences_, gpu_workarounds_, gpu_feature_info_,
                      gpu_info_, task_runner_, media_gpu_channel_manager_,
-                     gpu_memory_buffer_factory_, android_overlay_factory_cb_);
+                     gpu_memory_buffer_factory_, android_overlay_factory_cb_
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+                     ,
+                     video_geometry_setter_service
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+                     );
   task_runner->PostTask(
       FROM_HERE,
       base::BindOnce(

content/public/gpu/content_gpu_client.cc

@@ -23,4 +23,11 @@ ContentGpuClient::GetVizCompositorThreadRunner() {
   return nullptr;
 }
 
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+cobalt::media::VideoGeometrySetterService*
+ContentGpuClient::GetVideoGeometrySetterService() {
+  return nullptr;
+}
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+
 }  // namespace content

content/public/gpu/content_gpu_client.h

@@ -11,6 +11,12 @@
 #include "content/public/common/content_client.h"
 #include "mojo/public/cpp/bindings/binder_map.h"
 
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+namespace cobalt::media {
+class VideoGeometrySetterService;
+}
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+
 namespace gpu {
 struct GpuPreferences;
 class GpuDriverBugWorkarounds;
@@ -55,6 +61,10 @@ class CONTENT_EXPORT ContentGpuClient {
   virtual gpu::SharedImageManager* GetSharedImageManager();
   virtual gpu::Scheduler* GetScheduler();
   virtual viz::VizCompositorThreadRunner* GetVizCompositorThreadRunner();
+
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+  virtual cobalt::media::VideoGeometrySetterService* GetVideoGeometrySetterService();
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 };
 
 }  // namespace content