Request frame for new sinks from MediaStreamVideoTrack

content/renderer/media/canvas_capture_handler.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/canvas_capture_handler.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind_helpers.h"
@@ skipping 67 matching lines @@
                                   frame_rate_, media::PIXEL_FORMAT_YV12A));
     callback.Run(formats);
   }
   void StartCapture(const media::VideoCaptureParams& params,
                     const VideoCaptureDeliverFrameCB& frame_callback,
                     const RunningCallback& running_callback) override {
     DCHECK(main_render_thread_checker_.CalledOnValidThread());
     canvas_handler_->StartVideoCapture(params, frame_callback,
                                        running_callback);
   }
+  void RequestRefreshFrame() override {
+    DCHECK(main_render_thread_checker_.CalledOnValidThread());
+    canvas_handler_->RequestRefreshFrame();
+  }
   void StopCapture() override {
     DCHECK(main_render_thread_checker_.CalledOnValidThread());
     if (canvas_handler_.get())
       canvas_handler_->StopVideoCapture();
   }
 
  private:
   const double frame_rate_;
   // Bound to Main Render thread.
   base::ThreadChecker main_render_thread_checker_;
@@ skipping 89 matching lines @@
   DCHECK(params.requested_format.IsValid());
 
   // TODO(emircan): Accomodate to the given frame rate constraints here.
   capture_format_ = params.requested_format;
   delegate_.reset(new CanvasCaptureHandlerDelegate(new_frame_callback));
   DCHECK(delegate_);
   ask_for_new_frame_ = true;
   running_callback.Run(true);
 }
 
+void CanvasCaptureHandler::RequestRefreshFrame() {
+  DVLOG(3) << __FUNCTION__;
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  if (last_frame_ && delegate_) {
+    io_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&CanvasCaptureHandler::CanvasCaptureHandlerDelegate::
+                       SendNewFrameOnIOThread,
+                   delegate_->GetWeakPtrForIOThread(), last_frame_,
+                   base::TimeTicks::Now()));
+  }
+}
+
 void CanvasCaptureHandler::StopVideoCapture() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   ask_for_new_frame_ = false;
   io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
 }
 
 void CanvasCaptureHandler::CreateNewFrame(const SkImage* image) {
+  DVLOG(4) << __FUNCTION__;
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(image);
 
   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, size.width());
     image_info_ =
@@ skipping 21 matching lines @@
                      video_frame->stride(media::VideoFrame::kUPlane),
                      video_frame->data(media::VideoFrame::kVPlane),
                      video_frame->stride(media::VideoFrame::kVPlane),
                      size.width(), size.height());
   if (!isOpaque) {
     // TODO(emircan): Use https://code.google.com/p/libyuv/issues/detail?id=572
     // when it becomes available.
     CopyAlphaChannelIntoVideoFrame(temp_data_.data(), video_frame);
   }
 
+  last_frame_ = video_frame;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CanvasCaptureHandler::CanvasCaptureHandlerDelegate::
                      SendNewFrameOnIOThread,
                  delegate_->GetWeakPtrForIOThread(), video_frame, timestamp));
 }
 
 void CanvasCaptureHandler::AddVideoCapturerSourceToVideoTrack(
     scoped_ptr<media::VideoCapturerSource> source,
     blink::WebMediaStreamTrack* web_track) {
@@ skipping 10 matching lines @@
 
   web_track->initialize(webkit_source);
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   web_track->setExtraData(new MediaStreamVideoTrack(
       media_stream_source.release(), constraints,
       MediaStreamVideoSource::ConstraintsCallback(), true));
 }
 
 }  // namespace content