cobalt: Move VideoGeometrySetterService on gpu thread

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)
@@ -160,12 +156,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.
@@ -366,40 +357,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.
@@ -144,13 +135,10 @@ class CobaltContentBrowserClient : public content::ShellContentBrowserClient {
   uint64_t GetSbWindowHandle() const { return cached_sb_window_; }
 
  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,8 @@ source_set("gpu") {
 
   deps = [
     "//base",
+    "//cobalt/media/service",
+    "//cobalt/media/service/mojom",
     "//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:

content/gpu/gpu_service_factory.cc

@@ -24,6 +24,11 @@
 #include "media/mojo/services/media_service_factory.h"  // nogncheck
 #endif  // BUILDFLAG(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 
+#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(
@@ -88,10 +93,24 @@ void GpuServiceFactory::RunMediaService(
     }
   }
 
+#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)
+
   media::GpuMojoMediaClientTraits traits(
       gpu_preferences_, gpu_workarounds_, gpu_feature_info_, gpu_info_,
       /*gpu_task_runner=*/task_runner_, android_overlay_factory_cb_,
-      media_gpu_channel_manager_);
+      media_gpu_channel_manager_
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+      ,
+      video_geometry_setter_service
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+      );
   auto gpu_client = media::GpuMojoMediaClient::Create(traits);
 
   using FactoryCallback =

content/public/gpu/content_gpu_client.cc

@@ -30,4 +30,11 @@ ContentGpuClient::GetGrContextOptionsProvider() {
 }
 #endif
 
+#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

@@ -13,6 +13,12 @@
 #include "gpu/command_buffer/service/shared_context_state.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;
@@ -61,6 +67,10 @@ class CONTENT_EXPORT ContentGpuClient {
   virtual const gpu::SharedContextState::GrContextOptionsProvider*
   GetGrContextOptionsProvider();
 #endif
+
+#if BUILDFLAG(USE_STARBOARD_MEDIA)
+  virtual cobalt::media::VideoGeometrySetterService* GetVideoGeometrySetterService();
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 };
 
 }  // namespace content