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,12 @@
 #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"
+<<<<<<< HEAD
 #include "cobalt/media/service/mojom/video_geometry_setter.mojom.h"
 #include "cobalt/media/service/video_geometry_setter_service.h"
+=======
+#include "cobalt/media/service/platform_window_provider_service.h"
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 #include "cobalt/shell/browser/shell.h"
 #include "cobalt/shell/browser/shell_paths.h"
 #include "cobalt/shell/common/shell_switches.h"
@@ -61,8 +65,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)
@@ -153,13 +155,24 @@ blink::UserAgentMetadata GetCobaltUserAgentMetadata() {
   return metadata;
 }
 
+<<<<<<< HEAD
 CobaltContentBrowserClient::CobaltContentBrowserClient()
     : video_geometry_setter_service_(
           std::unique_ptr<cobalt::media::VideoGeometrySetterService,
                           base::OnTaskRunnerDeleter>(
               nullptr,
               base::OnTaskRunnerDeleter(nullptr))) {
   DETACH_FROM_THREAD(thread_checker_);
+=======
+CobaltContentBrowserClient::CobaltContentBrowserClient() {
+  COBALT_DETACH_FROM_THREAD(thread_checker_);
+#if BUILDFLAG(IS_STARBOARD)
+  // TODO: b/476434249 - Revisit if Cobalt supports multiple tabs/windows.
+  ui::PlatformWindowStarboard::SetWindowCreatedCallback(
+      base::BindRepeating(&CobaltContentBrowserClient::OnSbWindowCreated,
+                          weak_factory_.GetWeakPtr()));
+#endif  // BUILDFLAG(IS_STARBOARD)
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 }
 
 CobaltContentBrowserClient::~CobaltContentBrowserClient() = default;
@@ -340,6 +353,7 @@ void CobaltContentBrowserClient::RegisterBrowserInterfaceBindersForFrame(
       render_frame_host, map);
 }
 
+<<<<<<< HEAD
 void CobaltContentBrowserClient::CreateVideoGeometrySetterService() {
   DCHECK(!video_geometry_setter_service_);
   video_geometry_setter_service_ =
@@ -378,6 +392,9 @@ void CobaltContentBrowserClient::BindGpuHostReceiver(
 }
 
 bool CobaltContentBrowserClient::WillCreateURLLoaderFactory(
+=======
+void CobaltContentBrowserClient::WillCreateURLLoaderFactory(
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
     content::BrowserContext* browser_context,
     content::RenderFrameHost* frame,
     int render_process_id,

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;
 
@@ -94,11 +90,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.
@@ -128,11 +119,14 @@ class CobaltContentBrowserClient : public content::ShellContentBrowserClient {
   void DispatchFocus();
 
  private:
+<<<<<<< HEAD
   void CreateVideoGeometrySetterService();
+=======
+  void DispatchEvent(const std::string&, base::OnceClosure);
+  void OnSbWindowCreated(SbWindow window);
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 
   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,40 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/task/single_thread_task_runner.h"
+<<<<<<< HEAD
 #include "components/viz/service/display/starboard/overlay_strategy_underlay_starboard.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"
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 #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 +58,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,12 @@
 #include "media/base/media_switches.h"
 #include "media/base/renderer_factory.h"
 #include "media/mojo/clients/starboard/starboard_renderer_client_factory.h"
+<<<<<<< HEAD
 #include "media/starboard/bind_host_receiver_callback.h"
 #include "media/starboard/decoder_buffer_allocator.h"
 #include "mojo/public/cpp/bindings/generic_pending_receiver.h"
+=======
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 #include "starboard/media.h"
 #include "starboard/player.h"
 #include "third_party/blink/public/platform/web_string.h"
@@ -121,6 +124,7 @@ ::media::SupportedCodecs GetStarboardEmeSupportedCodecs() {
   return codecs;
 }
 
+<<<<<<< HEAD
 void BindHostReceiverWithValuation(mojo::GenericPendingReceiver receiver) {
   content::RenderThread::Get()->BindHostReceiver(std::move(receiver));
 }
@@ -252,13 +256,10 @@ ExperimentalFeatures ProcessH5vccSettings(
   return parsed;
 }
 
+=======
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 }  // 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 +364,15 @@ void CobaltContentRendererClient::RunScriptsAtDocumentStart(
   communication->RunScriptsAtDocumentStart();
 }
 
+<<<<<<< HEAD
 void CobaltContentRendererClient::BindHostReceiver(
     mojo::GenericPendingReceiver receiver) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   BindHostReceiverWithValuation(std::move(receiver));
 }
 
+=======
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 void CobaltContentRendererClient::GetStarboardRendererFactoryTraits(
     media::RendererFactoryTraits* renderer_factory_traits) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
@@ -392,11 +396,22 @@ void CobaltContentRendererClient::GetStarboardRendererFactoryTraits(
   renderer_factory_traits->experimental_features = experimental_features;
 
   renderer_factory_traits->viewport_size = viewport_size_;
+<<<<<<< HEAD
   // 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()));
+=======
+#if BUILDFLAG(IS_STARBOARD)
+  // Using base::Unretained(this) is safe here because
+  // CobaltContentRendererClient is a process-global singleton that outlives
+  // the media pipeline, and GetSbWindowHandle() only accesses an atomic
+  // member variable.
+  renderer_factory_traits->get_sb_window_handle_callback = base::BindRepeating(
+      &CobaltContentRendererClient::GetSbWindowHandle, base::Unretained(this));
+#endif  // BUILDFLAG(IS_STARBOARD)
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 }
 
 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,10 +51,14 @@ class CobaltContentRendererClient : public content::ContentRendererClient {
       ::media::RendererFactoryTraits* traits) override;
   void PostSandboxInitialized() override;
 
+<<<<<<< HEAD
   // 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_; }
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
 
  private:
   // Registers a custom content::AudioDeviceFactory

cobalt/testing/browser_tests/BUILD.gn

@@ -424,6 +424,53 @@ static_library("cobalt_shell_test_lib") {
   sources = [
     "common/shell_content_test_client.cc",
     "common/shell_content_test_client.h",
+<<<<<<< HEAD
+=======
+    "gpu/shell_content_gpu_test_client.cc",
+    "gpu/shell_content_gpu_test_client.h",
+    "renderer/shell_content_renderer_test_client.cc",
+    "renderer/shell_content_renderer_test_client.h",
+    "utility/shell_content_utility_client.cc",
+    "utility/shell_content_utility_client.h",
+  ]
+
+  deps = [
+    ":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",
+    "//components/prefs",
+    "//components/prefs:test_support",
+    "//components/variations",
+    "//components/variations/service",
+    "//components/viz/service",
+    "//services/network/public/cpp",
+  ]
+
+  if (use_aura) {
+    sources += [
+      "browser/shell_platform_test_data_aura.cc",
+      "browser/shell_platform_test_data_aura.h",
+    ]
+    deps += [ "//ui/aura" ]
+  }
+
+  if (shell_use_toolkit_views) {
+    deps += [ "//ui/views:test_support" ]
+  }
+}
+
+source_set("cobalt_browsertests_support") {
+  testonly = true
+  sources = [
+    "common/main_frame_counter_test_impl.cc",
+    "common/main_frame_counter_test_impl.h",
+    "common/power_monitor_test_impl.cc",
+    "common/power_monitor_test_impl.h",
+>>>>>>> d1376b13b0 (cobalt: Move VideoGeometrySetterService on gpu thread (#8962))
     "common/shell_test_switches.cc",
     "common/shell_test_switches.h",
     "shell/test_shell.cc",