Handle Alpha channel in Canvas capture

content/renderer/media/canvas_capture_handler.cc

Index: content/renderer/media/canvas_capture_handler.cc
diff --git a/content/renderer/media/canvas_capture_handler.cc b/content/renderer/media/canvas_capture_handler.cc
index 634267eb153f612d0acd24f9c742b8edd48e1039..314e94847f801b0b23ff915d1a7bccc9272e4d71 100644
--- a/content/renderer/media/canvas_capture_handler.cc
+++ b/content/renderer/media/canvas_capture_handler.cc
@@ -41,7 +41,7 @@ class CanvasCaptureHandler::VideoCapturerSource
     const blink::WebSize& size = canvas_handler_->GetSourceSize();
     const media::VideoCaptureFormat format(gfx::Size(size.width, size.height),
                                            frame_rate_,
-                                           media::PIXEL_FORMAT_I420);
+                                           media::PIXEL_FORMAT_YV12A);
     media::VideoCaptureFormats formats;
     formats.push_back(format);
     callback.Run(formats);
@@ -176,16 +176,18 @@ void CanvasCaptureHandler::CreateNewFrame(const SkImage* image) {
         media::VideoFrame::RowBytes(0, media::PIXEL_FORMAT_ARGB, size.width());
     image_info_ =
         SkImageInfo::Make(size.width(), size.height(), kBGRA_8888_SkColorType,
-                          kPremul_SkAlphaType);
+                          kUnpremul_SkAlphaType);
     last_size = size;
   }
 
   image->readPixels(image_info_, &temp_data_[0], row_bytes_, 0, 0);
   scoped_refptr<media::VideoFrame> video_frame =
-      frame_pool_.CreateFrame(media::PIXEL_FORMAT_I420, size, gfx::Rect(size),
+      frame_pool_.CreateFrame(media::PIXEL_FORMAT_YV12A, size, gfx::Rect(size),
                               size, base::TimeTicks::Now() - base::TimeTicks());
   DCHECK(video_frame);
 
+  // TODO(emircan): Use https://code.google.com/p/libyuv/issues/detail?id=572
+  // when it becomes available.
   libyuv::ARGBToI420(temp_data_.data(), row_bytes_,
                      video_frame->data(media::VideoFrame::kYPlane),
                      video_frame->stride(media::VideoFrame::kYPlane),
@@ -194,6 +196,10 @@ void CanvasCaptureHandler::CreateNewFrame(const SkImage* image) {
                      video_frame->data(media::VideoFrame::kVPlane),
                      video_frame->stride(media::VideoFrame::kVPlane),
                      size.width(), size.height());
+  // Copy alpha channel directly.
+  for (int p = 0; p < size.GetArea(); ++p)
+    video_frame->data(media::VideoFrame::kAPlane)[p] = temp_data_[p * 4 + 3];

[mcasas, 2016/02/25 22:06:25]

Hmm it looks like this deinterlaced could lower 
the performance significantly. I'd love to use 
libyuv::CopyPlane() [1]  but here it doesn't 
match due to the 4*.. + 3 extra calculation. I 
wonder if we could go back to |image| and use 
its readYUV8Planes() [2]? Ah but it doesn't
support Alpha either! :(

Could we at least skip this process overall if
we see somehow that the alpha plane is not
used? We don't expect that every single canvas
would make use of it, right?

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/libyuv...
[2]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/skia/i...

[emircan, 2016/02/26 01:33:07]

Unfortunately, there isn't a libyuv method I can directly use for now. I talked
with owners and they agreed to work on one . You can see updates on
https://code.google.com/p/libyuv/issues/detail?id=572. readYUV8Planes() also
doesn't have alpha, and works much slower than libyuv :(

Regarding alpha plane check, I started using SkImage::isOpaque().

+
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CanvasCaptureHandler::CanvasCaptureHandlerDelegate::