Remove uses of skia::GetWritablePixels(PaintCanvas)

content/renderer/media/image_capture_frame_grabber.cc

 // Copyright 2016 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/image_capture_frame_grabber.h"
 
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_surface.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebCallbacks.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkImage.h"
-#include "third_party/skia/include/core/SkSurface.h"
 
 namespace content {
 
 using blink::WebImageCaptureGrabFrameCallbacks;
 
 namespace {
 
 void OnError(std::unique_ptr<WebImageCaptureGrabFrameCallbacks> callbacks) {
   callbacks->onError();
 }
 
 }  // anonymous namespace
 
 // Ref-counted class to receive a single VideoFrame on IO thread, convert it and
 // send it to |main_task_runner_|, where this class is created and destroyed.
 class ImageCaptureFrameGrabber::SingleShotFrameHandler
     : public base::RefCountedThreadSafe<SingleShotFrameHandler> {
  public:
   SingleShotFrameHandler() : first_frame_received_(false) {}
 
   // Receives a |frame| and converts its pixels into a SkImage via an internal
-  // SkSurface and SkPixmap. Alpha channel, if any, is copied.
+  // PaintSurface and SkPixmap. Alpha channel, if any, is copied.
   void OnVideoFrameOnIOThread(SkImageDeliverCB callback,
                               const scoped_refptr<media::VideoFrame>& frame,
                               base::TimeTicks current_time);
 
  private:
   friend class base::RefCountedThreadSafe<SingleShotFrameHandler>;
   virtual ~SingleShotFrameHandler() {}
 
   // Flag to indicate that the first frames has been processed, and subsequent
   // ones can be safely discarded.
@@ skipping 13 matching lines @@
   if (first_frame_received_)
     return;
   first_frame_received_ = true;
 
   const SkAlphaType alpha = media::IsOpaque(frame->format())
                                 ? kOpaque_SkAlphaType
                                 : kPremul_SkAlphaType;
   const SkImageInfo info = SkImageInfo::MakeN32(
       frame->visible_rect().width(), frame->visible_rect().height(), alpha);
 
-  sk_sp<SkSurface> surface = SkSurface::MakeRaster(info);
+  sk_sp<cc::PaintSurface> surface = cc::PaintSurface::MakeRaster(info);
   DCHECK(surface);
 
   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";
     callback.Run(sk_sp<SkImage>());
     return;
   }
 
   const uint32 destination_pixel_format =
       (kN32_SkColorType == kRGBA_8888_SkColorType) ? libyuv::FOURCC_ABGR
                                                    : libyuv::FOURCC_ARGB;
 
   libyuv::ConvertFromI420(frame->visible_data(media::VideoFrame::kYPlane),
                           frame->stride(media::VideoFrame::kYPlane),
@@ skipping 66 matching lines @@
 
   MediaStreamVideoSink::DisconnectFromTrack();
   frame_grab_in_progress_ = false;
   if (image)
     callbacks.PassCallbacks()->onSuccess(image);
   else
     callbacks.PassCallbacks()->onError();
 }
 
 }  // namespace content