From 10d48512ebfe4a609106dfede497674b9537075a Mon Sep 17 00:00:00 2001 From: Bo-Rong Chen Date: Fri, 14 Feb 2025 22:55:28 -0800 Subject: [PATCH] Add VideoGeometrySetter Service for Cobalt (#4810) StarboardRender needs to be informed with the video geometry information from the display compositor. VideoGeometrySetter provides the IPC between the StarobardRenderer and the display compositor so the video geometry information can reach StarboardRenderer. This refers to https://chromium-review.googlesource.com/c/chromium/src/+/1799692 with the following modifications: - VideoGeometrySetterService is in Renderer thread, and it is exposed to ContentBrowserClient. - ContentBrowserClient binds VideoGeometrySetterService after receiving mojo::PendingRemote\ from compositing thread (viz) to Renderer thread. - ContentRendererClient creates a custom StarboardRendererFactory, which allows to bind |overlay_plane_id| for each StarboardRenderer with VideoGeometrySetterService. This CL also cleans up the old implementations for setting video bounds: https://github.com/youtube/cobalt/pull/4385, because it is unnecessary with this PR. b/391938746 --- cobalt/BUILD.gn | 3 +- cobalt/android/BUILD.gn | 3 +- cobalt/browser/BUILD.gn | 3 + .../browser/cobalt_content_browser_client.cc | 29 ++++- .../browser/cobalt_content_browser_client.h | 16 ++- .../cobalt_single_render_process_observer.cc | 56 +++++++++ .../cobalt_single_render_process_observer.h | 62 ++++++++++ cobalt/cobalt_main_delegate.cc | 6 + cobalt/cobalt_main_delegate.h | 3 + cobalt/gpu/BUILD.gn | 29 +++++ cobalt/gpu/cobalt_content_gpu_client.cc | 44 +++++++ cobalt/gpu/cobalt_content_gpu_client.h | 43 +++++++ cobalt/media/service/BUILD.gn | 35 +++--- .../service/mojom/video_geometry_setter.mojom | 44 +++---- .../service/video_geometry_setter_service.cc | 12 +- .../service/video_geometry_setter_service.h | 17 +-- cobalt/renderer/BUILD.gn | 3 + .../cobalt_content_renderer_client.cc | 110 ++++++++++++++---- .../renderer/cobalt_content_renderer_client.h | 49 +++++++- components/viz/service/BUILD.gn | 2 + .../overlay_strategy_underlay_starboard.cc | 30 +++++ .../overlay_strategy_underlay_starboard.h | 12 ++ content/renderer/media/media_factory.cc | 30 ++--- media/base/mock_filters.h | 3 - media/base/pipeline.h | 6 - media/base/pipeline_impl.cc | 18 --- media/base/pipeline_impl.h | 3 - media/base/renderer.cc | 13 --- media/base/renderer.h | 10 -- media/filters/pipeline_controller.cc | 7 -- media/filters/pipeline_controller.h | 3 - media/starboard/BUILD.gn | 2 + media/starboard/starboard_renderer.cc | 37 ++++-- media/starboard/starboard_renderer.h | 36 ++++-- media/starboard/starboard_renderer_factory.cc | 12 +- media/starboard/starboard_renderer_factory.h | 8 +- .../blink/public/platform/web_media_player.h | 6 - .../renderer/core/paint/video_painter.cc | 12 -- .../platform/media/web_media_player_impl.cc | 7 -- .../platform/media/web_media_player_impl.h | 8 -- 40 files changed, 609 insertions(+), 223 deletions(-) create mode 100644 cobalt/browser/cobalt_single_render_process_observer.cc create mode 100644 cobalt/browser/cobalt_single_render_process_observer.h create mode 100644 cobalt/gpu/BUILD.gn create mode 100644 cobalt/gpu/cobalt_content_gpu_client.cc create mode 100644 cobalt/gpu/cobalt_content_gpu_client.h diff --git a/cobalt/BUILD.gn b/cobalt/BUILD.gn index ab3448b75304..c3add3b22be9 100644 --- a/cobalt/BUILD.gn +++ b/cobalt/BUILD.gn @@ -47,7 +47,8 @@ if (!is_android) { deps = [ "//cobalt/browser", "//cobalt/browser:switches", - "//cobalt/renderer:renderer", + "//cobalt/gpu", + "//cobalt/renderer", "//content/public/app", "//content/shell:content_shell_app", "//content/shell:content_shell_lib", diff --git a/cobalt/android/BUILD.gn b/cobalt/android/BUILD.gn index dffaa4be3b8f..00adace0a65c 100644 --- a/cobalt/android/BUILD.gn +++ b/cobalt/android/BUILD.gn @@ -272,7 +272,8 @@ shared_library("libcobalt_content_shell_content_view") { deps = [ ":content_shell_jni_headers", "//cobalt/browser", - "//cobalt/renderer:renderer", + "//cobalt/gpu", + "//cobalt/renderer", # TODO: what can be removed in the dependencies? "//components/crash/content/browser", diff --git a/cobalt/browser/BUILD.gn b/cobalt/browser/BUILD.gn index 0756f8155c0e..f1ca24a7a0bc 100644 --- a/cobalt/browser/BUILD.gn +++ b/cobalt/browser/BUILD.gn @@ -24,6 +24,8 @@ source_set("browser") { "cobalt_browser_interface_binders.h", "cobalt_content_browser_client.cc", "cobalt_content_browser_client.h", + "cobalt_single_render_process_observer.cc", + "cobalt_single_render_process_observer.h", "cobalt_web_contents_observer.cc", "cobalt_web_contents_observer.h", ] @@ -42,6 +44,7 @@ source_set("browser") { "//cobalt/browser/h5vcc_runtime/public/mojom", "//cobalt/browser/h5vcc_system", "//cobalt/browser/h5vcc_system/public/mojom", + "//cobalt/media/service/mojom", "//cobalt/user_agent", "//components/js_injection/browser:browser", "//content/public/browser", diff --git a/cobalt/browser/cobalt_content_browser_client.cc b/cobalt/browser/cobalt_content_browser_client.cc index 3fb531710c83..b7398609dc74 100644 --- a/cobalt/browser/cobalt_content_browser_client.cc +++ b/cobalt/browser/cobalt_content_browser_client.cc @@ -17,15 +17,18 @@ #include #include "cobalt/browser/cobalt_browser_interface_binders.h" +#include "cobalt/browser/cobalt_web_contents_observer.h" +#include "cobalt/media/service/mojom/video_geometry_setter.mojom.h" #include "cobalt/user_agent/user_agent_platform_info.h" +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/render_process_host.h" +#include "content/public/browser/web_contents.h" #include "content/public/common/user_agent.h" // TODO(b/390021478): Remove this include when CobaltBrowserMainParts stops // being a ShellBrowserMainParts. #include "content/shell/browser/shell_browser_main_parts.h" #include "third_party/blink/public/common/web_preferences/web_preferences.h" -#include "base/logging.h" - #if BUILDFLAG(IS_ANDROIDTV) #include "cobalt/browser/android/mojo/cobalt_interface_registrar_android.h" #endif @@ -101,9 +104,13 @@ blink::UserAgentMetadata GetCobaltUserAgentMetadata() { } CobaltContentBrowserClient::CobaltContentBrowserClient() = default; - CobaltContentBrowserClient::~CobaltContentBrowserClient() = default; +void CobaltContentBrowserClient::RenderProcessWillLaunch( + content::RenderProcessHost* host) { + single_render_process_observer_.UpdateRenderProcessHost(host); +} + std::unique_ptr CobaltContentBrowserClient::CreateBrowserMainParts( bool /* is_integration_test */) { @@ -138,10 +145,12 @@ void CobaltContentBrowserClient::OverrideWebkitPrefs( #endif // !defined(COBALT_IS_RELEASE_BUILD) content::ShellContentBrowserClient::OverrideWebkitPrefs(web_contents, prefs); } + void CobaltContentBrowserClient::OnWebContentsCreated( content::WebContents* web_contents) { web_contents_observer_.reset(new CobaltWebContentsObserver(web_contents)); } + void CobaltContentBrowserClient::RegisterBrowserInterfaceBindersForFrame( content::RenderFrameHost* render_frame_host, mojo::BinderMapWithContext* map) { @@ -150,4 +159,18 @@ void CobaltContentBrowserClient::RegisterBrowserInterfaceBindersForFrame( render_frame_host, map); } +void CobaltContentBrowserClient::BindGpuHostReceiver( + mojo::GenericPendingReceiver receiver) { + DCHECK_CURRENTLY_ON(content::BrowserThread::UI); + if (auto r = receiver.As()) { + const auto renderer_process_id = + single_render_process_observer_.renderer_id(); + content::RenderProcessHost* host = + content::RenderProcessHost::FromID(renderer_process_id); + if (host) { + host->BindReceiver(std::move(r)); + } + } +} + } // namespace cobalt diff --git a/cobalt/browser/cobalt_content_browser_client.h b/cobalt/browser/cobalt_content_browser_client.h index 554db7406bde..0f47ca8f456a 100644 --- a/cobalt/browser/cobalt_content_browser_client.h +++ b/cobalt/browser/cobalt_content_browser_client.h @@ -15,13 +15,15 @@ #ifndef COBALT_BROWSER_COBALT_CONTENT_BROWSER_CLIENT_H_ #define COBALT_BROWSER_COBALT_CONTENT_BROWSER_CLIENT_H_ -#include "cobalt/browser/cobalt_web_contents_observer.h" -#include "content/public/browser/web_contents.h" +#include "cobalt/browser/cobalt_single_render_process_observer.h" #include "content/shell/browser/shell_content_browser_client.h" +#include "mojo/public/cpp/bindings/pending_receiver.h" namespace content { class BrowserMainParts; class RenderFrameHost; +class RenderProcessHost; +class WebContents; } // namespace content namespace mojo { @@ -31,6 +33,8 @@ class BinderMapWithContext; namespace cobalt { +class CobaltWebContentsObserver; + // This class allows Cobalt to inject specific logic in the business of the // browser (i.e. of Content), for example for startup or to override the UA. // TODO(b/390021478): In time CobaltContentBrowserClient should derive and @@ -39,11 +43,17 @@ namespace cobalt { class CobaltContentBrowserClient : public content::ShellContentBrowserClient { public: CobaltContentBrowserClient(); + + CobaltContentBrowserClient(const CobaltContentBrowserClient&) = delete; + CobaltContentBrowserClient& operator=(const CobaltContentBrowserClient&) = + delete; + ~CobaltContentBrowserClient() override; // ShellContentBrowserClient overrides. std::unique_ptr CreateBrowserMainParts( bool is_integration_test) override; + void RenderProcessWillLaunch(content::RenderProcessHost* host) override; std::string GetUserAgent() override; std::string GetFullUserAgent() override; std::string GetReducedUserAgent() override; @@ -55,9 +65,11 @@ class CobaltContentBrowserClient : public content::ShellContentBrowserClient { content::RenderFrameHost* render_frame_host, mojo::BinderMapWithContext* binder_map) override; + void BindGpuHostReceiver(mojo::GenericPendingReceiver receiver) override; private: std::unique_ptr web_contents_observer_; + CobaltSingleRenderProcessObserver single_render_process_observer_; }; } // namespace cobalt diff --git a/cobalt/browser/cobalt_single_render_process_observer.cc b/cobalt/browser/cobalt_single_render_process_observer.cc new file mode 100644 index 000000000000..a23f8dc213c8 --- /dev/null +++ b/cobalt/browser/cobalt_single_render_process_observer.cc @@ -0,0 +1,56 @@ +// Copyright 2025 The Cobalt Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "cobalt/browser/cobalt_single_render_process_observer.h" + +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/render_process_host.h" +#include "content/public/browser/render_process_host_observer.h" + +namespace cobalt { + +CobaltSingleRenderProcessObserver::CobaltSingleRenderProcessObserver() = + default; +CobaltSingleRenderProcessObserver::~CobaltSingleRenderProcessObserver() = + default; + +void CobaltSingleRenderProcessObserver::UpdateRenderProcessHost( + content::RenderProcessHost* host) { + DCHECK_CURRENTLY_ON(content::BrowserThread::UI); + DCHECK_EQ(renderer_id_, content::kInvalidChildProcessUniqueId) + << "Cobalt should only have one renderer."; + renderer_id_ = host->GetID(); + process_observation_.Reset(); + if (auto* rph = content::RenderProcessHost::FromID(renderer_id_)) { + process_observation_.Observe(rph); + } +} + +void CobaltSingleRenderProcessObserver::RenderProcessExited( + content::RenderProcessHost* host, + const content::ChildProcessTerminationInfo& info) { + DCHECK_CURRENTLY_ON(content::BrowserThread::UI); + NOTIMPLEMENTED() + << "CobaltSingleRenderProcessObserver only supports single process."; +} + +void CobaltSingleRenderProcessObserver::InProcessRendererExiting( + content::RenderProcessHost* host) { + DCHECK_CURRENTLY_ON(content::BrowserThread::UI); + DCHECK_EQ(host->GetID(), renderer_id_) + << "Cobalt should only have one renderer."; + process_observation_.Reset(); +} + +} // namespace cobalt diff --git a/cobalt/browser/cobalt_single_render_process_observer.h b/cobalt/browser/cobalt_single_render_process_observer.h new file mode 100644 index 000000000000..e3b1e76ababb --- /dev/null +++ b/cobalt/browser/cobalt_single_render_process_observer.h @@ -0,0 +1,62 @@ +// Copyright 2025 The Cobalt Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef COBALT_BROWSER_COBALT_SINGLE_RENDER_PROCESS_OBSERVER_H_ +#define COBALT_BROWSER_COBALT_SINGLE_RENDER_PROCESS_OBSERVER_H_ + +#include "base/memory/weak_ptr.h" +#include "base/scoped_observation.h" +#include "content/public/browser/render_process_host_observer.h" +#include "content/public/common/content_constants.h" + +namespace content { +class RenderProcessHost; +class RenderProcessHostObserver; +} // namespace content + +namespace cobalt { + +// This class keeps track of a Renderer ID during its lifetime. It must +// be used on the UI thread, and can observe one such Renderer. +class CobaltSingleRenderProcessObserver + : public content::RenderProcessHostObserver { + public: + CobaltSingleRenderProcessObserver(); + + CobaltSingleRenderProcessObserver(const CobaltSingleRenderProcessObserver&) = + delete; + CobaltSingleRenderProcessObserver& operator=( + const CobaltSingleRenderProcessObserver&) = delete; + + ~CobaltSingleRenderProcessObserver() override; + + void UpdateRenderProcessHost(content::RenderProcessHost* host); + int renderer_id() const { return renderer_id_; } + + // content::RenderProcessHostObserver implementation + void RenderProcessExited( + content::RenderProcessHost* host, + const content::ChildProcessTerminationInfo& info) override; + void InProcessRendererExiting(content::RenderProcessHost* host) override; + + private: + int renderer_id_ = content::kInvalidChildProcessUniqueId; + base::ScopedObservation + process_observation_{this}; +}; + +} // namespace cobalt + +#endif // COBALT_BROWSER_COBALT_SINGLE_RENDER_PROCESS_OBSERVER_H_ diff --git a/cobalt/cobalt_main_delegate.cc b/cobalt/cobalt_main_delegate.cc index 47d995ba6a81..73d9e43edebc 100644 --- a/cobalt/cobalt_main_delegate.cc +++ b/cobalt/cobalt_main_delegate.cc @@ -17,6 +17,7 @@ #include "base/process/current_process.h" #include "base/trace_event/trace_log.h" #include "cobalt/browser/cobalt_content_browser_client.h" +#include "cobalt/gpu/cobalt_content_gpu_client.h" #include "cobalt/renderer/cobalt_content_renderer_client.h" #include "content/common/content_constants_internal.h" #include "content/public/browser/render_frame_host.h" @@ -34,6 +35,11 @@ CobaltMainDelegate::CreateContentBrowserClient() { return browser_client_.get(); } +content::ContentGpuClient* CobaltMainDelegate::CreateContentGpuClient() { + gpu_client_ = std::make_unique(); + return gpu_client_.get(); +} + content::ContentRendererClient* CobaltMainDelegate::CreateContentRendererClient() { renderer_client_ = std::make_unique(); diff --git a/cobalt/cobalt_main_delegate.h b/cobalt/cobalt_main_delegate.h index f1b1d8f3f4e4..a1bffdd36302 100644 --- a/cobalt/cobalt_main_delegate.h +++ b/cobalt/cobalt_main_delegate.h @@ -16,6 +16,7 @@ #define COBALT_COBALT_MAIN_DELEGATE_H_ #include "build/build_config.h" +#include "cobalt/gpu/cobalt_content_gpu_client.h" #include "cobalt/renderer/cobalt_content_renderer_client.h" #include "content/public/browser/browser_main_runner.h" #include "content/shell/app/shell_main_delegate.h" @@ -31,6 +32,7 @@ class CobaltMainDelegate : public content::ShellMainDelegate { // ContentMainDelegate implementation: content::ContentBrowserClient* CreateContentBrowserClient() override; + content::ContentGpuClient* CreateContentGpuClient() override; content::ContentRendererClient* CreateContentRendererClient() override; absl::optional PostEarlyInitialization(InvokedIn invoked_in) override; @@ -48,6 +50,7 @@ class CobaltMainDelegate : public content::ShellMainDelegate { private: std::unique_ptr main_runner_; + std::unique_ptr gpu_client_; std::unique_ptr renderer_client_; }; diff --git a/cobalt/gpu/BUILD.gn b/cobalt/gpu/BUILD.gn new file mode 100644 index 000000000000..e4be020efd77 --- /dev/null +++ b/cobalt/gpu/BUILD.gn @@ -0,0 +1,29 @@ +# Copyright 2025 The Cobalt Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +source_set("gpu") { + sources = [ + "cobalt_content_gpu_client.cc", + "cobalt_content_gpu_client.h", + ] + + deps = [ + "//base", + "//cobalt/media/service/mojom", + "//components/viz/common", + "//components/viz/service", + "//content/public/child", + "//content/public/gpu", + ] +} diff --git a/cobalt/gpu/cobalt_content_gpu_client.cc b/cobalt/gpu/cobalt_content_gpu_client.cc new file mode 100644 index 000000000000..fc69a957709a --- /dev/null +++ b/cobalt/gpu/cobalt_content_gpu_client.cc @@ -0,0 +1,44 @@ +// Copyright 2025 The Cobalt Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "cobalt/gpu/cobalt_content_gpu_client.h" + +#include "base/memory/ptr_util.h" +#include "base/task/single_thread_task_runner.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() = default; + +void CobaltContentGpuClient::PostCompositorThreadCreated( + base::SingleThreadTaskRunner* task_runner) { + // 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 + video_geometry_setter; + content::ChildThread::Get()->BindHostReceiver( + video_geometry_setter.InitWithNewPipeAndPassReceiver()); + + task_runner->PostTask( + FROM_HERE, + base::BindOnce( + &viz::OverlayStrategyUnderlayStarboard::ConnectVideoGeometrySetter, + std::move(video_geometry_setter))); +} + +} // namespace cobalt diff --git a/cobalt/gpu/cobalt_content_gpu_client.h b/cobalt/gpu/cobalt_content_gpu_client.h new file mode 100644 index 000000000000..a1071a9938e5 --- /dev/null +++ b/cobalt/gpu/cobalt_content_gpu_client.h @@ -0,0 +1,43 @@ +// Copyright 2025 The Cobalt Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef COBALT_GPU_COBALT_CONTENT_GPU_CLIENT_H_ +#define COBALT_GPU_COBALT_CONTENT_GPU_CLIENT_H_ + +#include + +#include "base/task/single_thread_task_runner.h" +#include "content/public/gpu/content_gpu_client.h" + +namespace cobalt { + +// 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 { + public: + CobaltContentGpuClient(); + + CobaltContentGpuClient(const CobaltContentGpuClient&) = delete; + CobaltContentGpuClient& operator=(const CobaltContentGpuClient&) = delete; + + ~CobaltContentGpuClient() override; + + // content::ContentGpuClient: + void PostCompositorThreadCreated( + base::SingleThreadTaskRunner* task_runner) override; +}; + +} // namespace cobalt + +#endif // COBALT_GPU_COBALT_CONTENT_GPU_CLIENT_H_ diff --git a/cobalt/media/service/BUILD.gn b/cobalt/media/service/BUILD.gn index f83bc062bc5f..539817f85797 100644 --- a/cobalt/media/service/BUILD.gn +++ b/cobalt/media/service/BUILD.gn @@ -1,33 +1,32 @@ -# Copyright 2015 The Chromium Authors -# Use of this source code is governed by a BSD-style license that can be -# found in the LICENSE file. +# Copyright 2025 The Cobalt Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. -import("//chromecast/chromecast.gni") - -cast_source_set("service") { +source_set("service") { sources = [ - "cast_mojo_media_client.cc", - "cast_mojo_media_client.h", - "cast_renderer.cc", - "cast_renderer.h", "video_geometry_setter_service.cc", "video_geometry_setter_service.h", ] public_deps = [ - "//media/mojo/mojom", - "//media/mojo/services", + "//mojo/public/cpp/bindings", + "//mojo/public/mojom/base", "//services/service_manager/public/cpp", ] deps = [ "//base", - "//chromecast/base", - "//chromecast/common/mojom", - "//chromecast/external_mojo/external_service_support:external_service", - "//chromecast/media", - "//chromecast/media/service/mojom", - "//media", + "//cobalt/media/service/mojom", "//ui/gfx", "//ui/gfx/geometry", ] diff --git a/cobalt/media/service/mojom/video_geometry_setter.mojom b/cobalt/media/service/mojom/video_geometry_setter.mojom index d0ed78ea2062..aecef69d8c4f 100644 --- a/cobalt/media/service/mojom/video_geometry_setter.mojom +++ b/cobalt/media/service/mojom/video_geometry_setter.mojom @@ -2,23 +2,29 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -module chromecast.media.mojom; +module cobalt.media.mojom; import "mojo/public/mojom/base/unguessable_token.mojom"; import "ui/gfx/geometry/mojom/geometry.mojom"; import "ui/gfx/mojom/overlay_transform.mojom"; -// The purpose of VideoGeometrySetterService is to provide a brokerage between -// chromecast::media::CastRenderers and viz::OverlayStrategyUnderlayCast, in a -// situation where multiple instances of CastRenderers possibly run within -// different instances of MediaService. When OverlayStrategyUnderlayCast decides -// to set video geometry on a certain CastRenderer, it relies on -// VideoGeometrySetterService to pass the geometry information to the right CastRenderer. +// This file defines two mojo interfaces: +// - VideoGeometryChangeClient to be informed of changes in the presented video +// geometry (for a given |overlay_plane_id|). +// - VideoGeometrySetter that can be used by a source of geometry changes (for +// a given |overlay_plane_id|) to inform a remote observer. +// A broker (e.g., VideoGeometrySetterService) is implemented to connect the +// geometry update events (i.e., from VideoGeometrySetter::SetVideoGeometry() +// all the way to a VideoGeometryChangeClient::OnVideoGeometryChange()). +// A third mojo interface, VideoGeometryChangeSubscriber, is also defined to +// allow VideoGeometryChangeClients to connect to the broker. +// Note that there can be multiple VideoGeometryChangeClients (usually +// StarboardRenderers in a single Renderer process) and VideoGeometrySetters +// (usually OverlayStrategyUnderlayStarboard in the GPU/Viz process, compositor +// thread). The broker is expected to live in the only Cobalt Renderer process. -// CastRenderer must implement this interface. -// CastRenderer is used in multiple places but right now only CastRenderers -// running within ::media::MediaService, on browser process, are using -// video geometry setter service. +// Interface to inform clients (e.g., StarboardRenderer) of changes of the +// presented geometry of its video feed. interface VideoGeometryChangeClient { // Implementation of VideoGeometryChangeClient sets the video geometry on // itself. @@ -29,10 +35,8 @@ interface VideoGeometryChangeClient { // A single instance of VideoGeometrySetterService provides both the interface // and VideoGeometryChangeSubscriber and VideoGeometrySetter. -// To be used by a VideoGeometryChangeClient(i.e., a CastRenderer). -// CastRenders running in browser process can subscribe for the video geometry -// information, that would be sent from compositor, which is being migrated -// from browser process to GPU process. +// Interface to register a VideoGeometryChangeClient (e.g., a StarboardRenderer) +// to listen to geometry changes for a give |overlay_plane_id|. interface VideoGeometryChangeSubscriber { // A VideoGeometryChangeClient informs VideoGeometrySetterService its existence. // |overlay_plane_id| identifies the VideoGeometryChangeClient, @@ -43,14 +47,12 @@ interface VideoGeometryChangeSubscriber { pending_remote client_pending_remote) => (); }; -// To be used by OverlayStrategyUnderlayCast, which is part of compositor that -// is being migrated to GPU process. Within GPU process -// OverlayStrategyUnderlayCast cannot access CastRenderer any more, so it -// uses VideoGeometrySetter interface to send out the geometry information to -// VideoGeometrySetter, which then forward it to the right CastRenderer. +// VideoGeometrySetter is the interface used by some entity inside the Viz/GPU +// process compositor (e.g., OverlayStrategyUnderlayStarboard) to report changes +// in the geometry of the overlay. interface VideoGeometrySetter { // Informs VideoGeometrySetterService the video geometry information and the -// target CastRenderer, identified by |overlay_plane_id|, that the geometry is +// target StarboardRenderer, identified by |overlay_plane_id|, that the geometry is // set to. SetVideoGeometry(gfx.mojom.RectF rect_f, gfx.mojom.OverlayTransform transform, diff --git a/cobalt/media/service/video_geometry_setter_service.cc b/cobalt/media/service/video_geometry_setter_service.cc index 079142057db0..fbee32889514 100644 --- a/cobalt/media/service/video_geometry_setter_service.cc +++ b/cobalt/media/service/video_geometry_setter_service.cc @@ -16,7 +16,7 @@ return; \ } -namespace chromecast { +namespace cobalt { namespace media { VideoGeometrySetterService::VideoGeometrySetterService() @@ -35,6 +35,7 @@ void VideoGeometrySetterService::GetVideoGeometryChangeSubscriber( video_geometry_change_subscriber_receivers_.Add(this, std::move(pending_receiver)); } + void VideoGeometrySetterService::GetVideoGeometrySetter( mojo::PendingReceiver pending_receiver) { MAKE_SURE_ON_SEQUENCE(GetVideoGeometrySetter, std::move(pending_receiver)); @@ -45,6 +46,13 @@ void VideoGeometrySetterService::GetVideoGeometrySetter( video_geometry_setter_receiver_.Bind(std::move(pending_receiver)); } +base::RepeatingCallback)> +VideoGeometrySetterService::GetBindCallback() { + return base::BindRepeating( + &VideoGeometrySetterService::GetVideoGeometrySetter, + weak_factory_.GetWeakPtr()); +} + void VideoGeometrySetterService::SubscribeToVideoGeometryChange( const base::UnguessableToken& overlay_plane_id, mojo::PendingRemote client_pending_remote, @@ -86,4 +94,4 @@ void VideoGeometrySetterService::OnVideoGeometryChangeClientGone( } } // namespace media -} // namespace chromecast +} // namespace cobalt diff --git a/cobalt/media/service/video_geometry_setter_service.h b/cobalt/media/service/video_geometry_setter_service.h index 0a7cdc6e5707..dc3a965dd8ad 100644 --- a/cobalt/media/service/video_geometry_setter_service.h +++ b/cobalt/media/service/video_geometry_setter_service.h @@ -2,15 +2,15 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#ifndef CHROMECAST_MEDIA_SERVICE_VIDEO_GEOMETRY_SETTER_SERVICE_H_ -#define CHROMECAST_MEDIA_SERVICE_VIDEO_GEOMETRY_SETTER_SERVICE_H_ +#ifndef COBALT_MEDIA_SERVICE_VIDEO_GEOMETRY_SETTER_SERVICE_H_ +#define COBALT_MEDIA_SERVICE_VIDEO_GEOMETRY_SETTER_SERVICE_H_ #include "base/containers/flat_map.h" #include "base/functional/bind.h" #include "base/memory/scoped_refptr.h" #include "base/memory/weak_ptr.h" #include "base/unguessable_token.h" -#include "chromecast/media/service/mojom/video_geometry_setter.mojom.h" +#include "cobalt/media/service/mojom/video_geometry_setter.mojom.h" #include "mojo/public/cpp/bindings/pending_receiver.h" #include "mojo/public/cpp/bindings/pending_remote.h" #include "mojo/public/cpp/bindings/receiver.h" @@ -20,7 +20,7 @@ namespace base { class SequencedTaskRunner; } // namespace base -namespace chromecast { +namespace cobalt { namespace media { // This service runs and destructs on the sequence where it's constructed, but @@ -42,6 +42,9 @@ class VideoGeometrySetterService final pending_receiver); void GetVideoGeometrySetter( mojo::PendingReceiver pending_receiver); + base::RepeatingCallback< + void(mojo::PendingReceiver)> + GetBindCallback(); private: // mojom::VideoGeometryChangeSubscriber implementation. @@ -70,10 +73,10 @@ class VideoGeometrySetterService final mojo::Receiver video_geometry_setter_receiver_{ this}; - base::WeakPtrFactory weak_factory_; + base::WeakPtrFactory weak_factory_{this}; }; } // namespace media -} // namespace chromecast +} // namespace cobalt -#endif // CHROMECAST_MEDIA_SERVICE_VIDEO_GEOMETRY_SETTER_SERVICE_H_ +#endif // COBALT_MEDIA_SERVICE_VIDEO_GEOMETRY_SETTER_SERVICE_H_ diff --git a/cobalt/renderer/BUILD.gn b/cobalt/renderer/BUILD.gn index 19f8a86bdbf4..9ed68187c340 100644 --- a/cobalt/renderer/BUILD.gn +++ b/cobalt/renderer/BUILD.gn @@ -22,6 +22,8 @@ source_set("renderer") { deps = [ "//cobalt/media/audio:webaudio", + "//cobalt/media/service", + "//cobalt/media/service/mojom", "//components/cdm/renderer", "//components/js_injection/renderer:renderer", "//components/network_hints/renderer", @@ -29,6 +31,7 @@ source_set("renderer") { "//content/public/common", "//content/public/renderer", "//content/test:content_test_mojo_bindings", + "//media", "//media/mojo:buildflags", "//starboard:starboard_headers_only", "//v8", diff --git a/cobalt/renderer/cobalt_content_renderer_client.cc b/cobalt/renderer/cobalt_content_renderer_client.cc index 9e7287852d41..66ded77aa79d 100644 --- a/cobalt/renderer/cobalt_content_renderer_client.cc +++ b/cobalt/renderer/cobalt_content_renderer_client.cc @@ -6,9 +6,23 @@ #include +#include "base/time/time.h" +#include "cobalt/media/service/mojom/video_geometry_setter.mojom.h" +#include "cobalt/media/service/video_geometry_setter_service.h" #include "cobalt/renderer/cobalt_render_frame_observer.h" #include "components/cdm/renderer/widevine_key_system_info.h" +#include "components/js_injection/renderer/js_communication.h" +#include "content/public/renderer/render_frame.h" +#include "content/public/renderer/render_thread.h" +#include "media/base/decoder_factory.h" +#include "media/base/media_log.h" +#include "media/base/renderer_factory.h" +#include "media/renderers/video_overlay_factory.h" +#include "media/starboard/starboard_renderer_factory.h" +#include "media/video/gpu_video_accelerator_factories.h" +#include "mojo/public/cpp/bindings/binder_map.h" #include "starboard/media.h" +#include "starboard/player.h" namespace cobalt { @@ -19,14 +33,14 @@ namespace { // gets lost with hardcoded MIME string. This can sometimes cause issues. For // example, vp9 profile 2 indicates hdr support, so an implementation accepts // "codecs=vp9" may reject "codecs=vp9.2". -std::string GetMimeFromVideoType(const media::VideoType& type) { +std::string GetMimeFromVideoType(const ::media::VideoType& type) { // The MIME string is for very basic video codec supportability check. switch (type.codec) { - case media::VideoCodec::kH264: + case ::media::VideoCodec::kH264: return "video/mp4; codecs=\"avc1.4d4015\""; - case media::VideoCodec::kVP9: + case ::media::VideoCodec::kVP9: return "video/webm; codecs=\"vp9\""; - case media::VideoCodec::kAV1: + case ::media::VideoCodec::kAV1: return "video/mp4; codecs=\"av01.0.08M.08\""; default: return ""; @@ -35,16 +49,16 @@ std::string GetMimeFromVideoType(const media::VideoType& type) { // TODO(b/376542844): Eliminate the usage of hardcoded MIME string once we // support to query codec capabilities with configs. -std::string GetMimeFromAudioType(const media::AudioType& type) { +std::string GetMimeFromAudioType(const ::media::AudioType& type) { // The MIME string is for very basic audio codec supportability check. switch (type.codec) { - case media::AudioCodec::kAAC: + case ::media::AudioCodec::kAAC: return "audio/mp4; codecs=\"mp4a.40.2\""; - case media::AudioCodec::kAC3: + case ::media::AudioCodec::kAC3: return "audio/mp4; codecs=\"ac-3\""; - case media::AudioCodec::kEAC3: + case ::media::AudioCodec::kEAC3: return "audio/mp4; codecs=\"ec-3\""; - case media::AudioCodec::kOpus: + case ::media::AudioCodec::kOpus: return "audio/webm; codecs=\"opus\""; // TODO(b/375232937): Support IAMF default: @@ -52,8 +66,8 @@ std::string GetMimeFromAudioType(const media::AudioType& type) { } } -media::SupportedCodecs GetStarboardEmeSupportedCodecs() { - media::SupportedCodecs codecs = +::media::SupportedCodecs GetStarboardEmeSupportedCodecs() { + ::media::SupportedCodecs codecs = ::media::EME_CODEC_AAC | ::media::EME_CODEC_AVC1 | ::media::EME_CODEC_VP9_PROFILE0 | ::media::EME_CODEC_VP9_PROFILE2 | ::media::EME_CODEC_VP8 | ::media::EME_CODEC_OPUS | @@ -67,8 +81,35 @@ media::SupportedCodecs GetStarboardEmeSupportedCodecs() { } // namespace -CobaltContentRendererClient::CobaltContentRendererClient() {} -CobaltContentRendererClient::~CobaltContentRendererClient() {} +CobaltContentRendererClient::CobaltContentRendererClient() + : video_geometry_setter_service_( + std::unique_ptr( + nullptr, + base::OnTaskRunnerDeleter(nullptr))) { + DCHECK(content::RenderThread::IsMainThread()); +} + +CobaltContentRendererClient::~CobaltContentRendererClient() = default; + +void CobaltContentRendererClient::RenderThreadStarted() { + if (!video_geometry_setter_service_) { + video_geometry_setter_service_ = + std::unique_ptr( + new media::VideoGeometrySetterService, + base::OnTaskRunnerDeleter( + base::SingleThreadTaskRunner::GetCurrentDefault())); + } +} + +void CobaltContentRendererClient::ExposeInterfacesToBrowser( + mojo::BinderMap* binders) { + DCHECK(video_geometry_setter_service_); + binders->Add( + video_geometry_setter_service_->GetBindCallback(), + base::SingleThreadTaskRunner::GetCurrentDefault()); +} void CobaltContentRendererClient::RenderFrameCreated( content::RenderFrame* render_frame) { @@ -78,15 +119,15 @@ void CobaltContentRendererClient::RenderFrameCreated( #if BUILDFLAG(IS_ANDROID) void AddStarboardCmaKeySystems(::media::KeySystemInfos* key_system_infos) { - media::SupportedCodecs codecs = GetStarboardEmeSupportedCodecs(); + ::media::SupportedCodecs codecs = GetStarboardEmeSupportedCodecs(); using Robustness = cdm::WidevineKeySystemInfo::Robustness; - const base::flat_set kEncryptionSchemes = { - media::EncryptionScheme::kCenc, media::EncryptionScheme::kCbcs}; + const base::flat_set<::media::EncryptionScheme> kEncryptionSchemes = { + ::media::EncryptionScheme::kCenc, ::media::EncryptionScheme::kCbcs}; - const base::flat_set kSessionTypes = { - media::CdmSessionType::kTemporary}; + const base::flat_set<::media::CdmSessionType> kSessionTypes = { + ::media::CdmSessionType::kTemporary}; key_system_infos->emplace_back(new cdm::WidevineKeySystemInfo( codecs, // Regular codecs. @@ -97,14 +138,14 @@ void AddStarboardCmaKeySystems(::media::KeySystemInfos* key_system_infos) { kSessionTypes, // Hardware secure session types. Robustness::HW_SECURE_CRYPTO, // Max audio robustness. Robustness::HW_SECURE_ALL, // Max video robustness. - media::EmeFeatureSupport::ALWAYS_ENABLED, // Persistent state. - media::EmeFeatureSupport::ALWAYS_ENABLED)); // Distinctive identifier. + ::media::EmeFeatureSupport::ALWAYS_ENABLED, // Persistent state. + ::media::EmeFeatureSupport::ALWAYS_ENABLED)); // Distinctive identifier. } #endif void CobaltContentRendererClient::GetSupportedKeySystems( - media::GetSupportedKeySystemsCB cb) { - media::KeySystemInfos key_systems; + ::media::GetSupportedKeySystemsCB cb) { + ::media::KeySystemInfos key_systems; #if BUILDFLAG(IS_ANDROID) AddStarboardCmaKeySystems(&key_systems); std::move(cb).Run(std::move(key_systems)); @@ -112,7 +153,7 @@ void CobaltContentRendererClient::GetSupportedKeySystems( } bool CobaltContentRendererClient::IsSupportedAudioType( - const media::AudioType& type) { + const ::media::AudioType& type) { std::string mime = GetMimeFromAudioType(type); SbMediaSupportType support_type = kSbMediaSupportTypeNotSupported; if (!mime.empty()) { @@ -125,7 +166,7 @@ bool CobaltContentRendererClient::IsSupportedAudioType( } bool CobaltContentRendererClient::IsSupportedVideoType( - const media::VideoType& type) { + const ::media::VideoType& type) { std::string mime = GetMimeFromVideoType(type); SbMediaSupportType support_type = kSbMediaSupportTypeNotSupported; if (!mime.empty()) { @@ -144,4 +185,25 @@ void CobaltContentRendererClient::RunScriptsAtDocumentStart( communication->RunScriptsAtDocumentStart(); } +std::unique_ptr<::media::RendererFactory> +CobaltContentRendererClient::GetBaseRendererFactory( + content::RenderFrame* /* render_frame */, + ::media::MediaLog* media_log, + ::media::DecoderFactory* /* decoder_factory */, + base::RepeatingCallback<::media::GpuVideoAcceleratorFactories*()> + /* get_gpu_factories_cb */) { + // TODO(b/394368542): Add Content API to create StarboardRenderer. + auto overlay_factory = std::make_unique<::media::VideoOverlayFactory>(); + base::TimeDelta audio_write_duration_local = + base::Microseconds(kSbPlayerWriteDurationLocal); + base::TimeDelta audio_write_duration_remote = + base::Microseconds(kSbPlayerWriteDurationRemote); + DCHECK(video_geometry_setter_service_); + return std::make_unique<::media::StarboardRendererFactory>( + media_log, std::move(overlay_factory), + // TODO(b/383327725) - Cobalt: Inject these values from the web app. + audio_write_duration_local, audio_write_duration_remote, + video_geometry_setter_service_.get()); +} + } // namespace cobalt diff --git a/cobalt/renderer/cobalt_content_renderer_client.h b/cobalt/renderer/cobalt_content_renderer_client.h index 1d19321ed5fa..848f7ca53d62 100644 --- a/cobalt/renderer/cobalt_content_renderer_client.h +++ b/cobalt/renderer/cobalt_content_renderer_client.h @@ -5,29 +5,66 @@ #ifndef COBALT_RENDERER_COBALT_CONTENT_RENDERER_CLIENT_H_ #define COBALT_RENDERER_COBALT_CONTENT_RENDERER_CLIENT_H_ +#include "base/functional/callback.h" +#include "base/task/sequenced_task_runner.h" #include "cobalt/media/audio/cobalt_audio_device_factory.h" -#include "components/js_injection/renderer/js_communication.h" #include "content/public/renderer/content_renderer_client.h" +namespace content { +class RenderFrame; +} // namespace content + +namespace media { +class MediaLog; +class DecoderFactory; +class GpuVideoAcceleratorFactories; +class RendererFactory; +} // namespace media + +namespace mojo { +class BinderMap; +} // namespace mojo + namespace cobalt { +namespace media { +class VideoGeometrySetterService; +} // namespace media + +// This class utilizes embedder API for participating in renderer logic. +// It allows Cobalt to customize content Renderer module. class CobaltContentRendererClient : public content::ContentRendererClient { public: CobaltContentRendererClient(); + + CobaltContentRendererClient(const CobaltContentRendererClient&) = delete; + CobaltContentRendererClient& operator=(const CobaltContentRendererClient&) = + delete; + ~CobaltContentRendererClient() override; // ContentRendererClient implementation. + void RenderThreadStarted() override; + void ExposeInterfacesToBrowser(mojo::BinderMap* binders) override; void RenderFrameCreated(content::RenderFrame* render_frame) override; - void GetSupportedKeySystems(media::GetSupportedKeySystemsCB cb) override; - bool IsSupportedAudioType(const media::AudioType& type) override; - bool IsSupportedVideoType(const media::VideoType& type) override; - + void GetSupportedKeySystems(::media::GetSupportedKeySystemsCB cb) override; + bool IsSupportedAudioType(const ::media::AudioType& type) override; + bool IsSupportedVideoType(const ::media::VideoType& type) override; // JS Injection hook void RunScriptsAtDocumentStart(content::RenderFrame* render_frame) override; + // TODO(b/394368542): Add Content API to create StarboardRenderer. + std::unique_ptr<::media::RendererFactory> GetBaseRendererFactory( + content::RenderFrame* render_frame, + ::media::MediaLog* media_log, + ::media::DecoderFactory* decoder_factory, + base::RepeatingCallback<::media::GpuVideoAcceleratorFactories*()> + get_gpu_factories_cb) override; private: // Registers a custom content::AudioDeviceFactory - media::CobaltAudioDeviceFactory cobalt_audio_device_factory_; + ::media::CobaltAudioDeviceFactory cobalt_audio_device_factory_; + std::unique_ptr + video_geometry_setter_service_; }; } // namespace cobalt diff --git a/components/viz/service/BUILD.gn b/components/viz/service/BUILD.gn index 6ce28f2ca63e..1875cbd89759 100644 --- a/components/viz/service/BUILD.gn +++ b/components/viz/service/BUILD.gn @@ -351,6 +351,8 @@ viz_component("service") { "display/starboard/overlay_strategy_underlay_starboard.cc", "display/starboard/overlay_strategy_underlay_starboard.h", ] + + deps += [ "//cobalt/media/service/mojom" ] } } diff --git a/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.cc b/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.cc index 6725720b1029..261589ca2b2d 100644 --- a/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.cc +++ b/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.cc @@ -9,14 +9,31 @@ #include "base/containers/adapters.h" #include "base/logging.h" +#include "base/no_destructor.h" +#include "base/unguessable_token.h" #include "components/viz/common/quads/draw_quad.h" #include "components/viz/common/quads/solid_color_draw_quad.h" #include "components/viz/common/quads/video_hole_draw_quad.h" #include "components/viz/service/display/overlay_candidate_factory.h" +#include "mojo/public/cpp/bindings/remote.h" #include "ui/gfx/geometry/rect_conversions.h" namespace viz { +namespace { + +// This persistent mojo::Remote is bound then used by all the instances +// of OverlayStrategyUnderlayStarboard. +mojo::Remote& +GetVideoGeometrySetter() { + static base::NoDestructor< + mojo::Remote> + g_video_geometry_setter; + return *g_video_geometry_setter; +} + +} // namespace + OverlayStrategyUnderlayStarboard::OverlayStrategyUnderlayStarboard( OverlayProcessorUsingStrategy* capability_checker) : OverlayStrategyUnderlay(capability_checker) {} @@ -163,6 +180,12 @@ bool OverlayStrategyUnderlayStarboard::Attempt( void OverlayStrategyUnderlayStarboard::CommitCandidate( const OverlayProposedCandidate& proposed_candidate, AggregatedRenderPass* render_pass) { + DCHECK(GetVideoGeometrySetter()); + GetVideoGeometrySetter()->SetVideoGeometry( + proposed_candidate.candidate.display_rect, + absl::get(proposed_candidate.candidate.transform), + VideoHoleDrawQuad::MaterialCast(*proposed_candidate.quad_iter) + ->overlay_plane_id); if (proposed_candidate.candidate.has_mask_filter) { render_pass->ReplaceExistingQuadWithSolidColor( proposed_candidate.quad_iter, SkColors::kBlack, SkBlendMode::kDstOut); @@ -183,4 +206,11 @@ void OverlayStrategyUnderlayStarboard::AdjustOutputSurfaceOverlay( } } +// static +void OverlayStrategyUnderlayStarboard::ConnectVideoGeometrySetter( + mojo::PendingRemote + video_geometry_setter) { + GetVideoGeometrySetter().Bind(std::move(video_geometry_setter)); +} + } // namespace viz diff --git a/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.h b/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.h index 1d1ae70ef8fd..774c380ddc00 100644 --- a/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.h +++ b/components/viz/service/display/starboard/overlay_strategy_underlay_starboard.h @@ -9,7 +9,10 @@ #include #include "components/viz/service/display/overlay_strategy_underlay.h" + +#include "cobalt/media/service/mojom/video_geometry_setter.mojom.h" #include "components/viz/service/viz_service_export.h" +#include "mojo/public/cpp/bindings/pending_remote.h" namespace viz { // The underlay strategy looks for a video hole quad, where the underlay @@ -60,6 +63,15 @@ class VIZ_SERVICE_EXPORT OverlayStrategyUnderlayStarboard OverlayProcessorInterface::OutputSurfaceOverlayPlane* output_surface_plane) override; + // For SbPlayer, OverlayStrategyUnderlayStarboard needs a valid mojo + // interface to VideoGeometrySetter Service (shared by all instances of + // OverlayStrategyUnderlayStarboard). This must be called before compositor + // starts. Ideally, it can be called after compositor thread is created. Must + // be called on compositor thread. + static void ConnectVideoGeometrySetter( + mojo::PendingRemote + video_geometry_setter); + private: // Keep track if an overlay is being used on the previous frame. bool is_using_overlay_ = false; diff --git a/content/renderer/media/media_factory.cc b/content/renderer/media/media_factory.cc index 4a4d8d97ddc0..415bc1015b3a 100644 --- a/content/renderer/media/media_factory.cc +++ b/content/renderer/media/media_factory.cc @@ -94,7 +94,6 @@ #include "media/mojo/clients/mojo_fuchsia_cdm_provider.h" #elif BUILDFLAG(USE_STARBOARD_MEDIA) #include "media/starboard/starboard_cdm_factory.h" -#include "media/starboard/starboard_renderer_factory.h" #elif BUILDFLAG(ENABLE_MOJO_CDM) #include "media/mojo/clients/mojo_cdm_factory.h" // nogncheck #else @@ -144,17 +143,6 @@ namespace { // to be many of those. See http://crbug.com/1232649 constexpr size_t kDefaultMaxWebMediaPlayers = 1000; -#if BUILDFLAG(USE_STARBOARD_MEDIA) -// The following variables match |kSbPlayerWriteDurationLocal| -// and |kSbplayerWriteDurationRemote| in //starboard/player.h. -// -// The audio write duration when all the audio connectors are local. -const base::TimeDelta kWriteDurationLocal = base::Milliseconds(500); -// The audio write duration when at least one of the audio connectors are -// remote. -const base::TimeDelta kWriteDurationRemote = base::Seconds(10); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - size_t GetMaxWebMediaPlayers() { static const size_t kMaxWebMediaPlayers = []() { auto* command_line = base::CommandLine::ForCurrentProcess(); @@ -582,8 +570,15 @@ MediaFactory::CreateRendererFactorySelector( base::Unretained(render_thread))); if (factory) { is_base_renderer_factory_set = true; +#if BUILDFLAG(USE_STARBOARD_MEDIA) + // TODO(b/326827007): Revisit renderer to support secondary videos. + // TODO(b/394368542): Add Content API to create StarboardRenderer. + factory_selector->AddBaseFactory(RendererType::kStarboard, + std::move(factory)); +#else // BUILDFLAG(USE_STARBOARD_MEDIA) factory_selector->AddBaseFactory(RendererType::kContentEmbedderDefined, std::move(factory)); +#endif // BUILDFLAG(USE_STARBOARD_MEDIA) } #if BUILDFLAG(IS_ANDROID) @@ -759,21 +754,10 @@ MediaFactory::CreateRendererFactorySelector( // this method were significantly refactored to split things up by // Android/non-Android/Cast/etc... is_base_renderer_factory_set = true; -#if BUILDFLAG(USE_STARBOARD_MEDIA) - // TODO(b/326827007): Revisit renderer to support secondary videos. - factory_selector->AddFactory( - RendererType::kStarboard, - std::make_unique( - media_log, - // TODO: b/383327725 - Cobalt: Inject these values from the web app. - kWriteDurationLocal, kWriteDurationRemote)); - factory_selector->SetBaseRendererType(RendererType::kStarboard); -#else // BUILDFLAG(USE_STARBOARD_MEDIA) auto renderer_impl_factory = CreateRendererImplFactory( player_id, media_log, decoder_factory, render_thread, render_frame_); factory_selector->AddBaseFactory(RendererType::kRendererImpl, std::move(renderer_impl_factory)); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) } return factory_selector; diff --git a/media/base/mock_filters.h b/media/base/mock_filters.h index 5f6b383e0e7b..487af904af7c 100644 --- a/media/base/mock_filters.h +++ b/media/base/mock_filters.h @@ -140,9 +140,6 @@ class MockPipeline : public Pipeline { } MOCK_METHOD2(OnSetCdm, void(CdmContext* cdm_context, CdmAttachedCB& cdm_attached_cb)); -#if BUILDFLAG(USE_STARBOARD_MEDIA) - MOCK_METHOD0(GetSetBoundsCB, SetBoundsCB()); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) }; class MockMediaResource : public MediaResource { diff --git a/media/base/pipeline.h b/media/base/pipeline.h index 39a42f3d8d92..3359a7d904b3 100644 --- a/media/base/pipeline.h +++ b/media/base/pipeline.h @@ -263,12 +263,6 @@ class MEDIA_EXPORT Pipeline { using CdmAttachedCB = base::OnceCallback; virtual void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) = 0; - -#if BUILDFLAG(USE_STARBOARD_MEDIA) - // Return SetBoundsCB if SbPlayer is used for rendering. - using SetBoundsCB = base::OnceCallback; - virtual SetBoundsCB GetSetBoundsCB() = 0; -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) }; } // namespace media diff --git a/media/base/pipeline_impl.cc b/media/base/pipeline_impl.cc index 3c13ee6fd364..93f15566d72f 100644 --- a/media/base/pipeline_impl.cc +++ b/media/base/pipeline_impl.cc @@ -88,9 +88,6 @@ class PipelineImpl::RendererWrapper final : public DemuxerHost, bool DidLoadingProgress(); PipelineStatistics GetStatistics() const; void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb); -#if BUILDFLAG(USE_STARBOARD_MEDIA) - SetBoundsCB GetSetBoundsCB(); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) // |enabled_track_ids| contains track ids of enabled audio tracks. void OnEnabledAudioTracksChanged( @@ -596,14 +593,6 @@ void PipelineImpl::RendererWrapper::SetCdm(CdmContext* cdm_context, CreateRendererInternal(std::move(create_renderer_done_cb_)); } -#if BUILDFLAG(USE_STARBOARD_MEDIA) -Pipeline::SetBoundsCB PipelineImpl::RendererWrapper::GetSetBoundsCB() { - DCHECK(main_task_runner_->BelongsToCurrentThread()); - return shared_state_.renderer? shared_state_.renderer->GetSetBoundsCB() : - base::BindOnce(&SetBoundsNullTask); -} -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - void PipelineImpl::RendererWrapper::CreateRendererInternal( PipelineStatusCallback done_cb) { DVLOG(1) << __func__; @@ -1587,13 +1576,6 @@ const char* PipelineImpl::GetStateString(State state) { #undef RETURN_STRING -#if BUILDFLAG(USE_STARBOARD_MEDIA) -Pipeline::SetBoundsCB PipelineImpl::GetSetBoundsCB() { - DCHECK(thread_checker_.CalledOnValidThread()); - return renderer_wrapper_->GetSetBoundsCB(); -} -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - void PipelineImpl::AsyncCreateRenderer( absl::optional renderer_type, RendererCreatedCB renderer_created_cb) { diff --git a/media/base/pipeline_impl.h b/media/base/pipeline_impl.h index 603ddcaed907..418ff17cb857 100644 --- a/media/base/pipeline_impl.h +++ b/media/base/pipeline_impl.h @@ -119,9 +119,6 @@ class MEDIA_EXPORT PipelineImpl : public Pipeline { bool DidLoadingProgress() override; PipelineStatistics GetStatistics() const override; void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) override; -#if BUILDFLAG(USE_STARBOARD_MEDIA) - SetBoundsCB GetSetBoundsCB() override; -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) // |enabled_track_ids| contains track ids of enabled audio tracks. void OnEnabledAudioTracksChanged( diff --git a/media/base/renderer.cc b/media/base/renderer.cc index adb75dd6f1b3..ac6185fb5c37 100644 --- a/media/base/renderer.cc +++ b/media/base/renderer.cc @@ -40,12 +40,6 @@ std::string GetRendererName(RendererType renderer_type) { } } -#if BUILDFLAG(USE_STARBOARD_MEDIA) -bool SetBoundsNullTask(int x, int y, int width, int height) { - return false; -} -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - Renderer::Renderer() = default; Renderer::~Renderer() = default; @@ -82,11 +76,4 @@ void Renderer::OnExternalVideoFrameRequest() { // Default implementation of OnExternalVideoFrameRequest is to no-op. } -#if BUILDFLAG(USE_STARBOARD_MEDIA) -Renderer::SetBoundsCB Renderer::GetSetBoundsCB() { - // Default implementation of GetSetBoundsCB is to no-op. - return base::BindOnce(&SetBoundsNullTask); -} -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - } // namespace media diff --git a/media/base/renderer.h b/media/base/renderer.h index 0ea111a73c5d..5a59bb805cbf 100644 --- a/media/base/renderer.h +++ b/media/base/renderer.h @@ -48,10 +48,6 @@ enum class RendererType { // the actual Renderer class name or a descriptive name. std::string MEDIA_EXPORT GetRendererName(RendererType renderer_type); -#if BUILDFLAG(USE_STARBOARD_MEDIA) -bool MEDIA_EXPORT SetBoundsNullTask(int x, int y, int width, int height); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - class MEDIA_EXPORT Renderer { public: Renderer(); @@ -140,12 +136,6 @@ class MEDIA_EXPORT Renderer { // enforce RendererType registration for all Renderer implementations. // Note: New implementation should update RendererType. virtual RendererType GetRendererType() = 0; - -#if BUILDFLAG(USE_STARBOARD_MEDIA) - // Return SetBoundsCB if SbPlayer is used for rendering. - using SetBoundsCB = base::OnceCallback; - virtual SetBoundsCB GetSetBoundsCB(); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) }; } // namespace media diff --git a/media/filters/pipeline_controller.cc b/media/filters/pipeline_controller.cc index e19d3a726345..35dc4f32dc78 100644 --- a/media/filters/pipeline_controller.cc +++ b/media/filters/pipeline_controller.cc @@ -448,13 +448,6 @@ void PipelineController::OnExternalVideoFrameRequest() { pipeline_->OnExternalVideoFrameRequest(); } -#if BUILDFLAG(USE_STARBOARD_MEDIA) -Pipeline::SetBoundsCB PipelineController::GetSetBoundsCB() { - DCHECK(thread_checker_.CalledOnValidThread()); - return pipeline_->GetSetBoundsCB(); -} -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - void PipelineController::FireOnTrackChangeCompleteForTesting(State set_to) { previous_track_change_state_ = set_to; OnTrackChangeComplete(); diff --git a/media/filters/pipeline_controller.h b/media/filters/pipeline_controller.h index 1bccbe80c957..d50290a0acdd 100644 --- a/media/filters/pipeline_controller.h +++ b/media/filters/pipeline_controller.h @@ -149,9 +149,6 @@ class MEDIA_EXPORT PipelineController { void OnSelectedVideoTrackChanged( absl::optional selected_track_id); void OnExternalVideoFrameRequest(); -#if BUILDFLAG(USE_STARBOARD_MEDIA) - Pipeline::SetBoundsCB GetSetBoundsCB(); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) // Used to fire the OnTrackChangeComplete function which is captured in a // OnceCallback, and doesn't play nicely with gmock. diff --git a/media/starboard/BUILD.gn b/media/starboard/BUILD.gn index 39950f08fbf2..87c713af8226 100644 --- a/media/starboard/BUILD.gn +++ b/media/starboard/BUILD.gn @@ -102,6 +102,8 @@ source_set("starboard") { deps = [ "//base", + "//cobalt/media/service", + "//cobalt/media/service/mojom", "//media:media_buildflags", "//media/base", "//media/renderers", diff --git a/media/starboard/starboard_renderer.cc b/media/starboard/starboard_renderer.cc index 249127c730df..a59a91ddab62 100644 --- a/media/starboard/starboard_renderer.cc +++ b/media/starboard/starboard_renderer.cc @@ -20,6 +20,7 @@ #include "media/base/video_codecs.h" #include "starboard/common/media.h" #include "starboard/common/player.h" +#include "ui/gfx/geometry/rect_conversions.h" namespace media { @@ -110,17 +111,20 @@ StarboardRenderer::StarboardRenderer( const scoped_refptr& task_runner, VideoRendererSink* video_renderer_sink, MediaLog* media_log, + std::unique_ptr video_overlay_factory, TimeDelta audio_write_duration_local, - TimeDelta audio_write_duration_remote) + TimeDelta audio_write_duration_remote, + cobalt::media::VideoGeometrySetterService* video_geometry_setter_service) : state_(STATE_UNINITIALIZED), task_runner_(task_runner), video_renderer_sink_(video_renderer_sink), media_log_(media_log), + video_overlay_factory_(std::move(video_overlay_factory)), + set_bounds_helper_(new SbPlayerSetBoundsHelper), + cdm_context_(nullptr), audio_write_duration_local_(audio_write_duration_local), audio_write_duration_remote_(audio_write_duration_remote), - video_overlay_factory_(std::make_unique()), - set_bounds_helper_(new SbPlayerSetBoundsHelper), - cdm_context_(nullptr) { + video_geometry_setter_service_(video_geometry_setter_service) { DCHECK(task_runner_); DCHECK(video_renderer_sink_); DCHECK(media_log_); @@ -181,6 +185,16 @@ void StarboardRenderer::Initialize(MediaResource* media_resource, client_ = client; init_cb_ = std::move(init_cb); + DCHECK(video_geometry_setter_service_); + DCHECK(video_geometry_change_subcriber_remote_); + video_geometry_setter_service_->GetVideoGeometryChangeSubscriber( + video_geometry_change_subcriber_remote_.BindNewPipeAndPassReceiver()); + video_geometry_change_subcriber_remote_->SubscribeToVideoGeometryChange( + video_overlay_factory_->overlay_plane_id(), + video_geometry_change_client_receiver_.BindNewPipeAndPassRemote(), + base::BindOnce(&StarboardRenderer::OnSubscribeToVideoGeometryChange, + base::Unretained(this), media_resource, client)); + audio_stream_ = media_resource->GetFirstStream(DemuxerStream::AUDIO); video_stream_ = media_resource->GetFirstStream(DemuxerStream::VIDEO); @@ -226,6 +240,12 @@ void StarboardRenderer::Initialize(MediaResource* media_resource, CreatePlayerBridge(); } +void StarboardRenderer::OnSubscribeToVideoGeometryChange( + MediaResource* media_resource, + RendererClient* client) { + DCHECK(task_runner_->RunsTasksInCurrentSequence()); +} + void StarboardRenderer::SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) { DCHECK(task_runner_->RunsTasksInCurrentSequence()); @@ -412,9 +432,12 @@ TimeDelta StarboardRenderer::GetMediaTime() { return media_time; } -Renderer::SetBoundsCB StarboardRenderer::GetSetBoundsCB() { - return base::BindOnce(&SbPlayerSetBoundsHelper::SetBounds, - set_bounds_helper_); +void StarboardRenderer::OnVideoGeometryChange( + const gfx::RectF& rect_f, + gfx::OverlayTransform /* transform */) { + gfx::Rect new_bounds = gfx::ToNearestRect(rect_f); + set_bounds_helper_->SetBounds(new_bounds.x(), new_bounds.y(), + new_bounds.width(), new_bounds.height()); } void StarboardRenderer::CreatePlayerBridge() { diff --git a/media/starboard/starboard_renderer.h b/media/starboard/starboard_renderer.h index cdbc350f5716..19e549b05eb2 100644 --- a/media/starboard/starboard_renderer.h +++ b/media/starboard/starboard_renderer.h @@ -23,6 +23,8 @@ #include "base/synchronization/lock.h" #include "base/task/sequenced_task_runner.h" #include "base/time/time.h" +#include "cobalt/media/service/mojom/video_geometry_setter.mojom.h" +#include "cobalt/media/service/video_geometry_setter_service.h" #include "media/base/cdm_context.h" #include "media/base/decoder_buffer.h" #include "media/base/demuxer_stream.h" @@ -35,6 +37,8 @@ #include "media/renderers/video_overlay_factory.h" #include "media/starboard/sbplayer_bridge.h" #include "media/starboard/sbplayer_set_bounds_helper.h" +#include "mojo/public/cpp/bindings/receiver.h" +#include "mojo/public/cpp/bindings/remote.h" #include "third_party/abseil-cpp/absl/types/optional.h" namespace media { @@ -44,14 +48,19 @@ using base::TimeDelta; // SbPlayer based Renderer implementation, the entry point for all video // playbacks on Starboard platforms. -class MEDIA_EXPORT StarboardRenderer final : public Renderer, - private SbPlayerBridge::Host { +class MEDIA_EXPORT StarboardRenderer final + : public Renderer, + private SbPlayerBridge::Host, + public cobalt::media::mojom::VideoGeometryChangeClient { public: - StarboardRenderer(const scoped_refptr& task_runner, - VideoRendererSink* video_renderer_sink, - MediaLog* media_log, - TimeDelta audio_write_duration_local, - TimeDelta audio_write_duration_remote); + StarboardRenderer( + const scoped_refptr& task_runner, + VideoRendererSink* video_renderer_sink, + MediaLog* media_log, + std::unique_ptr video_overlay_factory, + TimeDelta audio_write_duration_local, + TimeDelta audio_write_duration_remote, + cobalt::media::VideoGeometrySetterService* video_geometry_setter_service); ~StarboardRenderer() final; @@ -92,7 +101,10 @@ class MEDIA_EXPORT StarboardRenderer final : public Renderer, std::move(change_completed_cb).Run(); } RendererType GetRendererType() final { return RendererType::kStarboard; } - SetBoundsCB GetSetBoundsCB() override; + + // cobalt::media::mojom::VideoGeometryChangeClient implementation. + void OnVideoGeometryChange(const gfx::RectF& rect_f, + gfx::OverlayTransform transform) override; private: enum State { @@ -104,6 +116,8 @@ class MEDIA_EXPORT StarboardRenderer final : public Renderer, STATE_ERROR }; + void OnSubscribeToVideoGeometryChange(MediaResource* media_resource, + RendererClient* client); void CreatePlayerBridge(); void UpdateDecoderConfig(DemuxerStream* stream); void OnDemuxerStreamRead(DemuxerStream* stream, @@ -211,6 +225,12 @@ class MEDIA_EXPORT StarboardRenderer final : public Renderer, static inline constexpr const char* kSbPlayerCapabilityChangedErrorMessage = "MEDIA_ERR_CAPABILITY_CHANGED"; + cobalt::media::VideoGeometrySetterService* video_geometry_setter_service_; + mojo::Remote + video_geometry_change_subcriber_remote_; + mojo::Receiver + video_geometry_change_client_receiver_{this}; + base::WeakPtrFactory weak_factory_{this}; base::WeakPtr weak_this_{weak_factory_.GetWeakPtr()}; diff --git a/media/starboard/starboard_renderer_factory.cc b/media/starboard/starboard_renderer_factory.cc index f72b0472e509..c15f2a5778cf 100644 --- a/media/starboard/starboard_renderer_factory.cc +++ b/media/starboard/starboard_renderer_factory.cc @@ -23,11 +23,15 @@ namespace media { StarboardRendererFactory::StarboardRendererFactory( MediaLog* media_log, + std::unique_ptr video_overlay_factory, base::TimeDelta audio_write_duration_local, - base::TimeDelta audio_write_duration_remote) + base::TimeDelta audio_write_duration_remote, + cobalt::media::VideoGeometrySetterService* video_geometry_setter) : media_log_(media_log), + video_overlay_factory_(std::move(video_overlay_factory)), audio_write_duration_local_(audio_write_duration_local), - audio_write_duration_remote_(audio_write_duration_remote) {} + audio_write_duration_remote_(audio_write_duration_remote), + video_geometry_setter_(video_geometry_setter) {} StarboardRendererFactory::~StarboardRendererFactory() = default; @@ -40,9 +44,11 @@ std::unique_ptr StarboardRendererFactory::CreateRenderer( const gfx::ColorSpace& target_color_space) { DCHECK(video_renderer_sink); DCHECK(media_log_); + DCHECK(video_geometry_setter_); return std::make_unique( media_task_runner, video_renderer_sink, media_log_, - audio_write_duration_local_, audio_write_duration_remote_); + std::move(video_overlay_factory_), audio_write_duration_local_, + audio_write_duration_remote_, video_geometry_setter_); } } // namespace media diff --git a/media/starboard/starboard_renderer_factory.h b/media/starboard/starboard_renderer_factory.h index 8ff866ff0b87..8d5fc0c6c72f 100644 --- a/media/starboard/starboard_renderer_factory.h +++ b/media/starboard/starboard_renderer_factory.h @@ -18,8 +18,10 @@ #include "base/memory/raw_ptr.h" #include "base/task/sequenced_task_runner.h" #include "base/time/time.h" +#include "cobalt/media/service/video_geometry_setter_service.h" #include "media/base/media_log.h" #include "media/base/renderer_factory.h" +#include "media/renderers/video_overlay_factory.h" namespace media { @@ -28,8 +30,10 @@ class MEDIA_EXPORT StarboardRendererFactory final : public RendererFactory { public: explicit StarboardRendererFactory( MediaLog* media_log, + std::unique_ptr video_overlay_factory, base::TimeDelta audio_write_duration_local, - base::TimeDelta audio_write_duration_remote); + base::TimeDelta audio_write_duration_remote, + cobalt::media::VideoGeometrySetterService* video_geometry_setter); StarboardRendererFactory(const StarboardRendererFactory&) = delete; StarboardRendererFactory& operator=(const StarboardRendererFactory&) = delete; @@ -47,8 +51,10 @@ class MEDIA_EXPORT StarboardRendererFactory final : public RendererFactory { private: raw_ptr media_log_; + std::unique_ptr video_overlay_factory_; const base::TimeDelta audio_write_duration_local_; const base::TimeDelta audio_write_duration_remote_; + cobalt::media::VideoGeometrySetterService* video_geometry_setter_; }; } // namespace media diff --git a/third_party/blink/public/platform/web_media_player.h b/third_party/blink/public/platform/web_media_player.h index 8b9dec4058d7..eb92552cb343 100644 --- a/third_party/blink/public/platform/web_media_player.h +++ b/third_party/blink/public/platform/web_media_player.h @@ -303,12 +303,6 @@ class WebMediaPlayer { // Sets the poster image URL. virtual void SetPoster(const WebURL& poster) {} -#if BUILDFLAG(USE_STARBOARD_MEDIA) - // Return SetBoundsCB if SbPlayer is used for rendering. - using SetBoundsCB = base::OnceCallback; - virtual SetBoundsCB GetSetBoundsCB() { return SetBoundsCB(); } -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - // Inform WebMediaPlayer when the element has entered/exited fullscreen. virtual void EnteredFullscreen() {} virtual void ExitedFullscreen() {} diff --git a/third_party/blink/renderer/core/paint/video_painter.cc b/third_party/blink/renderer/core/paint/video_painter.cc index bdb5c55c182e..8b7a7b694d25 100644 --- a/third_party/blink/renderer/core/paint/video_painter.cc +++ b/third_party/blink/renderer/core/paint/video_painter.cc @@ -35,9 +35,6 @@ void VideoPainter::PaintReplaced(const PaintInfo& paint_info, force_video_poster; if (!should_display_poster && !media_player) return; -#if BUILDFLAG(USE_STARBOARD_MEDIA) - WebMediaPlayer::SetBoundsCB set_bounds_cb = media_player->GetSetBoundsCB(); -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) PhysicalRect replaced_rect = layout_video_.ReplacedContentRect(); replaced_rect.Move(paint_offset); @@ -80,15 +77,6 @@ void VideoPainter::PaintReplaced(const PaintInfo& paint_info, layer->SetBounds(snapped_replaced_rect.size()); layer->SetIsDrawable(true); layer->SetHitTestable(true); -#if BUILDFLAG(USE_STARBOARD_MEDIA) - if (!set_bounds_cb.is_null()) { - // TODO(b/377754564): revisit it for the impact of performance of SbPlayerSetBounds. - std::move(set_bounds_cb).Run(layout_video_.AbsoluteBoundingBoxRect().x(), - layout_video_.AbsoluteBoundingBoxRect().y(), - layout_video_.AbsoluteBoundingBoxRect().width(), - layout_video_.AbsoluteBoundingBoxRect().height()); - } -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) RecordForeignLayer(context, layout_video_, DisplayItem::kForeignLayerVideo, layer, snapped_replaced_rect.origin()); diff --git a/third_party/blink/renderer/platform/media/web_media_player_impl.cc b/third_party/blink/renderer/platform/media/web_media_player_impl.cc index 7b9e29eaff13..5182ae81600a 100644 --- a/third_party/blink/renderer/platform/media/web_media_player_impl.cc +++ b/third_party/blink/renderer/platform/media/web_media_player_impl.cc @@ -690,13 +690,6 @@ void WebMediaPlayerImpl::DisableOverlay() { MaybeSendOverlayInfoToDecoder(); } -#if BUILDFLAG(USE_STARBOARD_MEDIA) -WebMediaPlayer::SetBoundsCB WebMediaPlayerImpl::GetSetBoundsCB() { - DCHECK(main_task_runner_->BelongsToCurrentThread()); - return pipeline_controller_->GetSetBoundsCB(); -} -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - void WebMediaPlayerImpl::EnteredFullscreen() { overlay_info_.is_fullscreen = true; diff --git a/third_party/blink/renderer/platform/media/web_media_player_impl.h b/third_party/blink/renderer/platform/media/web_media_player_impl.h index 50f9f1ceebf9..00159b375c77 100644 --- a/third_party/blink/renderer/platform/media/web_media_player_impl.h +++ b/third_party/blink/renderer/platform/media/web_media_player_impl.h @@ -59,10 +59,6 @@ #include "third_party/blink/renderer/platform/platform_export.h" #include "url/gurl.h" -#if BUILDFLAG(USE_STARBOARD_MEDIA) -#include "media/starboard/starboard_renderer.h" -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - namespace base { class SingleThreadTaskRunner; class TaskRunner; @@ -258,10 +254,6 @@ class PLATFORM_EXPORT WebMediaPlayerImpl WebContentDecryptionModule* cdm, WebContentDecryptionModuleResult result) override; -#if BUILDFLAG(USE_STARBOARD_MEDIA) - SetBoundsCB GetSetBoundsCB() override; -#endif // BUILDFLAG(USE_STARBOARD_MEDIA) - void EnteredFullscreen() override; void ExitedFullscreen() override; void BecameDominantVisibleContent(bool is_dominant) override;