Handle early destruction of CanvasCaptureHandler

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/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 "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 namespace content {
 
-class CanvasCaptureHandler::VideoCapturerSource
-    : public media::VideoCapturerSource {
+// Implementation VideoCapturerSource that is owned by
+// MediaStreamVideoCapturerSource and delegates the Start/Stop calls to
+// CanvasCaptureHandler.
+// This class is single threaded and pinned to main render thread.
+class VideoCapturerSource : public media::VideoCapturerSource {
  public:
   explicit VideoCapturerSource(base::WeakPtr<CanvasCaptureHandler>
                                    canvas_handler,
                                double frame_rate)
       : frame_rate_(frame_rate),
         canvas_handler_(canvas_handler) {}
 
  protected:
   void GetCurrentSupportedFormats(
       int max_requested_width,
@@ skipping 13 matching lines @@
   }
   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 StopCapture() override {
     DCHECK(main_render_thread_checker_.CalledOnValidThread());
-    canvas_handler_->StopVideoCapture();
+    if (canvas_handler_.get())
+      canvas_handler_->StopVideoCapture();
   }
 
  private:
-  double frame_rate_;
+  const double frame_rate_;
   // Bound to Main Render thread.
   base::ThreadChecker main_render_thread_checker_;
-  // CanvasCaptureHandler is owned by CanvasDrawListener in blink and
-  // guaranteed to be alive during the lifetime of this class.
+  // CanvasCaptureHandler is owned by CanvasDrawListener in blink and might be
+  // destroyed before StopCapture() call.
   base::WeakPtr<CanvasCaptureHandler> canvas_handler_;
 };
 
 class CanvasCaptureHandler::CanvasCaptureHandlerDelegate {
  public:
   explicit CanvasCaptureHandlerDelegate(
       media::VideoCapturerSource::VideoCaptureDeliverFrameCB new_frame_callback)
       : new_frame_callback_(new_frame_callback),
         weak_ptr_factory_(this) {
     io_thread_checker_.DetachFromThread();
@@ skipping 26 matching lines @@
 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),
       io_task_runner_(io_task_runner),
       weak_ptr_factory_(this) {
   scoped_ptr<media::VideoCapturerSource> video_source(
-      new CanvasCaptureHandler::VideoCapturerSource(
-          weak_ptr_factory_.GetWeakPtr(), frame_rate));
+      new VideoCapturerSource(weak_ptr_factory_.GetWeakPtr(), frame_rate));
   AddVideoCapturerSourceToVideoTrack(std::move(video_source), track);
 }
 
 CanvasCaptureHandler::~CanvasCaptureHandler() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
 }
 
 // static
@@ skipping 110 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