Move MediaStream renderer interfaces to Blink

This CL moves MediaStreamAudioRenderer, MediaStreamVideoRenderer
and MediaStreamRendererFactory from content/public/renderer
to blink/public/platform/modules/mediastream

All three interfaces get a Web prefix since they are intended to
remain in public/platform, as they come form content/public/renderer.

This is a straightforward move and rename and all changes outside
third_party/blink are mechanical (#include, namespace and type name
updates).

Bug: 921006
Change-Id: I1568e58ccaf8d4581ce8bc4ebdae199c3e67366d
TBR: haraken@chromium.org
Reviewed-on: https://chromium-review.googlesource.com/c/1450128
Commit-Queue: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#633759}

content/public/renderer/BUILD.gn

@@ -42,10 +42,7 @@ target(link_target_type, "renderer_sources") {
     "document_state.h",
     "fixed_received_data.cc",
     "fixed_received_data.h",
-    "media_stream_audio_renderer.h",
-    "media_stream_renderer_factory.h",
     "media_stream_utils.h",
-    "media_stream_video_renderer.h",
     "pepper_plugin_instance.h",
     "plugin_instance_throttler.h",
     "render_accessibility.h",

content/public/renderer/content_renderer_client.cc

@@ -4,8 +4,8 @@
 
 #include "content/public/renderer/content_renderer_client.h"
 
-#include "content/public/renderer/media_stream_renderer_factory.h"
 #include "media/base/renderer_factory.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_renderer_factory.h"
 #include "third_party/blink/public/platform/web_audio_device.h"
 #include "third_party/blink/public/platform/web_media_stream_center.h"
 #include "third_party/blink/public/platform/web_rtc_peer_connection_handler.h"
@@ -180,7 +180,7 @@ bool ContentRendererClient::IsSupportedBitstreamAudioCodec(
   return false;
 }
 
-std::unique_ptr<MediaStreamRendererFactory>
+std::unique_ptr<blink::WebMediaStreamRendererFactory>
 ContentRendererClient::CreateMediaStreamRendererFactory() {
   return nullptr;
 }

content/public/renderer/content_renderer_client.h

@@ -46,6 +46,7 @@ class WebPlugin;
 class WebPrescientNetworking;
 class WebSpeechSynthesizer;
 class WebSpeechSynthesizerClient;
+class WebMediaStreamRendererFactory;
 class WebThemeEngine;
 class WebURL;
 class WebURLRequest;
@@ -60,7 +61,6 @@ class KeySystemProperties;
 
 namespace content {
 class BrowserPluginDelegate;
-class MediaStreamRendererFactory;
 class RenderFrame;
 class RenderView;
 struct WebPluginInfo;
@@ -259,8 +259,8 @@ class CONTENT_EXPORT ContentRendererClient {
   // language.
   virtual bool IsOriginIsolatedPepperPlugin(const base::FilePath& plugin_path);
 
-  // Allows an embedder to provide a MediaStreamRendererFactory.
-  virtual std::unique_ptr<MediaStreamRendererFactory>
+  // Allows an embedder to provide a blink::WebMediaStreamRendererFactory.
+  virtual std::unique_ptr<blink::WebMediaStreamRendererFactory>
   CreateMediaStreamRendererFactory();
 
   // Allows embedder to register the key system(s) it supports by populating

content/renderer/media/media_factory.cc

@@ -599,14 +599,13 @@ MediaFactory::GetWebMediaPlayerDelegate() {
   return media_player_delegate_;
 }
 
-std::unique_ptr<MediaStreamRendererFactory>
+std::unique_ptr<blink::WebMediaStreamRendererFactory>
 MediaFactory::CreateMediaStreamRendererFactory() {
-  std::unique_ptr<MediaStreamRendererFactory> factory =
+  std::unique_ptr<blink::WebMediaStreamRendererFactory> factory =
       GetContentClient()->renderer()->CreateMediaStreamRendererFactory();
   if (factory.get())
     return factory;
-  return std::unique_ptr<MediaStreamRendererFactory>(
-      new MediaStreamRendererFactoryImpl());
+  return std::make_unique<MediaStreamRendererFactoryImpl>();
 }
 
 media::DecoderFactory* MediaFactory::GetDecoderFactory() {

content/renderer/media/media_factory.h

@@ -33,6 +33,7 @@ class WebLocalFrame;
 class WebMediaPlayer;
 class WebMediaPlayerClient;
 class WebMediaPlayerEncryptedMediaClient;
+class WebMediaStreamRendererFactory;
 }
 
 namespace cc {
@@ -60,7 +61,6 @@ namespace content {
 
 class RenderFrameImpl;
 class MediaInterfaceFactory;
-class MediaStreamRendererFactory;
 
 // Assist to RenderFrameImpl in creating various media clients.
 class MediaFactory {
@@ -135,9 +135,9 @@ class MediaFactory {
   // |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>
+  // Creates a blink::WebMediaStreamRendererFactory used for creating audio and
+  // video renderers for WebMediaPlayerMS.
+  std::unique_ptr<blink::WebMediaStreamRendererFactory>
   CreateMediaStreamRendererFactory();
 
   media::DecoderFactory* GetDecoderFactory();

content/renderer/media/stream/media_stream_renderer_factory_impl.cc

@@ -50,11 +50,11 @@ MediaStreamRendererFactoryImpl::MediaStreamRendererFactoryImpl() {
 MediaStreamRendererFactoryImpl::~MediaStreamRendererFactoryImpl() {
 }
 
-scoped_refptr<MediaStreamVideoRenderer>
+scoped_refptr<blink::WebMediaStreamVideoRenderer>
 MediaStreamRendererFactoryImpl::GetVideoRenderer(
     const blink::WebMediaStream& web_stream,
     const base::Closure& error_cb,
-    const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+    const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner) {
   DCHECK(!web_stream.IsNull());
@@ -74,7 +74,7 @@ MediaStreamRendererFactoryImpl::GetVideoRenderer(
                                           std::move(main_render_task_runner));
 }
 
-scoped_refptr<MediaStreamAudioRenderer>
+scoped_refptr<blink::WebMediaStreamAudioRenderer>
 MediaStreamRendererFactoryImpl::GetAudioRenderer(
     const blink::WebMediaStream& web_stream,
     int render_frame_id,

content/renderer/media/stream/media_stream_renderer_factory_impl.h

@@ -8,24 +8,25 @@
 #include <string>
 
 #include "base/macros.h"
-#include "content/public/renderer/media_stream_renderer_factory.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_renderer_factory.h"
 
 namespace content {
 
-class MediaStreamRendererFactoryImpl : public MediaStreamRendererFactory {
+class MediaStreamRendererFactoryImpl
+    : public blink::WebMediaStreamRendererFactory {
  public:
   MediaStreamRendererFactoryImpl();
   ~MediaStreamRendererFactoryImpl() override;
 
-  scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
+  scoped_refptr<blink::WebMediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
-      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+      const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner)
       override;
 
-  scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> GetAudioRenderer(
       const blink::WebMediaStream& web_stream,
       int render_frame_id,
       const std::string& device_id) override;

content/renderer/media/stream/media_stream_video_renderer_sink.h

@@ -10,9 +10,9 @@
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "content/common/content_export.h"
-#include "content/public/renderer/media_stream_video_renderer.h"
 #include "content/renderer/media_stream_video_sink.h"
 #include "third_party/blink/public/common/media/video_capture.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_video_renderer.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
 #include "ui/gfx/geometry/size.h"
 
@@ -22,8 +22,8 @@ class SingleThreadTaskRunner;
 
 namespace content {
 
-// MediaStreamVideoRendererSink is a MediaStreamVideoRenderer designed for
-// rendering Video MediaStreamTracks [1], MediaStreamVideoRendererSink
+// MediaStreamVideoRendererSink is a blink::WebMediaStreamVideoRenderer designed
+// for rendering Video MediaStreamTracks [1], MediaStreamVideoRendererSink
 // implements MediaStreamVideoSink in order to render video frames provided from
 // a MediaStreamVideoTrack, to which it connects itself when the
 // MediaStreamVideoRenderer is Start()ed, and disconnects itself when the latter
@@ -35,17 +35,18 @@ namespace content {
 // https://src.chromium.org/viewvc/chrome/trunk/src/content/renderer/media/rtc_
 // video_decoder_unittest.cc?revision=180591&view=markup
 class CONTENT_EXPORT MediaStreamVideoRendererSink
-    : public MediaStreamVideoRenderer,
+    : public blink::WebMediaStreamVideoRenderer,
       public MediaStreamVideoSink {
  public:
   MediaStreamVideoRendererSink(
       const blink::WebMediaStreamTrack& video_track,
       const base::Closure& error_cb,
-      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+      const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner);
 
-  // MediaStreamVideoRenderer implementation. Called on the main thread.
+  // blink::WebMediaStreamVideoRenderer implementation. Called on the main
+  // thread.
   void Start() override;
   void Stop() override;
   void Resume() override;

content/renderer/media/stream/track_audio_renderer.h

@@ -17,8 +17,8 @@
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "content/common/content_export.h"
-#include "content/public/renderer/media_stream_audio_renderer.h"
 #include "media/base/audio_renderer_sink.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_audio_renderer.h"
 #include "third_party/blink/public/platform/modules/mediastream/web_media_stream_audio_sink.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
 
@@ -30,12 +30,13 @@ class AudioParameters;
 
 namespace content {
 
-// TrackAudioRenderer is a MediaStreamAudioRenderer for plumbing audio data
-// generated from either local or remote (but not PeerConnection/WebRTC-sourced)
-// MediaStreamAudioTracks to an audio output device, reconciling differences in
-// the rates of production and consumption of the audio data.  Note that remote
-// PeerConnection-sourced tracks are NOT rendered by this implementation (see
-// MediaStreamRendererFactoryImpl).
+// TrackAudioRenderer is a blink::WebMediaStreamAudioRenderer for plumbing audio
+// data generated from either local or remote (but not
+// PeerConnection/WebRTC-sourced) MediaStreamAudioTracks to an audio output
+// device, reconciling differences in the rates of production and consumption of
+// the audio data.  Note that remote PeerConnection-sourced tracks are NOT
+// rendered by this implementation (see
+// blink::WebMediaStreamRendererFactoryImpl).
 //
 // This class uses AudioDeviceFactory to create media::AudioRendererSink and
 // owns/manages their lifecycles.  Output devices are automatically re-created
@@ -50,7 +51,7 @@ namespace content {
 // and skip audio to maintain time synchronization between the producer and
 // consumer.
 class CONTENT_EXPORT TrackAudioRenderer
-    : public MediaStreamAudioRenderer,
+    : public blink::WebMediaStreamAudioRenderer,
       public blink::WebMediaStreamAudioSink,
       public media::AudioRendererSink::RenderCallback {
  public:
@@ -66,7 +67,7 @@ class CONTENT_EXPORT TrackAudioRenderer
                      int session_id,
                      const std::string& device_id);
 
-  // MediaStreamAudioRenderer implementation.
+  // blink::WebMediaStreamAudioRenderer implementation.
   // Called on the main thread.
   void Start() override;
   void Stop() override;

content/renderer/media/stream/webmediaplayer_ms.cc

@@ -15,9 +15,6 @@
 #include "cc/layers/video_frame_provider_client_impl.h"
 #include "cc/layers/video_layer.h"
 #include "content/child/child_process.h"
-#include "content/public/renderer/media_stream_audio_renderer.h"
-#include "content/public/renderer/media_stream_renderer_factory.h"
-#include "content/public/renderer/media_stream_video_renderer.h"
 #include "content/renderer/media/stream/media_stream_video_track.h"
 #include "content/renderer/media/stream/webmediaplayer_ms_compositor.h"
 #include "content/renderer/media/web_media_element_source_utils.h"
@@ -34,6 +31,9 @@
 #include "media/video/gpu_memory_buffer_video_frame_pool.h"
 #include "services/ws/public/cpp/gpu/context_provider_command_buffer.h"
 #include "third_party/blink/public/platform/modules/mediastream/media_stream_audio_track.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_audio_renderer.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_renderer_factory.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_video_renderer.h"
 #include "third_party/blink/public/platform/web_media_player_client.h"
 #include "third_party/blink/public/platform/web_media_player_source.h"
 #include "third_party/blink/public/platform/web_rect.h"
@@ -76,11 +76,12 @@ const gfx::Size WebMediaPlayerMS::kUseGpuMemoryBufferVideoFramesMinResolution =
 // should be destructed on the IO thread.
 class WebMediaPlayerMS::FrameDeliverer {
  public:
-  FrameDeliverer(const base::WeakPtr<WebMediaPlayerMS>& player,
-                 const MediaStreamVideoRenderer::RepaintCB& enqueue_frame_cb,
-                 scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
-                 scoped_refptr<base::TaskRunner> worker_task_runner,
-                 media::GpuVideoAcceleratorFactories* gpu_factories)
+  FrameDeliverer(
+      const base::WeakPtr<WebMediaPlayerMS>& player,
+      const blink::WebMediaStreamVideoRenderer::RepaintCB& enqueue_frame_cb,
+      scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
+      scoped_refptr<base::TaskRunner> worker_task_runner,
+      media::GpuVideoAcceleratorFactories* gpu_factories)
       : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         player_(player),
         enqueue_frame_cb_(enqueue_frame_cb),
@@ -160,7 +161,7 @@ class WebMediaPlayerMS::FrameDeliverer {
     render_frame_suspended_ = render_frame_suspended;
   }
 
-  MediaStreamVideoRenderer::RepaintCB GetRepaintCallback() {
+  blink::WebMediaStreamVideoRenderer::RepaintCB GetRepaintCallback() {
     return base::Bind(&FrameDeliverer::OnVideoFrame,
                       weak_factory_.GetWeakPtr());
   }
@@ -210,7 +211,7 @@ class WebMediaPlayerMS::FrameDeliverer {
 
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const base::WeakPtr<WebMediaPlayerMS> player_;
-  const MediaStreamVideoRenderer::RepaintCB enqueue_frame_cb_;
+  const blink::WebMediaStreamVideoRenderer::RepaintCB enqueue_frame_cb_;
 
   // Pool of GpuMemoryBuffers and resources used to create hardware frames.
   std::unique_ptr<media::GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_;
@@ -230,7 +231,7 @@ WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebMediaPlayerClient* client,
     media::WebMediaPlayerDelegate* delegate,
     std::unique_ptr<media::MediaLog> media_log,
-    std::unique_ptr<MediaStreamRendererFactory> factory,
+    std::unique_ptr<blink::WebMediaStreamRendererFactory> factory,
     scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,

content/renderer/media/stream/webmediaplayer_ms.h

@@ -27,6 +27,9 @@
 namespace blink {
 class WebLocalFrame;
 class WebMediaPlayerClient;
+class WebMediaStreamAudioRenderer;
+class WebMediaStreamRendererFactory;
+class WebMediaStreamVideoRenderer;
 class WebString;
 class WebVideoFrameSubmitter;
 }
@@ -52,9 +55,6 @@ using CreateSurfaceLayerBridgeCB =
         blink::WebSurfaceLayerBridgeObserver*,
         cc::UpdateSubmissionStateCB)>;
 
-class MediaStreamAudioRenderer;
-class MediaStreamRendererFactory;
-class MediaStreamVideoRenderer;
 class WebMediaPlayerMSCompositor;
 
 // WebMediaPlayerMS delegates calls from WebCore::MediaPlayerPrivate to
@@ -65,7 +65,7 @@ class WebMediaPlayerMSCompositor;
 //
 // WebMediaPlayerMS works with multiple objects, the most important ones are:
 //
-// MediaStreamVideoRenderer
+// blink::WebMediaStreamVideoRenderer
 //   provides video frames for rendering.
 //
 // blink::WebMediaPlayerClient
@@ -78,14 +78,14 @@ class CONTENT_EXPORT WebMediaPlayerMS
       public base::SupportsWeakPtr<WebMediaPlayerMS> {
  public:
   // Construct a WebMediaPlayerMS with reference to the client, and
-  // a MediaStreamClient which provides MediaStreamVideoRenderer.
+  // a MediaStreamClient which provides blink::WebMediaStreamVideoRenderer.
   // |delegate| must not be null.
   WebMediaPlayerMS(
       blink::WebLocalFrame* frame,
       blink::WebMediaPlayerClient* client,
       media::WebMediaPlayerDelegate* delegate,
       std::unique_ptr<media::MediaLog> media_log,
-      std::unique_ptr<MediaStreamRendererFactory> factory,
+      std::unique_ptr<blink::WebMediaStreamRendererFactory> factory,
       scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
@@ -299,11 +299,12 @@ class CONTENT_EXPORT WebMediaPlayerMS
   class FrameDeliverer;
   std::unique_ptr<FrameDeliverer> frame_deliverer_;
 
-  scoped_refptr<MediaStreamVideoRenderer> video_frame_provider_;  // Weak
+  scoped_refptr<blink::WebMediaStreamVideoRenderer>
+      video_frame_provider_;  // Weak
 
   scoped_refptr<cc::VideoLayer> video_layer_;
 
-  scoped_refptr<MediaStreamAudioRenderer> audio_renderer_;  // Weak
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> audio_renderer_;  // Weak
   media::PaintCanvasVideoRenderer video_renderer_;
 
   bool paused_;
@@ -311,7 +312,7 @@ class CONTENT_EXPORT WebMediaPlayerMS
 
   std::unique_ptr<media::MediaLog> media_log_;
 
-  std::unique_ptr<MediaStreamRendererFactory> renderer_factory_;
+  std::unique_ptr<blink::WebMediaStreamRendererFactory> renderer_factory_;
 
   const scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;

content/renderer/media/stream/webmediaplayer_ms_unittest.cc

@@ -17,7 +17,6 @@
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "cc/layers/layer.h"
-#include "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/renderer/media/stream/webmediaplayer_ms.h"
 #include "content/renderer/media/stream/webmediaplayer_ms_compositor.h"
 #include "content/renderer/render_frame_impl.h"
@@ -26,6 +25,7 @@
 #include "media/base/video_frame.h"
 #include "media/video/mock_gpu_memory_buffer_video_frame_pool.h"
 #include "media/video/mock_gpu_video_accelerator_factories.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_renderer_factory.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "third_party/blink/public/platform/web_fullscreen_video_status.h"
 #include "third_party/blink/public/platform/web_media_player.h"
@@ -197,13 +197,13 @@ class ReusableMessageLoopEvent {
 };
 
 // The class is used mainly to inject VideoFrames into WebMediaPlayerMS.
-class MockMediaStreamVideoRenderer : public MediaStreamVideoRenderer {
+class MockMediaStreamVideoRenderer : public blink::WebMediaStreamVideoRenderer {
  public:
   MockMediaStreamVideoRenderer(
       const scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       ReusableMessageLoopEvent* message_loop_controller,
       const base::Closure& error_cb,
-      const MediaStreamVideoRenderer::RepaintCB& repaint_cb)
+      const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb)
       : started_(false),
         standard_size_(kStandardWidth, kStandardHeight),
         task_runner_(task_runner),
@@ -213,7 +213,7 @@ class MockMediaStreamVideoRenderer : public MediaStreamVideoRenderer {
         delay_till_next_generated_frame_(
             base::TimeDelta::FromSecondsD(1.0 / 30.0)) {}
 
-  // Implementation of MediaStreamVideoRenderer
+  // Implementation of blink::WebMediaStreamVideoRenderer
   void Start() override;
   void Stop() override;
   void Resume() override;
@@ -248,13 +248,13 @@ class MockMediaStreamVideoRenderer : public MediaStreamVideoRenderer {
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   ReusableMessageLoopEvent* const message_loop_controller_;
   const base::Closure error_cb_;
-  const MediaStreamVideoRenderer::RepaintCB repaint_cb_;
+  const blink::WebMediaStreamVideoRenderer::RepaintCB repaint_cb_;
 
   base::circular_deque<TestFrame> frames_;
   base::TimeDelta delay_till_next_generated_frame_;
 };
 
-class MockMediaStreamAudioRenderer : public MediaStreamAudioRenderer {
+class MockMediaStreamAudioRenderer : public blink::WebMediaStreamAudioRenderer {
  public:
   MockMediaStreamAudioRenderer() {}
 
@@ -425,7 +425,7 @@ class MockWebVideoFrameSubmitter : public blink::WebVideoFrameSubmitter {
 
 // The class is used to generate a MockVideoProvider in
 // WebMediaPlayerMS::load().
-class MockRenderFactory : public MediaStreamRendererFactory {
+class MockRenderFactory : public blink::WebMediaStreamRendererFactory {
  public:
   MockRenderFactory(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
@@ -433,10 +433,10 @@ class MockRenderFactory : public MediaStreamRendererFactory {
       : task_runner_(task_runner),
         message_loop_controller_(message_loop_controller) {}
 
-  scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
+  scoped_refptr<blink::WebMediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
-      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+      const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner)
       override;
@@ -445,14 +445,15 @@ class MockRenderFactory : public MediaStreamRendererFactory {
     return static_cast<MockMediaStreamVideoRenderer*>(provider_.get());
   }
 
-  scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> GetAudioRenderer(
       const blink::WebMediaStream& web_stream,
       int render_frame_id,
       const std::string& device_id) override {
     return audio_renderer_;
   }
 
-  void set_audio_renderer(scoped_refptr<MediaStreamAudioRenderer> renderer) {
+  void set_audio_renderer(
+      scoped_refptr<blink::WebMediaStreamAudioRenderer> renderer) {
     audio_renderer_ = std::move(renderer);
   }
 
@@ -465,16 +466,17 @@ class MockRenderFactory : public MediaStreamRendererFactory {
 
  private:
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  scoped_refptr<MediaStreamVideoRenderer> provider_;
+  scoped_refptr<blink::WebMediaStreamVideoRenderer> provider_;
   ReusableMessageLoopEvent* const message_loop_controller_;
   bool support_video_renderer_ = true;
-  scoped_refptr<MediaStreamAudioRenderer> audio_renderer_;
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> audio_renderer_;
 };
 
-scoped_refptr<MediaStreamVideoRenderer> MockRenderFactory::GetVideoRenderer(
+scoped_refptr<blink::WebMediaStreamVideoRenderer>
+MockRenderFactory::GetVideoRenderer(
     const blink::WebMediaStream& web_stream,
     const base::Closure& error_cb,
-    const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+    const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner) {
   if (!support_video_renderer_)
@@ -489,8 +491,8 @@ scoped_refptr<MediaStreamVideoRenderer> MockRenderFactory::GetVideoRenderer(
 // This is the main class coordinating the tests.
 // Basic workflow:
 // 1. WebMediaPlayerMS::Load will generate and start
-// content::MediaStreamVideoRenderer.
-// 2. content::MediaStreamVideoRenderer will start pushing frames into
+// blink::WebMediaStreamVideoRenderer.
+// 2. blink::WebMediaStreamVideoRenderer will start pushing frames into
 //    WebMediaPlayerMS repeatedly.
 // 3. On WebMediaPlayerMS receiving the first frame, a cc::Layer will be
 //    created.
@@ -501,7 +503,7 @@ scoped_refptr<MediaStreamVideoRenderer> MockRenderFactory::GetVideoRenderer(
 //    WebMediaPlayerMSCompositor::UpdateCurrentFrame, GetCurrentFrame for
 //    rendering repeatedly.
 // 6. When WebMediaPlayerMS::pause gets called, it should trigger
-//    content::MediaStreamVideoRenderer::Pause, and then the provider will stop
+//    blink::WebMediaStreamVideoRenderer::Pause, and then the provider will stop
 //    pushing frames into WebMediaPlayerMS, but instead digesting them;
 //    simultanously, it should call cc::VideoFrameProviderClient::StopRendering,
 //    so cc::VideoFrameProviderClient will stop asking frames from
@@ -663,7 +665,7 @@ void WebMediaPlayerMSTest::InitializeWebMediaPlayerMS() {
           : blink::WebMediaPlayer::SurfaceLayerMode::kNever;
   player_ = std::make_unique<WebMediaPlayerMS>(
       nullptr, this, &delegate_, std::make_unique<media::NullMediaLog>(),
-      std::unique_ptr<MediaStreamRendererFactory>(render_factory_),
+      std::unique_ptr<blink::WebMediaStreamRendererFactory>(render_factory_),
       blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
       blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
       blink::scheduler::GetSingleThreadTaskRunnerForTesting(),
@@ -818,7 +820,7 @@ TEST_P(WebMediaPlayerMSTest, NoDataDuringLoadForVideo) {
 TEST_P(WebMediaPlayerMSTest, NoWaitForFrameForAudio) {
   InitializeWebMediaPlayerMS();
   is_audio_element_ = true;
-  scoped_refptr<MediaStreamAudioRenderer> audio_renderer(
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> audio_renderer(
       new MockMediaStreamAudioRenderer());
   render_factory_->set_audio_renderer(audio_renderer);
   EXPECT_CALL(*this, DoNetworkStateChanged(
@@ -845,7 +847,7 @@ TEST_P(WebMediaPlayerMSTest, NoWaitForFrameForAudio) {
 TEST_P(WebMediaPlayerMSTest, NoWaitForFrameForAudioOnly) {
   InitializeWebMediaPlayerMS();
   render_factory_->set_support_video_renderer(false);
-  scoped_refptr<MediaStreamAudioRenderer> audio_renderer(
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> audio_renderer(
       new MockMediaStreamAudioRenderer());
   render_factory_->set_audio_renderer(audio_renderer);
   EXPECT_CALL(*this, DoReadyStateChanged(

content/renderer/media/webrtc/webrtc_audio_renderer.cc

@@ -46,7 +46,7 @@ const int kRenderTimeHistogramMaxMicroseconds = 1 * 1000 * 1000;  // 1 second
 // and 'started' states to avoid problems related to incorrect usage which
 // might violate the implementation assumptions inside WebRtcAudioRenderer
 // (see the play reference count).
-class SharedAudioRenderer : public MediaStreamAudioRenderer {
+class SharedAudioRenderer : public blink::WebMediaStreamAudioRenderer {
  public:
   // Callback definition for a callback that is called when when Play(), Pause()
   // or SetVolume are called (whenever the internal |playing_state_| changes).
@@ -59,10 +59,11 @@ class SharedAudioRenderer : public MediaStreamAudioRenderer {
   using OnPlayStateRemoved =
       base::OnceCallback<void(WebRtcAudioRenderer::PlayingState*)>;
 
-  SharedAudioRenderer(const scoped_refptr<MediaStreamAudioRenderer>& delegate,
-                      const blink::WebMediaStream& media_stream,
-                      const OnPlayStateChanged& on_play_state_changed,
-                      OnPlayStateRemoved on_play_state_removed)
+  SharedAudioRenderer(
+      const scoped_refptr<blink::WebMediaStreamAudioRenderer>& delegate,
+      const blink::WebMediaStream& media_stream,
+      const OnPlayStateChanged& on_play_state_changed,
+      OnPlayStateRemoved on_play_state_removed)
       : delegate_(delegate),
         media_stream_(media_stream),
         started_(false),
@@ -138,7 +139,7 @@ class SharedAudioRenderer : public MediaStreamAudioRenderer {
 
  private:
   THREAD_CHECKER(thread_checker_);
-  const scoped_refptr<MediaStreamAudioRenderer> delegate_;
+  const scoped_refptr<blink::WebMediaStreamAudioRenderer> delegate_;
   const blink::WebMediaStream media_stream_;
   bool started_;
   WebRtcAudioRenderer::PlayingState playing_state_;
@@ -217,7 +218,7 @@ bool WebRtcAudioRenderer::Initialize(WebRtcAudioRendererSource* source) {
   return true;
 }
 
-scoped_refptr<MediaStreamAudioRenderer>
+scoped_refptr<blink::WebMediaStreamAudioRenderer>
 WebRtcAudioRenderer::CreateSharedAudioRendererProxy(
     const blink::WebMediaStream& media_stream) {
   SharedAudioRenderer::OnPlayStateChanged on_play_state_changed =

content/renderer/media/webrtc/webrtc_audio_renderer.h

@@ -18,12 +18,12 @@
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
-#include "content/public/renderer/media_stream_audio_renderer.h"
 #include "content/renderer/media/webrtc/webrtc_audio_device_impl.h"
 #include "media/base/audio_decoder.h"
 #include "media/base/audio_pull_fifo.h"
 #include "media/base/audio_renderer_sink.h"
 #include "media/base/channel_layout.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_audio_renderer.h"
 #include "third_party/blink/public/platform/web_media_stream.h"
 
 namespace webrtc {
@@ -38,7 +38,7 @@ class WebRtcAudioRendererSource;
 // for connecting WebRtc MediaStream with the audio pipeline.
 class CONTENT_EXPORT WebRtcAudioRenderer
     : public media::AudioRendererSink::RenderCallback,
-      public MediaStreamAudioRenderer {
+      public blink::WebMediaStreamAudioRenderer {
  public:
   // This is a little utility class that holds the configured state of an audio
   // stream.
@@ -98,8 +98,8 @@ class CONTENT_EXPORT WebRtcAudioRenderer
   // When Stop() is called or when the proxy goes out of scope, the proxy
   // will ensure that Pause() is called followed by a call to Stop(), which
   // is the usage pattern that WebRtcAudioRenderer requires.
-  scoped_refptr<MediaStreamAudioRenderer> CreateSharedAudioRendererProxy(
-      const blink::WebMediaStream& media_stream);
+  scoped_refptr<blink::WebMediaStreamAudioRenderer>
+  CreateSharedAudioRendererProxy(const blink::WebMediaStream& media_stream);
 
   // Used to DCHECK on the expected state.
   bool IsStarted() const;
@@ -113,9 +113,10 @@ class CONTENT_EXPORT WebRtcAudioRenderer
   bool CurrentThreadIsRenderingThread();
 
  private:
-  // MediaStreamAudioRenderer implementation.  This is private since we want
-  // callers to use proxy objects.
-  // TODO(tommi): Make the MediaStreamAudioRenderer implementation a pimpl?
+  // blink::WebMediaStreamAudioRenderer implementation.  This is private since
+  // we want callers to use proxy objects.
+  // TODO(tommi): Make the blink::WebMediaStreamAudioRenderer implementation a
+  // pimpl?
   void Start() override;
   void Play() override;
   void Pause() override;

content/renderer/media/webrtc/webrtc_audio_renderer_unittest.cc

@@ -13,13 +13,13 @@
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
-#include "content/public/renderer/media_stream_audio_renderer.h"
 #include "content/renderer/media/audio/audio_device_factory.h"
 #include "content/renderer/media/webrtc/webrtc_audio_device_impl.h"
 #include "media/base/audio_capturer_source.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_audio_renderer.h"
 #include "third_party/blink/public/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "third_party/blink/public/platform/web_media_stream.h"
 #include "third_party/blink/public/platform/web_media_stream_track.h"
@@ -150,7 +150,7 @@ class WebRtcAudioRendererTest : public testing::Test,
   std::unique_ptr<MockAudioRendererSource> source_;
   blink::WebMediaStream stream_;
   scoped_refptr<WebRtcAudioRenderer> renderer_;
-  scoped_refptr<MediaStreamAudioRenderer> renderer_proxy_;
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> renderer_proxy_;
 };
 
 // Verify that the renderer will be stopped if the only proxy is stopped.
@@ -172,10 +172,11 @@ TEST_F(WebRtcAudioRendererTest, MultipleRenderers) {
   renderer_proxy_->Start();
 
   // Create a vector of renderer proxies from the |renderer_|.
-  std::vector<scoped_refptr<MediaStreamAudioRenderer> > renderer_proxies_;
+  std::vector<scoped_refptr<blink::WebMediaStreamAudioRenderer>>
+      renderer_proxies_;
   static const int kNumberOfRendererProxy = 5;
   for (int i = 0; i < kNumberOfRendererProxy; ++i) {
-    scoped_refptr<MediaStreamAudioRenderer> renderer_proxy(
+    scoped_refptr<blink::WebMediaStreamAudioRenderer> renderer_proxy(
         renderer_->CreateSharedAudioRendererProxy(stream_));
     renderer_proxy->Start();
     renderer_proxies_.push_back(renderer_proxy);

content/shell/renderer/web_test/test_media_stream_renderer_factory.cc

@@ -34,11 +34,11 @@ TestMediaStreamRendererFactory::TestMediaStreamRendererFactory() {}
 
 TestMediaStreamRendererFactory::~TestMediaStreamRendererFactory() {}
 
-scoped_refptr<MediaStreamVideoRenderer>
+scoped_refptr<blink::WebMediaStreamVideoRenderer>
 TestMediaStreamRendererFactory::GetVideoRenderer(
     const blink::WebMediaStream& web_stream,
     const base::Closure& error_cb,
-    const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+    const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner) {
   if (!IsMockMediaStreamWithVideo(web_stream))
@@ -51,7 +51,7 @@ TestMediaStreamRendererFactory::GetVideoRenderer(
       repaint_cb);
 }
 
-scoped_refptr<MediaStreamAudioRenderer>
+scoped_refptr<blink::WebMediaStreamAudioRenderer>
 TestMediaStreamRendererFactory::GetAudioRenderer(
     const blink::WebMediaStream& web_stream,
     int render_frame_id,

content/shell/renderer/web_test/test_media_stream_renderer_factory.h

@@ -8,27 +8,28 @@
 #include <string>
 
 #include "base/callback_forward.h"
-#include "content/public/renderer/media_stream_renderer_factory.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_renderer_factory.h"
 
 namespace content {
 
 // TestMediaStreamClient is a mock implementation of MediaStreamClient used when
 // running web tests.
-class TestMediaStreamRendererFactory : public MediaStreamRendererFactory {
+class TestMediaStreamRendererFactory
+    : public blink::WebMediaStreamRendererFactory {
  public:
   TestMediaStreamRendererFactory();
   ~TestMediaStreamRendererFactory() override;
 
   // MediaStreamRendererFactory implementation.
-  scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
+  scoped_refptr<blink::WebMediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
-      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+      const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner)
       override;
 
-  scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
+  scoped_refptr<blink::WebMediaStreamAudioRenderer> GetAudioRenderer(
       const blink::WebMediaStream& web_stream,
       int render_frame_id,
       const std::string& device_id) override;

content/shell/renderer/web_test/test_media_stream_video_renderer.cc

@@ -18,7 +18,7 @@ TestMediaStreamVideoRenderer::TestMediaStreamVideoRenderer(
     const gfx::Size& size,
     const base::TimeDelta& frame_duration,
     const base::Closure& error_cb,
-    const MediaStreamVideoRenderer::RepaintCB& repaint_cb)
+    const blink::WebMediaStreamVideoRenderer::RepaintCB& repaint_cb)
     : task_runner_(blink::scheduler::GetSingleThreadTaskRunnerForTesting()),
       io_task_runner_(io_task_runner),
       size_(size),

content/shell/renderer/web_test/test_media_stream_video_renderer.h

@@ -7,7 +7,7 @@
 
 #include "base/macros.h"
 #include "base/time/time.h"
-#include "content/public/renderer/media_stream_video_renderer.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_video_renderer.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace base {
@@ -16,12 +16,12 @@ class SingleThreadTaskRunner;
 
 namespace content {
 
-// A MediaStreamVideoRenderer that generates raw frames and
+// A blink::WebMediaStreamVideoRenderer that generates raw frames and
 // passes them to webmediaplayer.
 // Since non-black pixel values are required in the web test, e.g.,
 // media/video-capture-canvas.html, this class should generate frame with
 // only non-black pixels.
-class TestMediaStreamVideoRenderer : public MediaStreamVideoRenderer {
+class TestMediaStreamVideoRenderer : public blink::WebMediaStreamVideoRenderer {
  public:
   TestMediaStreamVideoRenderer(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
@@ -30,7 +30,7 @@ class TestMediaStreamVideoRenderer : public MediaStreamVideoRenderer {
       const base::Closure& error_cb,
       const RepaintCB& repaint_cb);
 
-  // MediaStreamVideoRenderer implementation.
+  // blink::WebMediaStreamVideoRenderer implementation.
   void Start() override;
   void Stop() override;
   void Resume() override;

content/shell/renderer/web_test/web_test_content_renderer_client.cc

@@ -94,9 +94,9 @@ WebThemeEngine* WebTestContentRendererClient::OverrideThemeEngine() {
       ->ThemeEngine();
 }
 
-std::unique_ptr<MediaStreamRendererFactory>
+std::unique_ptr<blink::WebMediaStreamRendererFactory>
 WebTestContentRendererClient::CreateMediaStreamRendererFactory() {
-  return std::unique_ptr<MediaStreamRendererFactory>(
+  return std::unique_ptr<blink::WebMediaStreamRendererFactory>(
       new TestMediaStreamRendererFactory());
 }
 

content/shell/renderer/web_test/web_test_content_renderer_client.h

@@ -23,8 +23,8 @@ class WebTestContentRendererClient : public ShellContentRendererClient {
   void RenderFrameCreated(RenderFrame* render_frame) override;
   void RenderViewCreated(RenderView* render_view) override;
   blink::WebThemeEngine* OverrideThemeEngine() override;
-  std::unique_ptr<MediaStreamRendererFactory> CreateMediaStreamRendererFactory()
-      override;
+  std::unique_ptr<blink::WebMediaStreamRendererFactory>
+  CreateMediaStreamRendererFactory() override;
   std::unique_ptr<content::WebSocketHandshakeThrottleProvider>
   CreateWebSocketHandshakeThrottleProvider() override;
   void DidInitializeWorkerContextOnWorkerThread(

third_party/blink/public/BUILD.gn

@@ -144,8 +144,11 @@ source_set("blink_headers") {
     "platform/modules/mediastream/media_stream_audio_track.h",
     "platform/modules/mediastream/media_stream_types.h",
     "platform/modules/mediastream/secure_display_link_tracker.h",
+    "platform/modules/mediastream/web_media_stream_audio_renderer.h",
     "platform/modules/mediastream/web_media_stream_audio_sink.h",
+    "platform/modules/mediastream/web_media_stream_renderer_factory.h",
     "platform/modules/mediastream/web_media_stream_sink.h",
+    "platform/modules/mediastream/web_media_stream_video_renderer.h",
     "platform/modules/mediastream/web_platform_media_stream_source.h",
     "platform/modules/mediastream/web_platform_media_stream_track.h",
     "platform/modules/notifications/web_notification_action.h",

content/public/renderer/media_stream_audio_renderer.h → third_party/blink/public/platform/modules/mediastream/web_media_stream_audio_renderer.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_AUDIO_RENDERER_H_
-#define CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_AUDIO_RENDERER_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_AUDIO_RENDERER_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_AUDIO_RENDERER_H_
 
 #include <string>
 
@@ -12,10 +12,10 @@
 #include "base/time/time.h"
 #include "media/base/output_device_info.h"
 
-namespace content {
+namespace blink {
 
-class MediaStreamAudioRenderer
-    : public base::RefCountedThreadSafe<MediaStreamAudioRenderer> {
+class WebMediaStreamAudioRenderer
+    : public base::RefCountedThreadSafe<WebMediaStreamAudioRenderer> {
  public:
   // Starts rendering audio.
   virtual void Start() = 0;
@@ -52,11 +52,11 @@ class MediaStreamAudioRenderer
   virtual bool IsLocalRenderer() = 0;
 
  protected:
-  friend class base::RefCountedThreadSafe<MediaStreamAudioRenderer>;
+  friend class base::RefCountedThreadSafe<WebMediaStreamAudioRenderer>;
 
-  virtual ~MediaStreamAudioRenderer() {}
+  virtual ~WebMediaStreamAudioRenderer() {}
 };
 
-}  // namespace content
+}  // namespace blink
 
-#endif  // CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_AUDIO_RENDERER_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_AUDIO_RENDERER_H_

content/public/renderer/media_stream_renderer_factory.h → third_party/blink/public/platform/modules/mediastream/web_media_stream_renderer_factory.h

@@ -2,49 +2,47 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_RENDERER_FACTORY_H_
-#define CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_RENDERER_FACTORY_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_RENDERER_FACTORY_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_RENDERER_FACTORY_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
-#include "content/public/renderer/media_stream_audio_renderer.h"
-#include "content/public/renderer/media_stream_video_renderer.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_audio_renderer.h"
+#include "third_party/blink/public/platform/modules/mediastream/web_media_stream_video_renderer.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }  // namespace base
 
 namespace blink {
-class WebMediaStream;
-}  // namespace blink
 
-namespace content {
+class WebMediaStream;
 
-// MediaStreamRendererFactory is used by WebMediaPlayerMS to create audio and
+// WebMediaStreamRendererFactory is used by WebMediaPlayerMS to create audio and
 // video feeds from a MediaStream provided an URL.
 // The factory methods are virtual in order for Blink web tests to be able to
 // override them.
-class MediaStreamRendererFactory {
+class WebMediaStreamRendererFactory {
  public:
-  virtual ~MediaStreamRendererFactory() {}
+  virtual ~WebMediaStreamRendererFactory() {}
 
-  // Returns a MediaStreamVideoRenderer that uses the given task runners.
+  // Returns a WebMediaStreamVideoRenderer that uses the given task runners.
   // |io_task_runner| is used for passing video frames.
-  virtual scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
+  virtual scoped_refptr<WebMediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
-      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
+      const WebMediaStreamVideoRenderer::RepaintCB& repaint_cb,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> main_render_task_runner) = 0;
 
-  virtual scoped_refptr<MediaStreamAudioRenderer> GetAudioRenderer(
+  virtual scoped_refptr<WebMediaStreamAudioRenderer> GetAudioRenderer(
       const blink::WebMediaStream& web_stream,
       int render_frame_id,
       const std::string& device_id) = 0;
 };
 
-}  // namespace content
+}  // namespace blink
 
-#endif  // CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_RENDERER_FACTORY_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_RENDERER_FACTORY_H_

content/public/renderer/media_stream_video_renderer.h → third_party/blink/public/platform/modules/mediastream/web_media_stream_video_renderer.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_VIDEO_RENDERER_H_
-#define CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_VIDEO_RENDERER_H_
+#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_VIDEO_RENDERER_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_VIDEO_RENDERER_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
@@ -12,13 +12,13 @@ namespace media {
 class VideoFrame;
 }
 
-namespace content {
+namespace blink {
 
 // Interface returned by MediaStreamRendererFactory that provides controls for
 // the flow of video frame callbacks being made.
 // TODO(wjia): remove ref count.
-class MediaStreamVideoRenderer
-    : public base::RefCountedThreadSafe<MediaStreamVideoRenderer> {
+class WebMediaStreamVideoRenderer
+    : public base::RefCountedThreadSafe<WebMediaStreamVideoRenderer> {
  public:
   typedef base::Callback<void(scoped_refptr<media::VideoFrame>)> RepaintCB;
 
@@ -37,12 +37,11 @@ class MediaStreamVideoRenderer
   virtual void Pause() = 0;
 
  protected:
-  friend class base::RefCountedThreadSafe<MediaStreamVideoRenderer>;
-
-  virtual ~MediaStreamVideoRenderer() {}
+  friend class base::RefCountedThreadSafe<WebMediaStreamVideoRenderer>;
 
+  virtual ~WebMediaStreamVideoRenderer() {}
 };
 
-}  // namespace content
+}  // namespace blink
 
-#endif  // CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_VIDEO_RENDERER_H_
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_MEDIASTREAM_WEB_MEDIA_STREAM_VIDEO_RENDERER_H_