Canvas capture from inactive tab

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"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/common/frame_messages.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
-#include "content/renderer/render_thread_impl.h"
+#include "content/renderer/render_view_impl.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 namespace content {
 
 class CanvasCaptureHandler::VideoCapturerSource
     : public media::VideoCapturerSource {
  public:
   explicit VideoCapturerSource(base::WeakPtr<CanvasCaptureHandler>
                                    canvas_handler,
                                double frame_rate)
@@ skipping 63 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CanvasCaptureHandlerDelegate);
 };
 
 CanvasCaptureHandler::CanvasCaptureHandler(
     const blink::WebSize& size,
     double frame_rate,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     blink::WebMediaStreamTrack* track)
     : ask_for_new_frame_(false),
       size_(size),
+      capturer_count_incremented_(false),
       io_task_runner_(io_task_runner),
       weak_ptr_factory_(this) {
+  blink::WebLocalFrame* const web_frame =
+      blink::WebLocalFrame::frameForCurrentContext();
+  render_view_ =
+      web_frame ? RenderViewImpl::FromWebView(web_frame->view()) : nullptr;
+
   scoped_ptr<media::VideoCapturerSource> video_source(
       new CanvasCaptureHandler::VideoCapturerSource(
           weak_ptr_factory_.GetWeakPtr(), frame_rate));
   AddVideoCapturerSourceToVideoTrack(std::move(video_source), track);
 }
 
 CanvasCaptureHandler::~CanvasCaptureHandler() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
+
+  // Handle when this class is destructed before StopVideoCapture() call.
+  if (render_view_ && capturer_count_incremented_) {
+    RenderThread::Get()->Send(
+        new FrameHostMsg_DecrementCapturerCount(render_view_->GetRoutingID()));
+    capturer_count_incremented_ = false;
+  }
+  DCHECK(!capturer_count_incremented_);
 }
 
 // static
 CanvasCaptureHandler* CanvasCaptureHandler::CreateCanvasCaptureHandler(
     const blink::WebSize& size,
     double frame_rate,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     blink::WebMediaStreamTrack* track) {
   // Save histogram data so we can see how much CanvasCapture is used.
   // The histogram counts the number of calls to the JS API.
@@ skipping 20 matching lines @@
   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_.reset(new CanvasCaptureHandlerDelegate(new_frame_callback));
   DCHECK(delegate_);
   ask_for_new_frame_ = true;
+
+  if (render_view_) {
+    RenderThread::Get()->Send(
+        new FrameHostMsg_IncrementCapturerCount(render_view_->GetRoutingID()));
+    capturer_count_incremented_ = true;
+  }
+
   running_callback.Run(true);
 }
 
 void CanvasCaptureHandler::StopVideoCapture() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   ask_for_new_frame_ = false;
   io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
+
+  if (render_view_) {
+    RenderThread::Get()->Send(
+        new FrameHostMsg_DecrementCapturerCount(render_view_->GetRoutingID()));
+    capturer_count_incremented_ = false;
+  }
 }
 
 void CanvasCaptureHandler::CreateNewFrame(const SkImage* image) {
   DCHECK(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));
@@ skipping 43 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