Rename SkCanvasVideoRenderer to PaintCanvasVideoRenderer

As the comment in skcanvas_video_renderer.h by enne@,
Rename SkCanvasVideoRenderer to PaintCanvasVideoRenderer
and related class. Rename the files also.

BUG=

Signed-off-by: zhuoyu.qian <zhuoyu.qian@samsung.com>
Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel
Change-Id: If018d84bb51a02a8a3d310f6f50429da8c444394
Reviewed-on: https://chromium-review.googlesource.com/706881
Commit-Queue: Chris Watkins <watk@chromium.org>
Reviewed-by: Chris Watkins <watk@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Nick Carter <nick@chromium.org>
Reviewed-by: enne <enne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#508979}

cc/paint/paint_canvas.h

@@ -33,7 +33,7 @@ class CC_PAINT_EXPORT PaintCanvas {
 
   // TODO(enne): It would be nice to get rid of flush() entirely, as it
   // doesn't really make sense for recording.  However, this gets used by
-  // SkCanvasVideoRenderer which takes a PaintCanvas to paint both
+  // PaintCanvasVideoRenderer which takes a PaintCanvas to paint both
   // software and hardware video.  This is super entangled with ImageBuffer
   // and canvas/video painting in Blink where the same paths are used for
   // both recording and gpu work.

cc/resources/video_resource_updater.cc

@@ -19,7 +19,7 @@
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/video_frame.h"
-#include "media/renderers/skcanvas_video_renderer.h"
+#include "media/renderers/paint_canvas_video_renderer.h"
 #include "media/video/half_float_maker.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
@@ -405,7 +405,7 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
       // We need to transfer data from |video_frame| to the plane resource.
       if (software_compositor) {
         if (!video_renderer_)
-          video_renderer_.reset(new media::SkCanvasVideoRenderer);
+          video_renderer_.reset(new media::PaintCanvasVideoRenderer);
 
         ResourceProvider::ScopedWriteLockSoftware lock(
             resource_provider_, plane_resource.resource_id());
@@ -420,7 +420,7 @@ VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
         if (upload_pixels_.size() < needed_size)
           upload_pixels_.resize(needed_size);
 
-        media::SkCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
+        media::PaintCanvasVideoRenderer::ConvertVideoFrameToRGBPixels(
             video_frame.get(), &upload_pixels_[0], bytes_per_row);
 
         resource_provider_->CopyToResource(plane_resource.resource_id(),

cc/resources/video_resource_updater.h

@@ -24,7 +24,7 @@
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
-class SkCanvasVideoRenderer;
+class PaintCanvasVideoRenderer;
 class VideoFrame;
 }
 
@@ -182,7 +182,7 @@ class CC_EXPORT VideoResourceUpdater {
   viz::ContextProvider* context_provider_;
   ResourceProvider* resource_provider_;
   const bool use_stream_video_draw_quad_;
-  std::unique_ptr<media::SkCanvasVideoRenderer> video_renderer_;
+  std::unique_ptr<media::PaintCanvasVideoRenderer> video_renderer_;
   std::vector<uint8_t> upload_pixels_;
   bool use_r16_for_testing_ = false;
 

content/browser/renderer_host/render_widget_host_view_browsertest.cc

@@ -37,7 +37,7 @@
 #include "content/shell/browser/shell.h"
 #include "content/test/did_commit_provisional_load_interceptor.h"
 #include "media/base/video_frame.h"
-#include "media/renderers/skcanvas_video_renderer.h"
+#include "media/renderers/paint_canvas_video_renderer.h"
 #include "net/base/filename_util.h"
 #include "net/dns/mock_host_resolver.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -565,7 +565,7 @@ class CompositingRenderWidgetHostViewBrowserTestTabCapture
       return;
     }
 
-    media::SkCanvasVideoRenderer video_renderer;
+    media::PaintCanvasVideoRenderer video_renderer;
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(video_frame->visible_rect().width(),

content/renderer/media/webmediaplayer_ms.cc

@@ -821,11 +821,11 @@ bool WebMediaPlayerMS::TexImageImpl(TexImageFunctionID functionID,
     // GPU Process crashed.
     if (!provider)
       return false;
-    return media::SkCanvasVideoRenderer::TexImage2D(
+    return media::PaintCanvasVideoRenderer::TexImage2D(
         target, texture, gl, provider->ContextCapabilities(), video_frame.get(),
         level, internalformat, format, type, flip_y, premultiply_alpha);
   } else if (functionID == kTexSubImage2D) {
-    return media::SkCanvasVideoRenderer::TexSubImage2D(
+    return media::PaintCanvasVideoRenderer::TexSubImage2D(
         target, gl, video_frame.get(), level, format, type, xoffset, yoffset,
         flip_y, premultiply_alpha);
   }
@@ -892,7 +892,8 @@ void WebMediaPlayerMS::SetReadyState(WebMediaPlayer::ReadyState state) {
   get_client()->ReadyStateChanged();
 }
 
-media::SkCanvasVideoRenderer* WebMediaPlayerMS::GetSkCanvasVideoRenderer() {
+media::PaintCanvasVideoRenderer*
+WebMediaPlayerMS::GetPaintCanvasVideoRenderer() {
   return &video_renderer_;
 }
 

content/renderer/media/webmediaplayer_ms.h

@@ -16,7 +16,7 @@
 #include "content/common/content_export.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_util.h"
-#include "media/renderers/skcanvas_video_renderer.h"
+#include "media/renderers/paint_canvas_video_renderer.h"
 #include "media/video/gpu_video_accelerator_factories.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
@@ -111,7 +111,7 @@ class CONTENT_EXPORT WebMediaPlayerMS
              cc::PaintFlags& flags,
              int already_uploaded_id,
              VideoFrameUploadMetadata* out_metadata) override;
-  media::SkCanvasVideoRenderer* GetSkCanvasVideoRenderer();
+  media::PaintCanvasVideoRenderer* GetPaintCanvasVideoRenderer();
   void ResetCanvasCache();
 
   // Methods to trigger resize event.
@@ -249,7 +249,7 @@ class CONTENT_EXPORT WebMediaPlayerMS
   std::unique_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 
   scoped_refptr<MediaStreamAudioRenderer> audio_renderer_; // Weak
-  media::SkCanvasVideoRenderer video_renderer_;
+  media::PaintCanvasVideoRenderer video_renderer_;
 
   bool paused_;
   media::VideoRotation video_rotation_;

content/renderer/media/webmediaplayer_ms_compositor.cc

@@ -19,7 +19,7 @@
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/filters/video_renderer_algorithm.h"
-#include "media/renderers/skcanvas_video_renderer.h"
+#include "media/renderers/paint_canvas_video_renderer.h"
 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
@@ -37,7 +37,7 @@ namespace {
 // This function copies |frame| to a new I420 or YV12A media::VideoFrame.
 scoped_refptr<media::VideoFrame> CopyFrame(
     const scoped_refptr<media::VideoFrame>& frame,
-    media::SkCanvasVideoRenderer* video_renderer) {
+    media::PaintCanvasVideoRenderer* video_renderer) {
   scoped_refptr<media::VideoFrame> new_frame;
   if (frame->HasTextures()) {
     DCHECK(frame->format() == media::PIXEL_FORMAT_ARGB ||
@@ -462,7 +462,7 @@ void WebMediaPlayerMSCompositor::ReplaceCurrentFrameWithACopyInternal() {
   // there might be a finite number of available buffers. E.g, video that
   // originates from a video camera, HW decoded frames.
   scoped_refptr<media::VideoFrame> copied_frame =
-      CopyFrame(current_frame_ref, player_->GetSkCanvasVideoRenderer());
+      CopyFrame(current_frame_ref, player_->GetPaintCanvasVideoRenderer());
   // Copying frame can take time, so only set the copied frame if
   // |current_frame_| hasn't been changed.
   {

content/renderer/media/webrtc/webrtc_video_capturer_adapter.cc

@@ -14,7 +14,7 @@
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_util.h"
-#include "media/renderers/skcanvas_video_renderer.h"
+#include "media/renderers/paint_canvas_video_renderer.h"
 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
@@ -55,7 +55,7 @@ class WebRtcVideoCapturerAdapter::TextureFrameCopier
  public:
   TextureFrameCopier()
       : main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-        canvas_video_renderer_(new media::SkCanvasVideoRenderer) {
+        canvas_video_renderer_(new media::PaintCanvasVideoRenderer) {
     RenderThreadImpl* const main_thread = RenderThreadImpl::current();
     if (main_thread)
       provider_ = main_thread->SharedMainThreadContextProvider();
@@ -145,7 +145,7 @@ class WebRtcVideoCapturerAdapter::TextureFrameCopier
 
   const scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   scoped_refptr<ui::ContextProviderCommandBuffer> provider_;
-  std::unique_ptr<media::SkCanvasVideoRenderer> canvas_video_renderer_;
+  std::unique_ptr<media::PaintCanvasVideoRenderer> canvas_video_renderer_;
 };
 
 WebRtcVideoCapturerAdapter::WebRtcVideoCapturerAdapter(

content/renderer/media_recorder/video_track_recorder.cc

@@ -23,7 +23,7 @@
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/filters/context_3d.h"
-#include "media/renderers/skcanvas_video_renderer.h"
+#include "media/renderers/paint_canvas_video_renderer.h"
 #include "services/ui/public/cpp/gpu/context_provider_command_buffer.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/libyuv/include/libyuv.h"
@@ -257,7 +257,7 @@ void VideoTrackRecorder::Encoder::RetrieveFrameOnMainThread(
         video_frame->timestamp());
   } else {
     // Accelerated decoders produce ARGB/ABGR texture-backed frames (see
-    // https://crbug.com/585242), fetch them using a SkCanvasVideoRenderer.
+    // https://crbug.com/585242), fetch them using a PaintCanvasVideoRenderer.
     DCHECK(video_frame->HasTextures());
     DCHECK_EQ(media::PIXEL_FORMAT_ARGB, video_frame->format());
 
@@ -288,7 +288,7 @@ void VideoTrackRecorder::Encoder::RetrieveFrameOnMainThread(
       canvas_ = base::MakeUnique<cc::SkiaPaintCanvas>(bitmap_);
     }
     if (!video_renderer_)
-      video_renderer_.reset(new media::SkCanvasVideoRenderer);
+      video_renderer_.reset(new media::PaintCanvasVideoRenderer);
 
     DCHECK(context_provider->ContextGL());
     video_renderer_->Copy(video_frame.get(), canvas_.get(),

content/renderer/media_recorder/video_track_recorder.h

@@ -27,7 +27,7 @@ class PaintCanvas;
 }  // namespace cc
 
 namespace media {
-class SkCanvasVideoRenderer;
+class PaintCanvasVideoRenderer;
 class VideoFrame;
 }  // namespace media
 
@@ -153,7 +153,7 @@ class CONTENT_EXPORT VideoTrackRecorder : public MediaStreamVideoSink {
 
     // Used to retrieve incoming opaque VideoFrames (i.e. VideoFrames backed by
     // textures). Created on-demand on |main_task_runner_|.
-    std::unique_ptr<media::SkCanvasVideoRenderer> video_renderer_;
+    std::unique_ptr<media::PaintCanvasVideoRenderer> video_renderer_;
     SkBitmap bitmap_;
     std::unique_ptr<cc::PaintCanvas> canvas_;
 

content/renderer/pepper/video_decoder_shim.cc

@@ -31,7 +31,6 @@
 #include "media/base/video_decoder.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/vpx_video_decoder.h"
-#include "media/renderers/skcanvas_video_renderer.h"
 #include "media/video/picture.h"
 #include "media/video/video_decode_accelerator.h"
 #include "ppapi/c/pp_errors.h"

media/blink/webmediaplayer_impl.cc

@@ -1049,7 +1049,7 @@ void WebMediaPlayerImpl::Paint(blink::WebCanvas* canvas,
       return;
     }
   }
-  skcanvas_video_renderer_.Paint(
+  video_renderer_.Paint(
       video_frame, canvas, gfx::RectF(gfx_rect), flags,
       pipeline_metadata_.video_decoder_config.video_rotation(), context_3d);
 }
@@ -1137,7 +1137,7 @@ bool WebMediaPlayerImpl::CopyVideoTextureToPlatformTexture(
     context_3d = Context3D(context_provider_->ContextGL(),
                            context_provider_->GrContext());
   }
-  return skcanvas_video_renderer_.CopyVideoFrameTexturesToGLTexture(
+  return video_renderer_.CopyVideoFrameTexturesToGLTexture(
       context_3d, gl, video_frame.get(), target, texture, internal_format,
       format, type, level, premultiply_alpha, flip_y);
 }

media/blink/webmediaplayer_impl.h

@@ -41,7 +41,7 @@
 #include "media/blink/webmediaplayer_util.h"
 #include "media/filters/pipeline_controller.h"
 #include "media/mojo/interfaces/video_decode_stats_recorder.mojom.h"
-#include "media/renderers/skcanvas_video_renderer.h"
+#include "media/renderers/paint_canvas_video_renderer.h"
 #include "third_party/WebKit/public/platform/WebAudioSourceProvider.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
@@ -659,7 +659,7 @@ class MEDIA_BLINK_EXPORT WebMediaPlayerImpl
   scoped_refptr<base::SingleThreadTaskRunner> vfc_task_runner_;
   std::unique_ptr<VideoFrameCompositor>
       compositor_;  // Deleted on |vfc_task_runner_|.
-  SkCanvasVideoRenderer skcanvas_video_renderer_;
+  PaintCanvasVideoRenderer video_renderer_;
 
   // The compositor layer for displaying the video content when using composited
   // playback.

media/renderers/BUILD.gn

@@ -13,10 +13,10 @@ source_set("renderers") {
     "audio_renderer_impl.h",
     "default_renderer_factory.cc",
     "default_renderer_factory.h",
+    "paint_canvas_video_renderer.cc",
+    "paint_canvas_video_renderer.h",
     "renderer_impl.cc",
     "renderer_impl.h",
-    "skcanvas_video_renderer.cc",
-    "skcanvas_video_renderer.h",
     "video_overlay_factory.cc",
     "video_overlay_factory.h",
     "video_renderer_impl.cc",
@@ -52,8 +52,8 @@ source_set("unit_tests") {
   testonly = true
   sources = [
     "audio_renderer_impl_unittest.cc",
+    "paint_canvas_video_renderer_unittest.cc",
     "renderer_impl_unittest.cc",
-    "skcanvas_video_renderer_unittest.cc",
     "video_renderer_impl_unittest.cc",
   ]
   configs += [ "//media:media_config" ]