HTMLVideoElementCapturer: use SkSurface::MakeRaster ISO skia::CreatePlatformCanvas

content/renderer/media/html_video_element_capturer_source.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/html_video_element_capturer_source.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "media/base/limits.h"
 #include "media/blink/webmediaplayer_impl.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.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 "third_party/skia/include/core/SkXfermode.h"
 
 namespace {
 const float kMinFramesPerSecond = 1.0;
 }  // anonymous namespace
 
 namespace content {
 
 //static
 std::unique_ptr<HtmlVideoElementCapturerSource>
@@ skipping 54 matching lines @@
            << media::VideoCaptureFormat::ToString(params.requested_format);
   DCHECK(params.requested_format.IsValid());
   DCHECK(thread_checker_.CalledOnValidThread());
 
   running_callback_ = running_callback;
   if (!web_media_player_ || !web_media_player_->hasVideo()) {
     running_callback_.Run(false);
     return;
   }
   const blink::WebSize resolution = web_media_player_->naturalSize();
-  // TODO(mcasas): Don't use CreatePlatformCanvas here: http://crbug.com/615454.
-  canvas_ = sk_sp<SkCanvas>(skia::CreatePlatformCanvas(resolution.width,
-                               resolution.height,
-                               true /* is_opaque */,
-                               0 /* data */,
-                               skia::RETURN_NULL_ON_FAILURE));
-  if (!canvas_){
+  surface_ =
+      SkSurface::MakeRasterN32Premul(resolution.width, resolution.height);
+  if (!surface_) {
     running_callback_.Run(false);
     return;
   }
 
   new_frame_callback_ = new_frame_callback;
   // Force |capture_frame_rate_| to be in between k{Min,Max}FramesPerSecond.
   capture_frame_rate_ =
       std::max(kMinFramesPerSecond,
                std::min(static_cast<float>(media::limits::kMaxFramesPerSecond),
                         params.requested_format.frame_rate));
@@ skipping 16 matching lines @@
   DVLOG(3) << __FUNCTION__;
   TRACE_EVENT0("video", "HtmlVideoElementCapturerSource::sendNewFrame");
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!web_media_player_ || new_frame_callback_.is_null())
     return;
 
   const base::TimeTicks current_time = base::TimeTicks::Now();
   const blink::WebSize resolution = web_media_player_->naturalSize();
 
+  SkCanvas* canvas = surface_->getCanvas();
   web_media_player_->paint(
-      canvas_.get(), blink::WebRect(0, 0, resolution.width, resolution.height),
+      canvas, blink::WebRect(0, 0, resolution.width, resolution.height),
       0xFF /* alpha */, SkXfermode::kSrc_Mode);
-  DCHECK_NE(kUnknown_SkColorType, canvas_->imageInfo().colorType());
-  DCHECK_EQ(canvas_->imageInfo().width(), resolution.width);
-  DCHECK_EQ(canvas_->imageInfo().height(), resolution.height);
+  DCHECK_NE(kUnknown_SkColorType, canvas->imageInfo().colorType());
+  DCHECK_EQ(canvas->imageInfo().width(), resolution.width);
+  DCHECK_EQ(canvas->imageInfo().height(), resolution.height);
 
-  const SkBitmap bitmap = skia::ReadPixels(canvas_.get());
+  const SkBitmap bitmap = skia::ReadPixels(canvas);

[Stephen White, 2016/05/31 18:42:43]

This may or may not be applicable, but note that now that you have an SkSurface,
you could use SkSurface::makeImageSnapshot() to use Skia's copy-on-write
mechanism, and possibly save yourself a buffer copy.

[mcasas, 2016/05/31 18:49:36]

Acknowledged. From this side, it'd be always a
read-only copy for the pixel transform below.

   DCHECK_NE(kUnknown_SkColorType, bitmap.colorType());
   DCHECK(!bitmap.drawsNothing());
   DCHECK(bitmap.getPixels());
   if (bitmap.colorType() != kN32_SkColorType) {
     DLOG(ERROR) << "Only supported capture format is ARGB";
     return;
   }
 
   scoped_refptr<media::VideoFrame> frame = frame_pool_.CreateFrame(
       media::PIXEL_FORMAT_I420, resolution, gfx::Rect(resolution), resolution,
@@ skipping 34 matching lines @@
       next_capture_time_ = current_time;
   }
   // Schedule next capture.
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&HtmlVideoElementCapturerSource::sendNewFrame,
                             weak_factory_.GetWeakPtr()),
       next_capture_time_ - current_time);
 }
 
 }  // namespace content