media: Wire URL-player renderer factory plumbing

build/build_config.h

@@ -310,6 +310,12 @@
 #define BUILDFLAG_INTERNAL_USE_STARBOARD_MEDIA() (0)
 #endif
 
+#if defined(ENABLE_BUILDFLAG_USE_STARBOARD_URL_PLAYER)
+#define BUILDFLAG_INTERNAL_USE_STARBOARD_URL_PLAYER() (1)
+#else
+#define BUILDFLAG_INTERNAL_USE_STARBOARD_URL_PLAYER() (0)
+#endif
+
 #if defined(ENABLE_BUILDFLAG_USE_EVERGREEN)
 #define BUILDFLAG_INTERNAL_USE_EVERGREEN() (1)
 #else

cobalt/build/configs/BUILD.gn

@@ -111,6 +111,14 @@ config("buildflag_defines") {
     defines += [ "ENABLE_BUILDFLAG_USE_STARBOARD_MEDIA" ]
   }
 
+  # use_starboard_url_player and BUILDFLAG(USE_STARBOARD_URL_PLAYER) should be
+  # used to wrap URL-based player functionality (e.g., HLS via AVPlayer on
+  # tvOS). This is a derived capability that is true only for tvOS builds with
+  # Starboard media enabled.
+  if (use_starboard_url_player) {
+    defines += [ "ENABLE_BUILDFLAG_USE_STARBOARD_URL_PLAYER" ]
+  }
+
   # use_evergreen and BUILDFLAG(USE_EVERGREEN) should be used for
   # Evergreen-specific functionality, i.e. the Evergreen loader_app. Do not use
   # this flag for hermetic build functionality, instead use

content/browser/media/frameless_media_interface_proxy.cc

@@ -152,6 +152,17 @@ void FramelessMediaInterfaceProxy::CreateStarboardRenderer(
         client_extension_remote) {}
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+void FramelessMediaInterfaceProxy::CreateUrlPlayerRenderer(
+    mojo::PendingRemote<media::mojom::MediaLog> media_log_remote,
+    const media::StarboardRendererConfig& config,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver,
+    mojo::PendingReceiver<media::mojom::StarboardRendererExtension>
+        renderer_extension_receiver,
+    mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
+        client_extension_remote) {}
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+
 void FramelessMediaInterfaceProxy::CreateCdm(const media::CdmConfig& cdm_config,
                                              CreateCdmCallback callback) {
   std::move(callback).Run(mojo::NullRemote(), nullptr,

content/browser/media/frameless_media_interface_proxy.h

@@ -94,6 +94,16 @@ class FramelessMediaInterfaceProxy final
       mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
           client_extension_remote) final;
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+  void CreateUrlPlayerRenderer(
+      mojo::PendingRemote<media::mojom::MediaLog> media_log_remote,
+      const media::StarboardRendererConfig& config,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver,
+      mojo::PendingReceiver<media::mojom::StarboardRendererExtension>
+          renderer_extension_receiver,
+      mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
+          client_extension_remote) final;
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
   void CreateCdm(const media::CdmConfig& cdm_config,
                  CreateCdmCallback callback) final;
 

content/browser/media/media_interface_proxy.cc

@@ -402,6 +402,28 @@ void MediaInterfaceProxy::CreateStarboardRenderer(
 }
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+void MediaInterfaceProxy::CreateUrlPlayerRenderer(
+    mojo::PendingRemote<media::mojom::MediaLog> media_log_remote,
+    const media::StarboardRendererConfig& config,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver,
+    mojo::PendingReceiver<media::mojom::StarboardRendererExtension>
+        renderer_extension_receiver,
+    mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
+        client_extension_remote) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << __func__ << ": this=" << this;
+
+  InterfaceFactory* factory = media_interface_factory_ptr_->Get();
+  if (factory) {
+    factory->CreateUrlPlayerRenderer(
+        std::move(media_log_remote), config,
+        std::move(receiver), std::move(renderer_extension_receiver),
+        std::move(client_extension_remote));
+  }
+}
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+
 void MediaInterfaceProxy::CreateCdm(const media::CdmConfig& cdm_config,
                                     CreateCdmCallback create_cdm_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());

