Extract media code from RenderFrameImpl

content/renderer/media/media_factory.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_MEDIA_FACTORY_H_
+#define CONTENT_RENDERER_MEDIA_MEDIA_FACTORY_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;

[xhwang, 2017/05/26 22:45:36]

"aliases declared in a header file are part of that header's public API". Is
this what we want?

https://google.github.io/styleguide/cppguide.html#Aliases

[chcunningham, 2017/05/27 00:11:49]

No. Just dropped it.

+
+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 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 MediaStreamRendererFactory;
+
+#if defined(OS_ANDROID)
+class RendererMediaPlayerManager;
+#endif
+
+// Assist to RenderFrameImpl in creating various media clients.
+class MediaFactory {
+ public:
+  // Create a MediaFactory to assist the |render_frame| with media tasks.
+  // |request_routing_token_cb| bound to |render_frame| IPC functions for
+  // obtaining overlay tokens.
+  MediaFactory(RenderFrameImpl* render_frame,
+               const RequestRoutingTokenCallback request_routing_token_cb);

[xhwang, 2017/05/26 22:45:36]

You can pass the callback by value, and use std::move. Or pass by const-ref. We
pretty much never pass callbacks by const-value:

https://cs.chromium.org/chromium/src/docs/callback.md?rcl=8ae2026e07808d63a17...

[chcunningham, 2017/05/27 00:11:49]

Done. Using move. 

+  ~MediaFactory();
+
+  void SetupMojo();

[xhwang, 2017/05/26 22:45:37]

Add a comment, e.g. when this is expected to be called?

[chcunningham, 2017/05/27 00:11:49]

Done.

+
+  // 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();

[xhwang, 2017/05/26 22:45:36]

These two are not overloads and we should have some comments.

[chcunningham, 2017/05/27 00:11:49]

Done.

+
+ 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

[xhwang, 2017/05/26 22:45:36]

s/creates and destroys/owns?

[chcunningham, 2017/05/27 00:11:49]

Done.

+  // MediaFactory, 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 RenderFrame's remote interfaces. Null until SetupMojo().
+  service_manager::InterfaceProvider* remote_interfaces_;

[xhwang, 2017/05/26 22:45:36]

nit: 

service_manager::InterfaceProvider* remote_interfaces_ = nullptr;

so we don't need to worry about initializing them in the init list.

[xhwang, 2017/05/26 22:45:37]

Please document the lifetime of this raw pointer and the following raw pointers.
It seems you dropped some of the old comments.

[chcunningham, 2017/05/27 00:11:49]

Done.

[chcunningham, 2017/05/27 00:11:49]

Done.

+
+#if defined(OS_ANDROID)
+  // 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).
+  RendererMediaPlayerManager* media_player_manager_;

[xhwang, 2017/05/26 22:45:36]

I am surprised we are still keeping this :(

[chcunningham, 2017/05/27 00:11:49]

Its usage is shrinking!

+#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_;
+
+#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

[xhwang, 2017/05/26 22:45:36]

s/media/content

[chcunningham, 2017/05/27 00:11:49]

Done.

+
+#endif  // CONTENT_RENDERER_MEDIA_MEDIA_FACTORY_H_