cobalt: Move VideoGeometrySetterService on gpu thread (youtube#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

Author: borongc

cobalt/browser/cobalt_content_browser_client.cc

@@ -42,9 +42,7 @@
 #include "cobalt/browser/metrics/cobalt_metrics_services_manager_client.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/platform_window_provider_service.h"
-#include "cobalt/media/service/video_geometry_setter_service.h"
 #include "cobalt/shell/browser/shell.h"
 #include "cobalt/shell/common/shell_paths.h"
 #include "cobalt/shell/common/shell_switches.h"
@@ -69,8 +67,6 @@
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "services/network/public/cpp/features.h"
 #include "services/network/public/mojom/network_context.mojom.h"
-#include "services/service_manager/public/cpp/binder_registry.h"
-#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
 #include "third_party/blink/public/common/web_preferences/web_preferences.h"
 
 #if BUILDFLAG(IS_ANDROID)
@@ -170,12 +166,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() {
   COBALT_DETACH_FROM_THREAD(thread_checker_);
 #if BUILDFLAG(IS_STARBOARD)
   // TODO: b/476434249 - Revisit if Cobalt supports multiple tabs/windows.
@@ -376,40 +367,6 @@ 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());
-}
-
-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));
-  }
-}
-
 void CobaltContentBrowserClient::WillCreateURLLoaderFactory(
     content::BrowserContext* browser_context,
     content::RenderFrameHost* frame,

cobalt/browser/cobalt_content_browser_client.h

@@ -48,10 +48,6 @@ class BinderMapWithContext;
 
 namespace cobalt {
 
-namespace media {
-class VideoGeometrySetterService;
-}  // namespace media
-
 class CobaltMetricsServicesManagerClient;
 class CobaltWebContentsObserver;
 
@@ -102,11 +98,6 @@ class CobaltContentBrowserClient : public content::ShellContentBrowserClient {
       content::RenderFrameHost* render_frame_host,
       mojo::BinderMapWithContext<content::RenderFrameHost*>* binder_map)
       override;
-  void ExposeInterfacesToRenderer(
-      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.
@@ -148,13 +139,10 @@ class CobaltContentBrowserClient : public content::ShellContentBrowserClient {
 #endif  // !BUILDFLAG(IS_ANDROIDTV)
 
  private:
-  void CreateVideoGeometrySetterService();
   void DispatchEvent(const std::string&, base::OnceClosure);
   void OnSbWindowCreated(SbWindow window);
 
   std::unique_ptr<CobaltWebContentsObserver> web_contents_observer_;
-  std::unique_ptr<media::VideoGeometrySetterService, base::OnTaskRunnerDeleter>
-      video_geometry_setter_service_;
 
   uint64_t cached_sb_window_ = 0;
   std::vector<

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

@@ -18,27 +18,58 @@
 
 #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/video_geometry_setter.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,
                         base::BindOnce(&viz::ConnectVideoGeometrySetter,
                                        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

@@ -20,6 +20,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 {
@@ -34,6 +38,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

@@ -19,8 +19,6 @@
 #include "media/base/media_log.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 "mojo/public/cpp/bindings/generic_pending_receiver.h"
 #include "starboard/media.h"
 #include "starboard/player.h"
 #include "third_party/blink/public/common/thread_safe_browser_interface_broker_proxy.h"
@@ -91,17 +89,8 @@ ::media::SupportedCodecs GetStarboardEmeSupportedCodecs() {
   return codecs;
 }
 
-void BindHostReceiverWithValuation(mojo::GenericPendingReceiver receiver) {
-  content::RenderThread::Get()->BindHostReceiver(std::move(receiver));
-}
-
 }  // namespace
 
-static_assert(std::is_same<::media::BindHostReceiverCallback,
-                           base::RepeatingCallback<
-                               decltype(BindHostReceiverWithValuation)>>::value,
-              "These two types must be the same");
-
 CobaltContentRendererClient::CobaltContentRendererClient() {
   CHECK_CALLED_ON_VALID_THREAD(main_thread_checker_);
 }
@@ -233,12 +222,6 @@ void CobaltContentRendererClient::RunScriptsAtDocumentStart(
   communication->RunScriptsAtDocumentStart();
 }
 
-void CobaltContentRendererClient::BindHostReceiver(
-    mojo::GenericPendingReceiver receiver) {
-  CHECK(content::RenderThread::IsMainThread());
-  BindHostReceiverWithValuation(std::move(receiver));
-}
-
 void CobaltContentRendererClient::GetStarboardRendererFactoryTraits(
     ::media::RendererFactoryTraits* renderer_factory_traits) {
   CHECK(content::RenderThread::IsMainThread());
@@ -256,11 +239,6 @@ void CobaltContentRendererClient::GetStarboardRendererFactoryTraits(
   renderer_factory_traits->get_sb_window_handle_callback = base::BindRepeating(
       &CobaltContentRendererClient::GetSbWindowHandle, base::Unretained(this));
 #endif  // BUILDFLAG(IS_STARBOARD)
-  // 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

@@ -29,10 +29,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.
@@ -60,11 +56,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);
-
   uint64_t GetSbWindowHandle() const { return sb_window_handle_; }
 
  private:

cobalt/testing/browser_tests/BUILD.gn

@@ -467,6 +467,7 @@ static_library("cobalt_shell_test_lib") {
     ":cobalt_browsertests_support",
     ":cobalt_browsertests_support_mojom",
     "//cc/base",
+    "//cobalt/media/service",
     "//cobalt/media/service/mojom",
     "//cobalt/shell:cobalt_shell_app",
     "//cobalt/shell:cobalt_shell_lib",

cobalt/testing/browser_tests/gpu/shell_content_gpu_test_client.cc

@@ -17,6 +17,7 @@
 #include "base/functional/bind.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 "cobalt/testing/browser_tests/common/power_monitor_test_impl.h"
 #include "components/viz/service/display/starboard/video_geometry_setter.h"
 #include "content/public/child/child_thread.h"
@@ -25,7 +26,12 @@
 
 namespace content {
 
-ShellContentGpuTestClient::ShellContentGpuTestClient() = default;
+ShellContentGpuTestClient::ShellContentGpuTestClient()
+    : video_geometry_setter_service_(
+          std::unique_ptr<cobalt::media::VideoGeometrySetterService,
+                          base::OnTaskRunnerDeleter>(
+              nullptr,
+              base::OnTaskRunnerDeleter(nullptr))) {}
 
 ShellContentGpuTestClient::~ShellContentGpuTestClient() = default;
 
@@ -50,4 +56,22 @@ void ShellContentGpuTestClient::PostCompositorThreadCreated(
                                        std::move(video_geometry_setter)));
 }
 
+cobalt::media::VideoGeometrySetterService*
+ShellContentGpuTestClient::GetVideoGeometrySetterService() {
+  if (!video_geometry_setter_service_) {
+    CreateVideoGeometrySetterService();
+  }
+  return video_geometry_setter_service_.get();
+}
+
+void ShellContentGpuTestClient::CreateVideoGeometrySetterService() {
+  DCHECK(!video_geometry_setter_service_);
+  video_geometry_setter_service_ =
+      std::unique_ptr<cobalt::media::VideoGeometrySetterService,
+                      base::OnTaskRunnerDeleter>(
+          new cobalt::media::VideoGeometrySetterService,
+          base::OnTaskRunnerDeleter(
+              base::SingleThreadTaskRunner::GetCurrentDefault()));
+}
+
 }  // namespace content

cobalt/testing/browser_tests/gpu/shell_content_gpu_test_client.h

@@ -15,6 +15,7 @@
 #ifndef COBALT_TESTING_BROWSER_TESTS_GPU_SHELL_CONTENT_GPU_TEST_CLIENT_H_
 #define COBALT_TESTING_BROWSER_TESTS_GPU_SHELL_CONTENT_GPU_TEST_CLIENT_H_
 
+#include "cobalt/media/service/video_geometry_setter_service.h"
 #include "content/public/gpu/content_gpu_client.h"
 #include "services/network/public/mojom/network_service_test.mojom-forward.h"
 
@@ -38,6 +39,16 @@ class ShellContentGpuTestClient : public ContentGpuClient {
 
   void PostCompositorThreadCreated(
       base::SingleThreadTaskRunner* task_runner) override;
+
+  cobalt::media::VideoGeometrySetterService* GetVideoGeometrySetterService()
+      override;
+
+ private:
+  void CreateVideoGeometrySetterService();
+
+  std::unique_ptr<cobalt::media::VideoGeometrySetterService,
+                  base::OnTaskRunnerDeleter>
+      video_geometry_setter_service_;
 };
 
 }  // namespace content