content/renderer/media/media_factory.h

   1 // Copyright 2017 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_RENDERER_MEDIA_MEDIA_FACTORY_H_
   6 #define CONTENT_RENDERER_MEDIA_MEDIA_FACTORY_H_
   7
   8 #include <memory>
   9
  10 #include "base/memory/raw_ptr.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/task/single_thread_task_runner.h"
  13 #include "build/build_config.h"
  14 #include "build/buildflag.h"
  15 #include "build/chromecast_buildflags.h"
  16 #include "components/viz/common/surfaces/surface_id.h"
  17 #include "media/base/media_player_logging_id.h"
  18 #include "media/base/renderer_factory_selector.h"
  19 #include "media/base/routing_token_callback.h"
  20 #include "media/media_buildflags.h"
  21 #include "media/mojo/buildflags.h"
  22 #include "media/mojo/clients/mojo_renderer_factory.h"
  23 #include "media/mojo/mojom/interface_factory.mojom.h"
  24 #include "mojo/public/cpp/bindings/remote.h"
  25 #include "third_party/blink/public/platform/web_media_player_source.h"
  26 #include "third_party/blink/public/platform/web_set_sink_id_callbacks.h"
  27 #include "third_party/blink/public/platform/web_string.h"
  28 #include "third_party/blink/public/web/web_media_inspector.h"
  29
  30 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
  31 // Needed by remoting sender.
  32 #include "media/mojo/mojom/remoting.mojom.h"  // nogncheck
  33 #endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING)
  34
  35 namespace blink {
  36 class BrowserInterfaceBrokerProxy;
  37 class ResourceFetchContext;
  38 class UrlIndex;
  39 class WebContentDecryptionModule;
  40 class WebEncryptedMediaClient;
  41 class WebEncryptedMediaClientImpl;
  42 class WebLocalFrame;
  43 class WebMediaPlayer;
  44 class WebMediaPlayerClient;
  45 class WebMediaPlayerEncryptedMediaClient;
  46 }  // namespace blink
  47
  48 #if BUILDFLAG(ENABLE_CAST_RECEIVER)
  49 namespace cast_streaming {
  50 class ResourceProvider;
  51 }  // namespace cast_streaming
  52 #endif
  53
  54 namespace cc {
  55 class LayerTreeSettings;
  56 }  // namespace cc
  57
  58 namespace media {
  59 class CdmFactory;
  60 class DecoderFactory;
  61 class DefaultDecoderFactory;
  62 class MediaLog;
  63 class MediaObserver;
  64 class RemotePlaybackClientWrapper;
  65 class RendererWebMediaPlayerDelegate;
  66 }  // namespace media
  67
  68 namespace content {
  69
  70 class RenderFrameImpl;
  71 class MediaInterfaceFactory;
  72 struct RenderFrameMediaPlaybackOptions;
  73
  74 // Assist to RenderFrameImpl in creating various media clients.
  75 class MediaFactory {
  76  public:
  77   // Helper function returning whether VideoSurfaceLayer should be enabled for
  78   // MediaStreams.
  79   static bool VideoSurfaceLayerEnabledForMS();
  80
  81   // Create a MediaFactory to assist the |render_frame| with media tasks.
  82   // |request_routing_token_cb| bound to |render_frame| IPC functions for
  83   // obtaining overlay tokens.
  84   MediaFactory(RenderFrameImpl* render_frame,
  85                media::RequestRoutingTokenCallback request_routing_token_cb);
  86   ~MediaFactory();
  87
  88   // Instruct MediaFactory to establish Mojo channels as needed to perform its
  89   // factory duties. This should be called by RenderFrameImpl as soon as its own
  90   // interface provider is bound.
  91   void SetupMojo();
  92
  93   // Creates a new WebMediaPlayer for the given |source| (either a stream or
  94   // URL). All pointers other than |initial_cdm| are required to be non-null.
  95   // The created player serves and is directed by the |client| (e.g.
  96   // HTMLMediaElement). The |encrypted_client| will be used to establish
  97   // means of decryption for encrypted content. |initial_cdm| should point
  98   // to a ContentDecryptionModule if MediaKeys have been provided to the
  99   // |encrypted_client| (otherwise null). |sink_id|, when not empty, identifies
 100   // the audio sink to use for this player (see HTMLMediaElement.sinkId).
 101   // |parent_frame_sink_id| identifies the local root widget's FrameSinkId.
 102   blink::WebMediaPlayer* CreateMediaPlayer(
 103       const blink::WebMediaPlayerSource& source,
 104       blink::WebMediaPlayerClient* client,
 105       blink::MediaInspectorContext* inspector_context,
 106       blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
 107       blink::WebContentDecryptionModule* initial_cdm,
 108       const blink::WebString& sink_id,
 109       viz::FrameSinkId parent_frame_sink_id,
 110       const cc::LayerTreeSettings& settings,
 111       scoped_refptr<base::SingleThreadTaskRunner>
 112           main_thread_compositor_task_runner,
 113 #if defined(TIZEN_VIDEO_HOLE)
 114       bool is_video_hole,
 115 #endif
 116       scoped_refptr<base::TaskRunner> compositor_worker_task_runner);
 117
 118   // Provides an EncryptedMediaClient to connect blink's EME layer to media's
 119   // implementation of requestMediaKeySystemAccess. Will always return the same
 120   // client whose lifetime is tied to this Factory (same as the RenderFrame).
 121   blink::WebEncryptedMediaClient* EncryptedMediaClient();
 122
 123   // Returns `DecoderFactory`, which can be used to created decoders in WebRTC.
 124   // Can be dereferenced only on the media thread.
 125   base::WeakPtr<media::DecoderFactory> GetDecoderFactory();
 126
 127  private:
 128   // Initializes `decoder_factory_` if it hasn't been initialized yet.
 129   void EnsureDecoderFactory();
 130
 131   std::unique_ptr<media::RendererFactorySelector> CreateRendererFactorySelector(
 132       media::MediaPlayerLoggingID player_id,
 133       media::MediaLog* media_log,
 134       blink::WebURL url,
 135       const RenderFrameMediaPlaybackOptions& renderer_media_playback_options,
 136       media::DecoderFactory* decoder_factory,
 137       std::unique_ptr<media::RemotePlaybackClientWrapper> client_wrapper,
 138       base::WeakPtr<media::MediaObserver>* out_media_observer);
 139
 140   blink::WebMediaPlayer* CreateWebMediaPlayerForMediaStream(
 141       blink::WebMediaPlayerClient* client,
 142       blink::MediaInspectorContext* inspector_context,
 143       const blink::WebString& sink_id,
 144       blink::WebLocalFrame* frame,
 145       viz::FrameSinkId parent_frame_sink_id,
 146       const cc::LayerTreeSettings& settings,
 147       scoped_refptr<base::SingleThreadTaskRunner>
 148           main_thread_compositor_task_runner,
 149       scoped_refptr<base::TaskRunner> compositor_worker_task_runner);
 150
 151   // Returns the media delegate for WebMediaPlayer usage.  If
 152   // |media_player_delegate_| is NULL, one is created.
 153   media::RendererWebMediaPlayerDelegate* GetWebMediaPlayerDelegate();
 154
 155   bool UseDefaultRendererForRawAudio(blink::WebURL url);
 156
 157 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
 158   media::mojom::RemoterFactory* GetRemoterFactory();
 159 #endif
 160
 161   media::CdmFactory* GetCdmFactory();
 162
 163   media::mojom::InterfaceFactory* GetMediaInterfaceFactory();
 164
 165   std::unique_ptr<media::MojoRendererFactory> CreateMojoRendererFactory();
 166
 167   // The render frame we're helping. RenderFrameImpl owns this factory, so the
 168   // pointer will always be valid.
 169   raw_ptr<RenderFrameImpl, ExperimentalRenderer> render_frame_;
 170
 171   // The media interface provider attached to this frame, lazily initialized.
 172   std::unique_ptr<MediaInterfaceFactory> media_interface_factory_;
 173
 174   // Injected callback for requesting overlay routing tokens.
 175   media::RequestRoutingTokenCallback request_routing_token_cb_;
 176
 177   // Handy pointer to RenderFrame's browser interface broker. Null until
 178   // SetupMojo(). Lifetime matches that of the owning |render_frame_|. Will
 179   // always be valid once assigned.
 180   raw_ptr<blink::BrowserInterfaceBrokerProxy, ExperimentalRenderer>
 181       interface_broker_ = nullptr;
 182
 183   // Manages play, pause notifications for WebMediaPlayer implementations; its
 184   // lifetime is tied to the RenderFrame via the RenderFrameObserver interface.
 185   raw_ptr<media::RendererWebMediaPlayerDelegate, ExperimentalRenderer>
 186       media_player_delegate_ = nullptr;
 187
 188   // The CDM and decoder factory attached to this frame, lazily initialized.
 189   std::unique_ptr<media::DefaultDecoderFactory> decoder_factory_;
 190   std::unique_ptr<media::CdmFactory> cdm_factory_;
 191
 192   // Media resource cache, lazily initialized.
 193   std::unique_ptr<blink::ResourceFetchContext> fetch_context_;
 194   std::unique_ptr<blink::UrlIndex> url_index_;
 195
 196   // EncryptedMediaClient attached to this frame; lazily initialized.
 197   std::unique_ptr<blink::WebEncryptedMediaClientImpl>
 198       web_encrypted_media_client_;
 199
 200 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
 201   // Lazy-bound remote for the RemoterFactory service in the browser
 202   // process. Always use the GetRemoterFactory() accessor instead of this.
 203   mojo::Remote<media::mojom::RemoterFactory> remoter_factory_;
 204 #endif
 205
 206 #if BUILDFLAG(ENABLE_CAST_RECEIVER)
 207   std::unique_ptr<cast_streaming::ResourceProvider>
 208       cast_streaming_resource_provider_;
 209 #endif
 210 };
 211
 212 }  // namespace content
 213
 214 #endif  // CONTENT_RENDERER_MEDIA_MEDIA_FACTORY_H_