Extract media code from RenderFrameImpl

content/renderer/media/render_media_helper.h

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_RENDERER_MEDIA_RENDER_MEDIA_HELPER_H_
+#define CONTENT_RENDERER_MEDIA_RENDER_MEDIA_HELPER_H_
+
+#include <memory>
+
+#include "base/memory/linked_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "build/buildflag.h"
+#include "media/base/renderer_factory_selector.h"
+#include "media/base/routing_token_callback.h"
+#include "media/blink/url_index.h"
+#include "media/media_features.h"
+#include "media/mojo/features.h"
+#include "media/mojo/interfaces/remoting.mojom.h"
+#include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
+#include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
+#include "third_party/WebKit/public/platform/WebSetSinkIdCallbacks.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+#include "url/gurl.h"
+
+using media::RequestRoutingTokenCallback;
+
+namespace blink {
+class WebContentDecryptionModule;
+class WebEncryptedMediaClient;
+class WebLocalFrame;
+class WebMediaPlayer;
+class WebMediaPlayerClient;
+class WebMediaPlayerEncryptedMediaClient;
+}
+
+namespace media {
+class CdmFactory;
+class DecoderFactory;
+class MediaLog;
+class MediaObserver;
+class MediaPermission;
+class RendererWebMediaPlayerDelegate;
+class SurfaceManager;
+class WebEncryptedMediaClientImpl;
+#if defined(OS_ANDROID)
+class RendererMediaPlayerManager;
+#endif
+namespace remoting {
+class SinkAvailabilityObserver;
+}
+}
+
+namespace service_manager {
+class InterfaceProvider;
+namespace mojom {
+class InterfaceProvider;
+}
+}
+
+namespace content {
+
+class RenderFrameImpl;
+class MediaInterfaceProvider;
+class MediaPermissionDispatcher;
+class MediaStreamRendererFactory;
+
+#if defined(OS_ANDROID)
+class RendererMediaPlayerManager;
+#endif
+
+// Helper to RenderFrameImpl for all things media.
+class RenderMediaHelper {
+ public:
+  // Create a RenderMediaHelper to assist the |render_frame| with media tasks.
+  // |request_routing_token_cb| bound to |render_frame| IPC functions for
+  // obtaining overlay tokens.
+  RenderMediaHelper(RenderFrameImpl* render_frame,
+                    const RequestRoutingTokenCallback request_routing_token_cb);
+  ~RenderMediaHelper();
+
+  // See blink::WebFrameClient.
+  blink::WebMediaPlayer* CreateMediaPlayer(
+      const blink::WebMediaPlayerSource& source,
+      blink::WebMediaPlayerClient* client,
+      blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
+      blink::WebContentDecryptionModule* initial_cdm,
+      const blink::WebString& sink_id);
+  blink::WebEncryptedMediaClient* EncryptedMediaClient();
+  void CheckIfAudioSinkExistsAndIsAuthorized(
+      const blink::WebString& sink_id,
+      const blink::WebSecurityOrigin& security_origin,
+      blink::WebSetSinkIdCallbacks* web_callbacks);
+
+  // Object to handle media related permission checks and requests.
+  media::MediaPermission* GetMediaPermission();
+
+ private:
+  std::unique_ptr<media::RendererFactorySelector> CreateRendererFactorySelector(
+      media::MediaLog* media_log,
+      bool use_media_player,
+      media::DecoderFactory* decoder_factory,
+      base::WeakPtr<media::MediaObserver>* out_media_observer);
+
+  blink::WebMediaPlayer* CreateWebMediaPlayerForMediaStream(
+      blink::WebMediaPlayerClient* client,
+      const blink::WebString& sink_id,
+      const blink::WebSecurityOrigin& security_origin,
+      blink::WebLocalFrame* frame);
+
+  // Returns the media delegate for WebMediaPlayer usage.  If
+  // |media_player_delegate_| is NULL, one is created.
+  media::RendererWebMediaPlayerDelegate* GetWebMediaPlayerDelegate();
+
+  // Creates a MediaStreamRendererFactory used for creating audio and video
+  // renderers for WebMediaPlayerMS.
+  std::unique_ptr<MediaStreamRendererFactory>
+  CreateMediaStreamRendererFactory();
+
+  media::DecoderFactory* GetDecoderFactory();
+
+#if defined(OS_ANDROID)
+  RendererMediaPlayerManager* GetMediaPlayerManager();
+#endif
+
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING)
+  media::mojom::RemoterFactory* GetRemoterFactory();
+#endif
+
+  bool AreSecureCodecsSupported();
+
+  media::CdmFactory* GetCdmFactory();
+
+#if BUILDFLAG(ENABLE_MOJO_MEDIA)
+  service_manager::mojom::InterfaceProvider* GetMediaInterfaceProvider();
+
+  // The media interface provider attached to this frame, lazily initialized.
+  std::unique_ptr<MediaInterfaceProvider> media_interface_provider_;
+#endif
+
+  // The render frame we're helping. RenderFrameImpl creates and destroys this
+  // RenderMediaHelper, so the pointer will always be valid.
+  RenderFrameImpl* render_frame_;
+
+  // Injected callback for requesting overlay routing tokens.
+  RequestRoutingTokenCallback request_routing_token_cb_;
+
+  // Handy pointer to render_frame_->GetRemoteInterfaces();
+  service_manager::InterfaceProvider* remote_interfaces_;
+
+#if defined(OS_ANDROID)
+  // Manages all media players and sessions in this render frame for
+  // communicating with the real media player and sessions in the

[tguilbert, 2017/05/25 00:35:39]

This comment is out of date. The RendererMediaPlayerManager is only used in the
WebMediaPlayerCast scenario at the moment. I think the following would be more
accurate:

Manages media players and sessions in this render frame for communicating with
the real media player and sessions in the browser process.
NOTE: This currently only being used in the case where we are casting. See also
WebMediaPlayerCast (renderer side) and RemoteMediaPlayerManager (browser side).

[chcunningham, 2017/05/25 01:18:50]

Done.

+  // browser process. It's okay to use raw pointers since they're both
+  // RenderFrameObservers.
+  RendererMediaPlayerManager* media_player_manager_;
+#endif
+
+  media::SurfaceManager* media_surface_manager_;
+
+  // Manages play, pause notifications for WebMediaPlayer implementations; its
+  // lifetime is tied to the RenderFrame via the RenderFrameObserver interface.
+  media::RendererWebMediaPlayerDelegate* media_player_delegate_;
+
+  // The CDM and decoder factory attached to this frame, lazily initialized.
+  std::unique_ptr<media::DecoderFactory> decoder_factory_;
+  std::unique_ptr<media::CdmFactory> cdm_factory_;
+
+  // Media resource cache, lazily initialized.
+  linked_ptr<media::UrlIndex> url_index_;
+
+  // EncryptedMediaClient attached to this frame; lazily initialized.
+  std::unique_ptr<media::WebEncryptedMediaClientImpl>
+      web_encrypted_media_client_;
+
+  // The media permission dispatcher attached to this frame.
+  std::unique_ptr<MediaPermissionDispatcher> media_permission_dispatcher_;
+
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING)
+  // Lazy-bound pointer to the RemoterFactory service in the browser
+  // process. Always use the GetRemoterFactory() accessor instead of this.
+  media::mojom::RemoterFactoryPtr remoter_factory_;
+
+  // An observer for the remoting sink availability that is used by
+  // media::RemotingCdmFactory to initialize media::RemotingSourceImpl. Created
+  // in the constructor of RenderFrameImpl to make sure
+  // media::RemotingSourceImpl be intialized with correct availability info.
+  // Own by media::RemotingCdmFactory after it is created.
+  std::unique_ptr<media::remoting::SinkAvailabilityObserver>
+      remoting_sink_observer_;
+#endif
+};
+
+}  // namespace media
+
+#endif  // CONTENT_RENDERER_MEDIA_RENDER_MEDIA_HELPER_H_