Remove uses of skia::GetWritablePixels(PaintCanvas)

content/renderer/media/recorder/video_track_recorder.cc

 // Copyright 2015 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.
 
 #include "content/renderer/media/recorder/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_surface.h"
 #include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/bind_to_current_loop.h"
 #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 "services/ui/public/cpp/gpu/context_provider_command_buffer.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/libyuv/include/libyuv.h"
-#include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/geometry/size.h"
 
 #if BUILDFLAG(RTC_USE_H264)
 #include "third_party/openh264/src/codec/api/svc/codec_api.h"
 #include "third_party/openh264/src/codec/api/svc/codec_app_def.h"
 #include "third_party/openh264/src/codec/api/svc/codec_def.h"
 #endif  // #if BUILDFLAG(RTC_USE_H264)
 
 extern "C" {
 // VPX_CODEC_DISABLE_COMPAT excludes parts of the libvpx API that provide
@@ skipping 192 matching lines @@
 
   // This callback should be exercised on IO thread.
   const OnEncodedVideoCB on_encoded_video_callback_;
 
   // Target bitrate for video encoding. If 0, a standard bitrate is used.
   const int32_t bits_per_second_;
 
   // 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_;
-  sk_sp<SkSurface> surface_;
+  sk_sp<cc::PaintSurface> surface_;
 
   DISALLOW_COPY_AND_ASSIGN(Encoder);
 };
 
 void VideoTrackRecorder::Encoder::StartFrameEncode(
     const scoped_refptr<VideoFrame>& video_frame,
     base::TimeTicks capture_timestamp) {
   // Cache the thread sending frames on first frame arrival.
   if (!origin_task_runner_.get())
     origin_task_runner_ = base::ThreadTaskRunnerHandle::Get();
@@ skipping 52 matching lines @@
         video_frame->visible_rect(), video_frame->natural_size(),
         video_frame->timestamp());
 
     const SkImageInfo info = SkImageInfo::MakeN32(
         frame->visible_rect().width(), frame->visible_rect().height(),
         kOpaque_SkAlphaType);
 
     // Create |surface_| if it doesn't exist or incoming resolution has changed.
     if (!surface_ || surface_->width() != info.width() ||
         surface_->height() != info.height()) {
-      surface_ = SkSurface::MakeRaster(info);
+      surface_ = cc::PaintSurface::MakeRaster(info);
     }
     if (!video_renderer_)
       video_renderer_.reset(new media::SkCanvasVideoRenderer);
 
     DCHECK(context_provider->ContextGL());
     video_renderer_->Copy(video_frame.get(), surface_->getCanvas(),
                           media::Context3D(context_provider->ContextGL(),
                                            context_provider->GrContext()));
 
     SkPixmap pixmap;
-    if (!skia::GetWritablePixels(surface_->getCanvas(), &pixmap)) {
-      DLOG(ERROR) << "Error trying to map SkSurface's pixels";
+    if (!cc::ToPixmap(surface_->getCanvas(), &pixmap)) {
+      DLOG(ERROR) << "Error trying to map PaintSurface's pixels";
       return;
     }
     // TODO(mcasas): Use the incoming frame's rotation when
     // https://bugs.chromium.org/p/webrtc/issues/detail?id=6069 is closed.
     const libyuv::RotationMode source_rotation = libyuv::kRotate0;
     const uint32 source_pixel_format =
         (kN32_SkColorType == kRGBA_8888_SkColorType) ? libyuv::FOURCC_ABGR
                                                      : libyuv::FOURCC_ARGB;
     if (libyuv::ConvertToI420(static_cast<uint8*>(pixmap.writable_addr()),
                               pixmap.getSafeSize(),
@@ skipping 879 matching lines @@
     encoder_->SetPaused(paused_before_init_);
 
   // StartFrameEncode() will be called on Render IO thread.
   MediaStreamVideoSink::ConnectToTrack(
       track_,
       base::Bind(&VideoTrackRecorder::Encoder::StartFrameEncode, encoder_),
       false);
 }
 
 }  // namespace content