content/browser/media/media_interface_proxy.h

@@ -97,6 +97,16 @@ class MediaInterfaceProxy final : public DocumentUserData<MediaInterfaceProxy>,
       mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
           client_extension_remote) final;
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+  void CreateUrlPlayerRenderer(
+      mojo::PendingRemote<media::mojom::MediaLog> media_log_remote,
+      const media::StarboardRendererConfig& config,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver,
+      mojo::PendingReceiver<media::mojom::StarboardRendererExtension>
+          renderer_extension_receiver,
+      mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
+          client_extension_remote) final;
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
   void CreateCdm(const media::CdmConfig& cdm_config,
                  CreateCdmCallback create_cdm_cb) final;
 

content/renderer/media/media_interface_factory.cc

@@ -202,6 +202,33 @@ void MediaInterfaceFactory::CreateStarboardRenderer(
 }
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+void MediaInterfaceFactory::CreateUrlPlayerRenderer(
+    mojo::PendingRemote<media::mojom::MediaLog> media_log_remote,
+    const media::StarboardRendererConfig& config,
+    mojo::PendingReceiver<media::mojom::Renderer> receiver,
+    mojo::PendingReceiver<media::mojom::StarboardRendererExtension>
+        renderer_extension_receiver,
+    mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
+        client_extension_remote) {
+  if (!task_runner_->BelongsToCurrentThread()) {
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::BindOnce(&MediaInterfaceFactory::CreateUrlPlayerRenderer,
+                       weak_this_, std::move(media_log_remote),
+                       config, std::move(receiver),
+                       std::move(renderer_extension_receiver),
+                       std::move(client_extension_remote)));
+    return;
+  }
+
+  GetMediaInterfaceFactory()->CreateUrlPlayerRenderer(
+      std::move(media_log_remote), config,
+      std::move(receiver), std::move(renderer_extension_receiver),
+      std::move(client_extension_remote));
+}
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+
 void MediaInterfaceFactory::CreateCdm(const media::CdmConfig& cdm_config,
                                       CreateCdmCallback callback) {
   if (!task_runner_->BelongsToCurrentThread()) {

content/renderer/media/media_interface_factory.h

@@ -92,6 +92,16 @@ class MediaInterfaceFactory final : public media::mojom::InterfaceFactory {
       mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
           client_extension_remote) final;
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+  void CreateUrlPlayerRenderer(
+      mojo::PendingRemote<media::mojom::MediaLog> media_log_remote,
+      const media::StarboardRendererConfig& config,
+      mojo::PendingReceiver<media::mojom::Renderer> receiver,
+      mojo::PendingReceiver<media::mojom::StarboardRendererExtension>
+          renderer_extension_receiver,
+      mojo::PendingRemote<media::mojom::StarboardRendererClientExtension>
+          client_extension_remote) final;
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
   void CreateCdm(const media::CdmConfig& cdm_config,
                  CreateCdmCallback callback) final;
 

media/base/media_resource.cc

@@ -5,6 +5,7 @@
 #include "media/base/media_resource.h"
 
 #include "base/no_destructor.h"
+#include "media/media_buildflags.h"
 #include "net/cookies/site_for_cookies.h"
 #include "net/storage_access_api/status.h"
 #include "url/gurl.h"
@@ -25,4 +26,10 @@ DemuxerStream* MediaResource::GetFirstStream(DemuxerStream::Type type) {
   return nullptr;
 }
 
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+GURL MediaResource::GetMediaUrl() const {
+  return GURL();
+}
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+
 }  // namespace media

media/base/media_resource.h

@@ -11,6 +11,11 @@
 #include "base/time/time.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_export.h"
+#include "build/build_config.h"
+#include "media/media_buildflags.h"
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+#include "url/gurl.h"
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
 
 namespace media {
 
@@ -41,6 +46,11 @@ class MEDIA_EXPORT MediaResource {
   // A helper function that return the first stream of the given `type` if one
   // exists or a null pointer if there is no streams of that type.
   DemuxerStream* GetFirstStream(DemuxerStream::Type type);
+
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+  // Returns the media URL for URL based players (e.g., HLS via AVPlayer).
+  virtual GURL GetMediaUrl() const;
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
 };
 
 }  // namespace media

media/base/renderer.cc

@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 #include "media/base/renderer.h"
+
 #include "base/logging.h"
+#include "build/build_config.h"
 
 namespace media {
 
@@ -34,7 +36,11 @@ std::string GetRendererName(RendererType renderer_type) {
 #if BUILDFLAG(USE_STARBOARD_MEDIA)
     case RendererType::kStarboard:
       return "StarboardRenderer";
-#endif // BUILDFLAG(USE_STARBOARD_MEDIA)
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+    case RendererType::kUrlPlayer:
+      return "UrlPlayerRenderer";
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
   }
 }
 

media/base/renderer.h

@@ -9,6 +9,7 @@
 
 #include "base/functional/callback.h"
 #include "base/time/time.h"
+#include "build/build_config.h"
 #include "media/base/buffering_state.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_export.h"
@@ -39,10 +40,15 @@ enum class RendererType {
   kTest = 11,                    // Renderer implementations used in tests
 #if BUILDFLAG(USE_STARBOARD_MEDIA)
   kStarboard = 12,       // StarboardRendererFactory
+#endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+  kUrlPlayer = 13,       // UrlPlayerRendererClientFactory
+  kMaxValue = kUrlPlayer,
+#elif BUILDFLAG(USE_STARBOARD_MEDIA)
   kMaxValue = kStarboard,
-#else // BUILDFLAG(USE_STARBOARD_MEDIA)
+#else
   kMaxValue = kTest,
-#endif // BUILDFLAG(USE_STARBOARD_MEDIA)
+#endif // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
 };
 
 // Get the name of the Renderer for `renderer_type`. The returned name could be

media/mojo/clients/BUILD.gn

@@ -148,6 +148,15 @@ source_set("clients") {
       "//cobalt/renderer",
     ]
   }
