Refactor VideoCapturerDelegate to use WeakPtr instead of refcount.

content/renderer/media/media_stream_video_capturer_source.cc

 // Copyright 2014 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/media_stream_video_capturer_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
@@ skipping 23 matching lines @@
 const double kMaxScreenCastFrameRate = 120.0;
 
 }  // namespace
 
 namespace content {
 
 VideoCapturerDelegate::VideoCapturerDelegate(
     const StreamDeviceInfo& device_info)
     : session_id_(device_info.session_id),
       is_screen_cast_(device_info.device.type == MEDIA_TAB_VIDEO_CAPTURE ||
-                      device_info.device.type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
+                      device_info.device.type == MEDIA_DESKTOP_VIDEO_CAPTURE),
+      weak_factory_(this) {
   DVLOG(3) << "VideoCapturerDelegate::ctor";
 
   // NULL in unit test.
   if (RenderThreadImpl::current()) {
     VideoCaptureImplManager* manager =
         RenderThreadImpl::current()->video_capture_impl_manager();
     if (manager)
       release_device_cb_ = manager->UseDevice(session_id_);
   }
 }
 
 VideoCapturerDelegate::~VideoCapturerDelegate() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(3) << "VideoCapturerDelegate::dtor";
   if (!release_device_cb_.is_null())
     release_device_cb_.Run();
 }
 
 void VideoCapturerDelegate::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
     double max_requested_frame_rate,
     const VideoCaptureDeviceFormatsCB& callback) {
@@ skipping 22 matching lines @@
   VideoCaptureImplManager* manager =
       RenderThreadImpl::current()->video_capture_impl_manager();
   if (!manager)
     return;
   DCHECK(source_formats_callback_.is_null());
   source_formats_callback_ = callback;
   manager->GetDeviceFormatsInUse(
       session_id_,
       media::BindToCurrentLoop(
           base::Bind(
-              &VideoCapturerDelegate::OnDeviceFormatsInUseReceived, this)));
+              &VideoCapturerDelegate::OnDeviceFormatsInUseReceived,
+              weak_factory_.GetWeakPtr())));
 }
 
 void VideoCapturerDelegate::StartCapture(
     const media::VideoCaptureParams& params,
     const VideoCaptureDeliverFrameCB& new_frame_callback,
     const RunningCallback& running_callback) {
   DCHECK(params.requested_format.IsValid());
   DCHECK(thread_checker_.CalledOnValidThread());
   running_callback_ = running_callback;
 
   // NULL in unit test.
   if (!RenderThreadImpl::current())
     return;
   VideoCaptureImplManager* manager =
       RenderThreadImpl::current()->video_capture_impl_manager();
   if (!manager)
     return;
   stop_capture_cb_ =
       manager->StartCapture(
           session_id_,
           params,
           media::BindToCurrentLoop(base::Bind(
-              &VideoCapturerDelegate::OnStateUpdateOnRenderThread, this)),
+              &VideoCapturerDelegate::OnStateUpdateOnRenderThread,
+              weak_factory_.GetWeakPtr())),
           new_frame_callback);
 }
 
 void VideoCapturerDelegate::StopCapture() {
   // Immediately make sure we don't provide more frames.
   DVLOG(3) << "VideoCapturerDelegate::StopCapture()";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!stop_capture_cb_.is_null()) {
     base::ResetAndReturn(&stop_capture_cb_).Run();
   }
@@ skipping 31 matching lines @@
     return;
   }
 
   // NULL in unit test.
   if (!RenderThreadImpl::current())
     return;
   VideoCaptureImplManager* manager =
       RenderThreadImpl::current()->video_capture_impl_manager();
   if (!manager)
     return;
+
   manager->GetDeviceSupportedFormats(
       session_id_,
       media::BindToCurrentLoop(
           base::Bind(
               &VideoCapturerDelegate::OnDeviceSupportedFormatsEnumerated,
-              this)));
+              weak_factory_.GetWeakPtr())));
 }
 
 void VideoCapturerDelegate::OnDeviceSupportedFormatsEnumerated(
     const media::VideoCaptureFormats& formats) {
   DVLOG(3) << "OnDeviceSupportedFormatsEnumerated: " << formats.size()
            << " received";
   DCHECK(thread_checker_.CalledOnValidThread());
   // StopCapture() might have destroyed |source_formats_callback_| before
   // arriving here.
   if (source_formats_callback_.is_null())
     return;
   if (formats.size()) {
-    source_formats_callback_.Run(formats);
+    base::ResetAndReturn(&source_formats_callback_).Run(formats);
   } else {
     // The capture device doesn't seem to support capability enumeration,
     // compose a fallback list of capabilities.
     media::VideoCaptureFormats default_formats;
     for (size_t i = 0; i < arraysize(kVideoResolutions); ++i) {
       for (size_t j = 0; j < arraysize(kVideoFrameRates); ++j) {
         default_formats.push_back(media::VideoCaptureFormat(
             gfx::Size(kVideoResolutions[i].width, kVideoResolutions[i].height),
             kVideoFrameRates[j], media::PIXEL_FORMAT_I420));
       }
     }
-    source_formats_callback_.Run(default_formats);
+    base::ResetAndReturn(&source_formats_callback_).Run(default_formats);
   }
-  source_formats_callback_.Reset();
 }
 
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
     const StreamDeviceInfo& device_info,
     const SourceStoppedCallback& stop_callback,
-    const scoped_refptr<VideoCapturerDelegate>& delegate)
-    : delegate_(delegate) {
+    scoped_ptr<VideoCapturerDelegate> delegate)
+    : delegate_(delegate.Pass()) {
   SetDeviceInfo(device_info);
   SetStopCallback(stop_callback);
 }
 
 MediaStreamVideoCapturerSource::~MediaStreamVideoCapturerSource() {
 }
 
 void MediaStreamVideoCapturerSource::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
@@ skipping 21 matching lines @@
       frame_callback,
       base::Bind(&MediaStreamVideoCapturerSource::OnStartDone,
                  base::Unretained(this)));
 }
 
 void MediaStreamVideoCapturerSource::StopSourceImpl() {
   delegate_->StopCapture();
 }
 
 }  // namespace content