Cleanup naming issue with content::VideoFrameProvider

The name content::VideoFrameProvider was easy to cause confusion with
cc:VideoFrameProvider. Furthermore, the methods provided in the
content::VideoFrameProvider are not specific to Video, which makes the
name somewhat unsuitable.

List of changes:
* Moved the typedef content::VideoFrameProvider::RepaintCB out to a new
  file and renamed it to VideoFrameCallback.
* Renamed interface VideoFrameProvider to PausableStream
* Renamed method Play() to Resume()

BUG=526835

Review-Url: https://codereview.chromium.org/2005053006
Cr-Commit-Position: refs/heads/master@{#398071}

content/content_renderer.gypi

@@ -93,7 +93,7 @@
       'public/renderer/resource_fetcher.h',
       'public/renderer/video_encode_accelerator.cc',
       'public/renderer/video_encode_accelerator.h',
-      'public/renderer/video_frame_provider.h',
+      'public/renderer/media_stream_video_renderer.h',
     ],
     'public_renderer_plugin_sources': [
       'public/renderer/plugin_instance_throttler.h',

content/content_shell.gypi

@@ -228,8 +228,8 @@
         'shell/renderer/layout_test/leak_detector.h',
         'shell/renderer/layout_test/test_media_stream_renderer_factory.cc',
         'shell/renderer/layout_test/test_media_stream_renderer_factory.h',
-        'shell/renderer/layout_test/test_video_frame_provider.cc',
-        'shell/renderer/layout_test/test_video_frame_provider.h',
+        'shell/renderer/layout_test/test_media_stream_video_renderer.cc',
+        'shell/renderer/layout_test/test_media_stream_video_renderer.h',
         'shell/renderer/shell_content_renderer_client.cc',
         'shell/renderer/shell_content_renderer_client.h',
         'shell/renderer/shell_render_view_observer.cc',

content/public/renderer/media_stream_renderer_factory.h

@@ -10,7 +10,7 @@
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "content/public/renderer/media_stream_audio_renderer.h"
-#include "content/public/renderer/video_frame_provider.h"
+#include "content/public/renderer/media_stream_video_renderer.h"
 #include "url/origin.h"
 
 namespace base {
@@ -36,10 +36,10 @@ class MediaStreamRendererFactory {
  public:
   virtual ~MediaStreamRendererFactory() {}
 
-  virtual scoped_refptr<VideoFrameProvider> GetVideoFrameProvider(
+  virtual scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
-      const VideoFrameProvider::RepaintCB& repaint_cb,
+      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       media::GpuVideoAcceleratorFactories* gpu_factories) = 0;

content/public/renderer/video_frame_provider.h → content/public/renderer/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_VIDEO_FRAME_PROVIDER_H_
-#define CONTENT_PUBLIC_RENDERER_VIDEO_FRAME_PROVIDER_H_
+#ifndef CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_VIDEO_RENDERER_H_
+#define CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_VIDEO_RENDERER_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
@@ -14,11 +14,11 @@ class VideoFrame;
 
 namespace content {
 
-// Define an interface to provide a sequence of video frames to clients.
+// Interface returned by MediaStreamRendererFactory that provides controls for
+// the flow of video frame callbacks being made.
 // TODO(wjia): remove ref count.
-// TODO(wjia): rename interface so it doesn't clash with cc::VideoFrameProvider.
-class VideoFrameProvider
-    : public base::RefCountedThreadSafe<VideoFrameProvider> {
+class MediaStreamVideoRenderer
+    : public base::RefCountedThreadSafe<MediaStreamVideoRenderer> {
  public:
   typedef base::Callback<void(const scoped_refptr<media::VideoFrame>&)>
       RepaintCB;
@@ -30,7 +30,7 @@ class VideoFrameProvider
   virtual void Stop() = 0;
 
   // Resume to provide video frames to the caller after being paused.
-  virtual void Play() = 0;
+  virtual void Resume() = 0;
 
   // Put the provider in pause state and the caller will not receive video
   // frames, but the provider might still generate video frames which are
@@ -38,12 +38,12 @@ class VideoFrameProvider
   virtual void Pause() = 0;
 
  protected:
-  friend class base::RefCountedThreadSafe<VideoFrameProvider>;
+  friend class base::RefCountedThreadSafe<MediaStreamVideoRenderer>;
 
-  virtual ~VideoFrameProvider() {}
+  virtual ~MediaStreamVideoRenderer() {}
 
 };
 
 }  // namespace content
 
-#endif  // CONTENT_PUBLIC_RENDERER_VIDEO_FRAME_PROVIDER_H_
+#endif  // CONTENT_PUBLIC_RENDERER_MEDIA_STREAM_VIDEO_RENDERER_H_

content/renderer/media/media_stream_renderer_factory_impl.cc

@@ -57,17 +57,17 @@ MediaStreamRendererFactoryImpl::MediaStreamRendererFactoryImpl() {
 MediaStreamRendererFactoryImpl::~MediaStreamRendererFactoryImpl() {
 }
 
-scoped_refptr<VideoFrameProvider>
-MediaStreamRendererFactoryImpl::GetVideoFrameProvider(
+scoped_refptr<MediaStreamVideoRenderer>
+MediaStreamRendererFactoryImpl::GetVideoRenderer(
     const blink::WebMediaStream& web_stream,
     const base::Closure& error_cb,
-    const VideoFrameProvider::RepaintCB& repaint_cb,
+    const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     media::GpuVideoAcceleratorFactories* gpu_factories) {
   DCHECK(!web_stream.isNull());
 
-  DVLOG(1) << "MediaStreamRendererFactoryImpl::GetVideoFrameProvider stream:"
+  DVLOG(1) << "MediaStreamRendererFactoryImpl::GetVideoRenderer stream:"
            << base::UTF16ToUTF8(base::StringPiece16(web_stream.id()));
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;

content/renderer/media/media_stream_renderer_factory_impl.h

@@ -15,10 +15,10 @@ class MediaStreamRendererFactoryImpl : public MediaStreamRendererFactory {
   MediaStreamRendererFactoryImpl();
   ~MediaStreamRendererFactoryImpl() override;
 
-  scoped_refptr<VideoFrameProvider> GetVideoFrameProvider(
+  scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
-      const VideoFrameProvider::RepaintCB& repaint_cb,
+      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       media::GpuVideoAcceleratorFactories* gpu_factories) override;

content/renderer/media/media_stream_video_renderer_sink.cc

@@ -75,7 +75,7 @@ void MediaStreamVideoRendererSink::Stop() {
   frame_size_.set_height(kMinFrameSize);
 }
 
-void MediaStreamVideoRendererSink::Play() {
+void MediaStreamVideoRendererSink::Resume() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ == PAUSED)
     state_ = STARTED;

content/renderer/media/media_stream_video_renderer_sink.h

@@ -10,8 +10,8 @@
 #include "base/memory/weak_ptr.h"
 #include "content/common/content_export.h"
 #include "content/common/media/video_capture.h"
+#include "content/public/renderer/media_stream_video_renderer.h"
 #include "content/public/renderer/media_stream_video_sink.h"
-#include "content/public/renderer/video_frame_provider.h"
 #include "media/video/gpu_memory_buffer_video_frame_pool.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "ui/gfx/geometry/size.h"
@@ -27,12 +27,12 @@ class GpuVideoAcceleratorFactories;
 
 namespace content {
 
-// MediaStreamVideoRendererSink is a VideoFrameProvider 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
-// VideoFrameProvider is Start()ed, and disconnects itself when the latter is
-// Stop()ed.
+// MediaStreamVideoRendererSink is a MediaStreamVideoRenderer 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
+// is Stop()ed.
 //
 // [1] http://dev.w3.org/2011/webrtc/editor/getusermedia.html#mediastreamtrack
 //
@@ -40,22 +40,23 @@ namespace content {
 // http://src.chromium.org/viewvc/chrome/trunk/src/content/renderer/media/rtc_vi
 // deo_decoder_unittest.cc?revision=180591&view=markup
 class CONTENT_EXPORT MediaStreamVideoRendererSink
-    : NON_EXPORTED_BASE(public VideoFrameProvider),
+    : NON_EXPORTED_BASE(public MediaStreamVideoRenderer),
       NON_EXPORTED_BASE(public MediaStreamVideoSink) {
  public:
   MediaStreamVideoRendererSink(
       const blink::WebMediaStreamTrack& video_track,
       const base::Closure& error_cb,
-      const RepaintCB& repaint_cb,
+      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       media::GpuVideoAcceleratorFactories* gpu_factories);
 
-  // VideoFrameProvider implementation. Called on the main thread.
+  // MediaStreamVideoRenderer implementation. Called on the main thread.
   void Start() override;
   void Stop() override;
-  void Play() override;
+  void Resume() override;
   void Pause() override;
+
   void SetGpuMemoryBufferVideoForTesting(
       media::GpuMemoryBufferVideoFramePool* gpu_memory_buffer_pool);
 

content/renderer/media/media_stream_video_renderer_sink_unittest.cc

@@ -108,7 +108,7 @@ TEST_F(MediaStreamVideoRendererSinkTest, StartStop) {
   media_stream_video_renderer_sink_->Pause();
   EXPECT_TRUE(IsInPausedState());
 
-  media_stream_video_renderer_sink_->Play();  // Should be called Resume().
+  media_stream_video_renderer_sink_->Resume();
   EXPECT_TRUE(IsInStartedState());
 
   media_stream_video_renderer_sink_->Stop();

content/renderer/media/webmediaplayer_ms.cc

@@ -18,7 +18,7 @@
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/public/renderer/media_stream_audio_renderer.h"
 #include "content/public/renderer/media_stream_renderer_factory.h"
-#include "content/public/renderer/video_frame_provider.h"
+#include "content/public/renderer/media_stream_video_renderer.h"
 #include "content/renderer/media/web_media_element_source_utils.h"
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
 #include "content/renderer/render_frame_impl.h"
@@ -122,7 +122,7 @@ void WebMediaPlayerMS::load(LoadType load_type,
       web_stream.isNull() ? std::string() : web_stream.id().utf8();
   media_log_->AddEvent(media_log_->CreateLoadEvent(stream_id));
 
-  video_frame_provider_ = renderer_factory_->GetVideoFrameProvider(
+  video_frame_provider_ = renderer_factory_->GetVideoRenderer(
       web_stream, base::Bind(&WebMediaPlayerMS::OnSourceError, AsWeakPtr()),
       base::Bind(&WebMediaPlayerMS::OnFrameAvailable, AsWeakPtr()),
       media_task_runner_, worker_task_runner_, gpu_factories_);
@@ -166,7 +166,7 @@ void WebMediaPlayerMS::play() {
     return;
 
   if (video_frame_provider_)
-    video_frame_provider_->Play();
+    video_frame_provider_->Resume();
 
   compositor_->StartRendering();
 

content/renderer/media/webmediaplayer_ms.h

@@ -45,7 +45,7 @@ class GLES2Interface;
 namespace content {
 class MediaStreamAudioRenderer;
 class MediaStreamRendererFactory;
-class VideoFrameProvider;
+class MediaStreamVideoRenderer;
 class WebMediaPlayerMSCompositor;
 class RenderFrameObserver;
 
@@ -57,7 +57,7 @@ class RenderFrameObserver;
 //
 // WebMediaPlayerMS works with multiple objects, the most important ones are:
 //
-// VideoFrameProvider
+// MediaStreamVideoRenderer
 //   provides video frames for rendering.
 //
 // blink::WebMediaPlayerClient
@@ -68,7 +68,7 @@ class CONTENT_EXPORT WebMediaPlayerMS
       public NON_EXPORTED_BASE(base::SupportsWeakPtr<WebMediaPlayerMS>) {
  public:
   // Construct a WebMediaPlayerMS with reference to the client, and
-  // a MediaStreamClient which provides VideoFrameProvider.
+  // a MediaStreamClient which provides MediaStreamVideoRenderer.
   WebMediaPlayerMS(
       blink::WebFrame* frame,
       blink::WebMediaPlayerClient* client,
@@ -161,7 +161,8 @@ class CONTENT_EXPORT WebMediaPlayerMS
  private:
   friend class WebMediaPlayerMSTest;
 
-  // The callback for VideoFrameProvider to signal a new frame is available.
+  // The callback for MediaStreamVideoRenderer to signal a new frame is
+  // available.
   void OnFrameAvailable(const scoped_refptr<media::VideoFrame>& frame);
   // Need repaint due to state change.
   void RepaintInternal();
@@ -193,12 +194,11 @@ class CONTENT_EXPORT WebMediaPlayerMS
   const base::WeakPtr<media::WebMediaPlayerDelegate> delegate_;
   int delegate_id_;
 
-  // Specify content:: to disambiguate from cc::.
-  scoped_refptr<content::VideoFrameProvider> video_frame_provider_;  // Weak
+  scoped_refptr<MediaStreamVideoRenderer> video_frame_provider_; // Weak
 
   std::unique_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 
-  scoped_refptr<MediaStreamAudioRenderer> audio_renderer_;  // Weak
+  scoped_refptr<MediaStreamAudioRenderer> audio_renderer_; // Weak
   media::SkCanvasVideoRenderer video_renderer_;
 
   bool paused_;

content/shell/BUILD.gn

@@ -177,8 +177,8 @@ static_library("content_shell_lib") {
     "renderer/layout_test/leak_detector.h",
     "renderer/layout_test/test_media_stream_renderer_factory.cc",
     "renderer/layout_test/test_media_stream_renderer_factory.h",
-    "renderer/layout_test/test_video_frame_provider.cc",
-    "renderer/layout_test/test_video_frame_provider.h",
+    "renderer/layout_test/test_media_stream_video_renderer.cc",
+    "renderer/layout_test/test_media_stream_video_renderer.h",
     "renderer/shell_content_renderer_client.cc",
     "renderer/shell_content_renderer_client.h",
     "renderer/shell_render_view_observer.cc",

content/shell/renderer/layout_test/test_media_stream_renderer_factory.cc

@@ -4,7 +4,7 @@
 
 #include "content/shell/renderer/layout_test/test_media_stream_renderer_factory.h"
 
-#include "content/shell/renderer/layout_test/test_video_frame_provider.h"
+#include "content/shell/renderer/layout_test/test_media_stream_video_renderer.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
@@ -38,18 +38,18 @@ TestMediaStreamRendererFactory::TestMediaStreamRendererFactory() {}
 
 TestMediaStreamRendererFactory::~TestMediaStreamRendererFactory() {}
 
-scoped_refptr<VideoFrameProvider>
-TestMediaStreamRendererFactory::GetVideoFrameProvider(
+scoped_refptr<MediaStreamVideoRenderer>
+TestMediaStreamRendererFactory::GetVideoRenderer(
     const blink::WebMediaStream& web_stream,
     const base::Closure& error_cb,
-    const VideoFrameProvider::RepaintCB& repaint_cb,
+    const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     media::GpuVideoAcceleratorFactories* gpu_factories) {
   if (!IsMockMediaStreamWithVideo(web_stream))
     return NULL;
 
-  return new TestVideoFrameProvider(
+  return new TestMediaStreamVideoRenderer(
       gfx::Size(kVideoCaptureWidth, kVideoCaptureHeight),
       base::TimeDelta::FromMilliseconds(kVideoCaptureFrameDurationMs),
       error_cb,

content/shell/renderer/layout_test/test_media_stream_renderer_factory.h

@@ -18,10 +18,10 @@ class TestMediaStreamRendererFactory : public MediaStreamRendererFactory {
   ~TestMediaStreamRendererFactory() override;
 
   // MediaStreamRendererFactory implementation.
-  scoped_refptr<VideoFrameProvider> GetVideoFrameProvider(
+  scoped_refptr<MediaStreamVideoRenderer> GetVideoRenderer(
       const blink::WebMediaStream& web_stream,
       const base::Closure& error_cb,
-      const VideoFrameProvider::RepaintCB& repaint_cb,
+      const MediaStreamVideoRenderer::RepaintCB& repaint_cb,
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       media::GpuVideoAcceleratorFactories* gpu_factories) override;

content/shell/renderer/layout_test/test_video_frame_provider.cc → content/shell/renderer/layout_test/test_media_stream_video_renderer.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/shell/renderer/layout_test/test_video_frame_provider.h"
+#include "content/shell/renderer/layout_test/test_media_stream_video_renderer.h"
 
 #include "base/bind.h"
 #include "base/location.h"
@@ -12,11 +12,11 @@
 
 namespace content {
 
-TestVideoFrameProvider::TestVideoFrameProvider(
+TestMediaStreamVideoRenderer::TestMediaStreamVideoRenderer(
     const gfx::Size& size,
     const base::TimeDelta& frame_duration,
     const base::Closure& error_cb,
-    const VideoFrameProvider::RepaintCB& repaint_cb)
+    const MediaStreamVideoRenderer::RepaintCB& repaint_cb)
     : task_runner_(base::ThreadTaskRunnerHandle::Get()),
       size_(size),
       state_(kStopped),
@@ -25,38 +25,39 @@ TestVideoFrameProvider::TestVideoFrameProvider(
       repaint_cb_(repaint_cb) {
 }
 
-TestVideoFrameProvider::~TestVideoFrameProvider() {}
+TestMediaStreamVideoRenderer::~TestMediaStreamVideoRenderer() {}
 
-void TestVideoFrameProvider::Start() {
-  DVLOG(1) << "TestVideoFrameProvider::Start";
+void TestMediaStreamVideoRenderer::Start() {
+  DVLOG(1) << "TestMediaStreamVideoRenderer::Start";
   DCHECK(task_runner_->BelongsToCurrentThread());
   state_ = kStarted;
   task_runner_->PostTask(
-      FROM_HERE, base::Bind(&TestVideoFrameProvider::GenerateFrame, this));
+      FROM_HERE, base::Bind(&TestMediaStreamVideoRenderer::GenerateFrame,
+                            this));
 }
 
-void TestVideoFrameProvider::Stop() {
-  DVLOG(1) << "TestVideoFrameProvider::Stop";
+void TestMediaStreamVideoRenderer::Stop() {
+  DVLOG(1) << "TestMediaStreamVideoRenderer::Stop";
   DCHECK(task_runner_->BelongsToCurrentThread());
   state_ = kStopped;
 }
 
-void TestVideoFrameProvider::Play() {
-  DVLOG(1) << "TestVideoFrameProvider::Play";
+void TestMediaStreamVideoRenderer::Resume() {
+  DVLOG(1) << "TestMediaStreamVideoRenderer::Resume";
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ == kPaused)
     state_ = kStarted;
 }
 
-void TestVideoFrameProvider::Pause() {
-  DVLOG(1) << "TestVideoFrameProvider::Pause";
+void TestMediaStreamVideoRenderer::Pause() {
+  DVLOG(1) << "TestMediaStreamVideoRenderer::Pause";
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ == kStarted)
     state_ = kPaused;
 }
 
-void TestVideoFrameProvider::GenerateFrame() {
-  DVLOG(1) << "TestVideoFrameProvider::GenerateFrame";
+void TestMediaStreamVideoRenderer::GenerateFrame() {
+  DVLOG(1) << "TestMediaStreamVideoRenderer::GenerateFrame";
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ == kStopped)
     return;
@@ -75,7 +76,7 @@ void TestVideoFrameProvider::GenerateFrame() {
 
   current_time_ += frame_duration_;
   task_runner_->PostDelayedTask(
-      FROM_HERE, base::Bind(&TestVideoFrameProvider::GenerateFrame, this),
+      FROM_HERE, base::Bind(&TestMediaStreamVideoRenderer::GenerateFrame, this),
       frame_duration_);
 }
 

content/shell/renderer/layout_test/test_video_frame_provider.h → content/shell/renderer/layout_test/test_media_stream_video_renderer.h

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_SHELL_RENDERER_LAYOUT_TEST_TEST_VIDEO_FRAME_PROVIDER_H_
-#define CONTENT_SHELL_RENDERER_LAYOUT_TEST_TEST_VIDEO_FRAME_PROVIDER_H_
+#ifndef CONTENT_SHELL_RENDERER_LAYOUT_TEST_TEST_MEDIA_STREAM_VIDEO_RENDERER_H_
+#define CONTENT_SHELL_RENDERER_LAYOUT_TEST_TEST_MEDIA_STREAM_VIDEO_RENDERER_H_
 
 #include "base/macros.h"
 #include "base/time/time.h"
-#include "content/public/renderer/video_frame_provider.h"
+#include "content/public/renderer/media_stream_video_renderer.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace base {
@@ -16,27 +16,27 @@ class SingleThreadTaskRunner;
 
 namespace content {
 
-// A simple implementation of VideoFrameProvider generates raw frames and
+// A MediaStreamVideoRenderer that generates raw frames and
 // passes them to webmediaplayer.
 // Since non-black pixel values are required in the layout test, e.g.,
 // media/video-capture-canvas.html, this class should generate frame with
 // only non-black pixels.
-class TestVideoFrameProvider : public VideoFrameProvider {
+class TestMediaStreamVideoRenderer : public MediaStreamVideoRenderer {
  public:
-  TestVideoFrameProvider(
+  TestMediaStreamVideoRenderer(
       const gfx::Size& size,
       const base::TimeDelta& frame_duration,
       const base::Closure& error_cb,
       const RepaintCB& repaint_cb);
 
-  // VideoFrameProvider implementation.
+  // MediaStreamVideoRenderer implementation.
   void Start() override;
   void Stop() override;
-  void Play() override;
+  void Resume() override;
   void Pause() override;
 
  protected:
-  ~TestVideoFrameProvider() override;
+  ~TestMediaStreamVideoRenderer() override;
 
  private:
   enum State {
@@ -56,9 +56,9 @@ class TestVideoFrameProvider : public VideoFrameProvider {
   base::Closure error_cb_;
   RepaintCB repaint_cb_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestVideoFrameProvider);
+  DISALLOW_COPY_AND_ASSIGN(TestMediaStreamVideoRenderer);
 };
 
-}  // namespace content
+} // namespace content
 
-#endif  // CONTENT_SHELL_RENDERER_LAYOUT_TEST_TEST_VIDEO_FRAME_PROVIDER_H_
+#endif // CONTENT_SHELL_RENDERER_LAYOUT_TEST_TEST_MEDIA_STREAM_VIDEO_RENDERER_H_