+
+  if (is_cobalt && use_starboard_url_player) {
+    sources += [
+      "starboard/url_player_renderer_client.cc",
+      "starboard/url_player_renderer_client.h",
+      "starboard/url_player_renderer_client_factory.cc",
+      "starboard/url_player_renderer_client_factory.h",
+    ]
+  }
 }
 
 static_library("test_support") {
@@ -212,4 +221,5 @@ source_set("unit_tests") {
   if (is_cobalt && use_starboard_media) {
     sources += [ "starboard/starboard_renderer_client_unittest.cc" ]
   }
+
 }

media/mojo/clients/mojo_renderer.cc

@@ -151,6 +151,32 @@ void MojoRenderer::Initialize(MediaResource* media_resource,
                                               base::Unretained(this), client));
 }
 
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+void MojoRenderer::InitializeWithUrl(media::RendererClient* client,
+                                     const GURL& source_url,
+                                     PipelineStatusCallback init_cb) {
+  DVLOG(1) << __func__;
+  DCHECK(task_runner_->RunsTasksInCurrentSequence());
+  DCHECK(source_url.is_valid());
+
+  if (encountered_error_) {
+    task_runner_->PostTask(
+        FROM_HERE, base::BindOnce(std::move(init_cb),
+                                  PIPELINE_ERROR_INITIALIZATION_FAILED));
+    return;
+  }
+
+  init_cb_ = std::move(init_cb);
+
+  BindRemoteRendererIfNeeded();
+
+  remote_renderer_->InitializeWithUrl(
+      client_receiver_.BindNewEndpointAndPassRemote(), source_url,
+      base::BindOnce(&MojoRenderer::OnInitialized, base::Unretained(this),
+                     client));
+}
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+
 void MojoRenderer::SetCdm(CdmContext* cdm_context,
                           CdmAttachedCB cdm_attached_cb) {
   DVLOG(1) << __func__;

media/mojo/clients/mojo_renderer.h

@@ -19,9 +19,11 @@
 #include "media/base/renderer.h"
 #include "media/base/time_delta_interpolator.h"
 #include "media/mojo/mojom/renderer.mojom.h"
+#include "build/build_config.h"
 #include "mojo/public/cpp/bindings/associated_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
+#include "url/gurl.h"
 
 #if BUILDFLAG(USE_STARBOARD_MEDIA)
 #include "media/mojo/common/starboard/mojo_renderer_bypass_bridge.h"
@@ -65,6 +67,11 @@ class MojoRenderer : public Renderer, public mojom::RendererClient {
   void Initialize(MediaResource* media_resource,
                   media::RendererClient* client,
                   PipelineStatusCallback init_cb) override;
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+  void InitializeWithUrl(media::RendererClient* client,
+                         const GURL& source_url,
+                         PipelineStatusCallback init_cb);
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
   void SetCdm(CdmContext* cdm_context, CdmAttachedCB cdm_attached_cb) override;
   void SetLatencyHint(std::optional<base::TimeDelta> latency_hint) override;
   void Flush(base::OnceClosure flush_cb) override;

media/mojo/clients/mojo_renderer_factory.cc

@@ -134,4 +134,30 @@ std::unique_ptr<MojoRenderer> MojoRendererFactory::CreateStarboardRenderer(
 }
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
 
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+std::unique_ptr<MojoRenderer> MojoRendererFactory::CreateUrlPlayerRenderer(
+    mojo::PendingRemote<mojom::MediaLog> media_log_remote,
+    const StarboardRendererConfig& config,
+    mojo::PendingReceiver<mojom::StarboardRendererExtension>
+        renderer_extension_receiver,
+    mojo::PendingRemote<mojom::StarboardRendererClientExtension>
+        client_extension_remote,
+    const scoped_refptr<base::SequencedTaskRunner>& media_task_runner,
+    VideoRendererSink* video_renderer_sink) {
+  DCHECK(interface_factory_);
+
+  mojo::PendingRemote<mojom::Renderer> renderer_remote;
+  interface_factory_->CreateUrlPlayerRenderer(
+      std::move(media_log_remote), config,
+      renderer_remote.InitWithNewPipeAndPassReceiver(),
+      std::move(renderer_extension_receiver),
+      std::move(client_extension_remote));
+
+  return std::make_unique<MojoRenderer>(
+      media_task_runner, nullptr, video_renderer_sink,
+      std::move(renderer_remote),
+      config.experimental_features.bypass_mojo_for_media);
+}
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+
 }  // namespace media

media/mojo/clients/mojo_renderer_factory.h

@@ -86,6 +86,17 @@ class MojoRendererFactory final : public RendererFactory {
       const scoped_refptr<base::SequencedTaskRunner>& media_task_runner,
       VideoRendererSink* video_renderer_sink);
 #endif  // BUILDFLAG(USE_STARBOARD_MEDIA)
+#if BUILDFLAG(USE_STARBOARD_URL_PLAYER)
+  std::unique_ptr<MojoRenderer> CreateUrlPlayerRenderer(
+      mojo::PendingRemote<mojom::MediaLog> media_log_remote,
+      const StarboardRendererConfig& config,
+      mojo::PendingReceiver<mojom::StarboardRendererExtension>
+          renderer_extension_receiver,
+      mojo::PendingRemote<mojom::StarboardRendererClientExtension>
+          client_extension_remote,
+      const scoped_refptr<base::SequencedTaskRunner>& media_task_runner,
+      VideoRendererSink* video_renderer_sink);
+#endif  // BUILDFLAG(USE_STARBOARD_URL_PLAYER)
 
  private:
   // InterfaceFactory or InterfaceProvider used to create or connect to remote