Basic use implementation for MediaStream from Canvas: captureStream()

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
new file mode 100644
index 0000000000000000000000000000000000000000..b61182378a0222c67fff99fb1897c59e815fa119
--- /dev/null
+++ b/content/renderer/media/canvas_capture_handler.cc
@@ -0,0 +1,179 @@
+// 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/canvas_capture_handler.h"
+
+#include "base/bind_helpers.h"
+#include "content/public/renderer/media_stream_api.h"
+#include "content/public/renderer/render_thread.h"
+#include "content/renderer/render_thread_impl.h"
+#include "third_party/libyuv/include/libyuv.h"
+
+namespace {
+const float kDefaultFrameRate = 60.0f;
+}  // anonymous namespace
+
+namespace content {
+
+class CanvasCaptureHandler::VideoCapturerSource
+    : public media::VideoCapturerSource {
+ public:
+  explicit VideoCapturerSource(CanvasCaptureHandler* canvas_handler)
+      : canvas_handler_(canvas_handler) {}
+
+ protected:
+  void GetCurrentSupportedFormats(
+      int max_requested_width,
+      int max_requested_height,
+      double max_requested_frame_rate,
+      const VideoCaptureDeviceFormatsCB& callback) override;
+  void StartCapture(const media::VideoCaptureParams& params,
+                    const VideoCaptureDeliverFrameCB& frame_callback,
+                    const RunningCallback& running_callback) override {
+    canvas_handler_->StartVideoCapture(params, frame_callback,
+                                       running_callback);
+  }
+  void StopCapture() override {
+    canvas_handler_->StopVideoCapture();
+  }
+
+ private:
+  // CanvasCaptureHandler is owned by blink and guaranteed to be alive during
+  // the lifetime of this class.
+  CanvasCaptureHandler* canvas_handler_;
+};
+
+void CanvasCaptureHandler::VideoCapturerSource::GetCurrentSupportedFormats(

[perkj_chrome, 2015/12/01 19:26:34]

nit: please inline this method too or split out startCapture and StopCapture()

[emircan, 2015/12/01 21:07:34]

Done.

+    int max_requested_width,
+    int max_requested_height,
+    double max_requested_frame_rate,
+    const VideoCaptureDeviceFormatsCB& callback) {
+  const blink::WebSize& size = canvas_handler_->GetSourceSize();
+  const media::VideoCaptureFormat format(gfx::Size(size.width, size.height),
+                                         kDefaultFrameRate,
+                                         media::PIXEL_FORMAT_I420);
+  media::VideoCaptureFormats formats;
+  formats.push_back(format);
+  callback.Run(formats);
+}
+
+class CanvasCaptureHandler::CanvasCaptureHandlerDelegate {
+ public:
+  explicit CanvasCaptureHandlerDelegate(
+      media::VideoCapturerSource::VideoCaptureDeliverFrameCB new_frame_callback)
+      : new_frame_callback_(new_frame_callback),

[perkj_chrome, 2015/12/01 19:26:34]

Just use a normal ThreadChecker. In the ctor, call detachThread.

Also, please add a dtor and ad a threadcheck since it looks like it is important
that it this is destroyed on the correct thread since you post to this class on
the io thread.

[emircan, 2015/12/01 21:07:34]

Done.

+        io_task_runner_(content::RenderThread::Get()->GetIOMessageLoopProxy()),
+        weak_ptr_factory_(this) {}
+
+  void SendNewFrameOnIOThread(
+      const scoped_refptr<media::VideoFrame>& video_frame,
+      const base::TimeTicks& current_time) {
+    DCHECK(io_task_runner_->BelongsToCurrentThread());
+    new_frame_callback_.Run(video_frame, current_time);
+  }
+
+  base::WeakPtr<CanvasCaptureHandlerDelegate> GetWeakPtrForIOThread() {
+    return weak_ptr_factory_.GetWeakPtr();
+  }
+
+ private:
+  const media::VideoCapturerSource::VideoCaptureDeliverFrameCB
+      new_frame_callback_;
+  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  base::WeakPtrFactory<CanvasCaptureHandlerDelegate> weak_ptr_factory_;
+  DISALLOW_COPY_AND_ASSIGN(CanvasCaptureHandlerDelegate);

[perkj_chrome, 2015/12/01 19:26:34]

nit empty line before DISALLOW...

[emircan, 2015/12/01 21:07:34]

Done.

+};
+
+CanvasCaptureHandler::CanvasCaptureHandler(const blink::WebSize& size,
+                                           blink::WebMediaStream* stream)
+    : ask_for_new_frame_(false),
+      size_(size),
+      io_task_runner_(content::RenderThread::Get()->GetIOMessageLoopProxy()) {
+  scoped_ptr<media::VideoCapturerSource> video(
+      new CanvasCaptureHandler::VideoCapturerSource(this));
+  content::AddVideoTrackToMediaStream(video.Pass(), false, true, stream);
+}
+
+CanvasCaptureHandler::~CanvasCaptureHandler() {
+  DVLOG(3) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
+}
+
+void CanvasCaptureHandler::sendNewFrame(const blink::WebSkImage& image) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  CreateNewFrame(image);
+}
+
+bool CanvasCaptureHandler::needsNewFrameCapture() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return ask_for_new_frame_;
+}
+
+void CanvasCaptureHandler::StartVideoCapture(
+    const media::VideoCaptureParams& params,
+    const media::VideoCapturerSource::VideoCaptureDeliverFrameCB&
+        new_frame_callback,
+    const media::VideoCapturerSource::RunningCallback& running_callback) {
+  DVLOG(3) << __FUNCTION__ << " requested "
+           << media::VideoCaptureFormat::ToString(params.requested_format);
+  DCHECK(params.requested_format.IsValid());
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // TODO(emircan): Accomodate to the given frame rate constraints here.
+  capture_format_ = params.requested_format;
+  delegate_ =

[perkj_chrome, 2015/12/01 19:26:34]

nit: delegate.reset(new ...)
Otherwise you will do a copy of scoped_ptr (unless a there is a move
constructor)

[emircan, 2015/12/01 21:07:34]

Done.

+      make_scoped_ptr(new CanvasCaptureHandlerDelegate(new_frame_callback));
+  DCHECK(delegate_);
+  ask_for_new_frame_ = true;
+  running_callback.Run(true);
+}
+
+void CanvasCaptureHandler::StopVideoCapture() {
+  DVLOG(3) << __FUNCTION__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  ask_for_new_frame_ = false;
+  delegate_.reset();

[perkj_chrome, 2015/12/01 19:26:34]

io_task_runner_->DeleteSoon(FROM ?

[emircan, 2015/12/01 21:07:34]

Done.

+}
+
+void CanvasCaptureHandler::CreateNewFrame(const blink::WebSkImage& image) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  DCHECK(!image.isNull());
+  const gfx::Size size(image.width(), image.height());
+  if (size != last_size) {
+    temp_data_.resize(
+        media::VideoFrame::AllocationSize(media::PIXEL_FORMAT_ARGB, size));
+    row_bytes_ = media::VideoFrame::RowBytes(
+        0, media::PIXEL_FORMAT_ARGB, capture_format_.frame_size.width());
+    image_info_ =
+        SkImageInfo::Make(size.width(), size.height(), kBGRA_8888_SkColorType,
+                          kPremul_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),
+                              size, base::TimeTicks::Now() - base::TimeTicks());
+  libyuv::ARGBToI420(temp_data_.data(), row_bytes_,
+                     video_frame->data(media::VideoFrame::kYPlane),
+                     video_frame->stride(media::VideoFrame::kYPlane),
+                     video_frame->data(media::VideoFrame::kUPlane),
+                     video_frame->stride(media::VideoFrame::kUPlane),
+                     video_frame->data(media::VideoFrame::kVPlane),
+                     video_frame->stride(media::VideoFrame::kVPlane),
+                     size.width(), size.height());
+
+  if (!delegate_)

[perkj_chrome, 2015/12/01 19:26:34]

nit: move to the just after the thread_checker_

[esprehn, 2015/12/01 20:04:26]

how do you end up with no delegate here?

[emircan, 2015/12/01 21:07:34]

I dont think it necessary to check any more. 

[emircan, 2015/12/01 21:07:34]

I was thinking of a possible call to this function after StopVideoCapture(), but
|ask_for_new_frame_| stops it. Removed it.

+    return;
+  io_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&CanvasCaptureHandler::CanvasCaptureHandlerDelegate::
+                     SendNewFrameOnIOThread,
+                 delegate_->GetWeakPtrForIOThread(), video_frame,
+                 base::TimeTicks()));
+}
+
+}  // namespace content