Make V4L2CaptureDelegate non-ref-counted

media/capture/video/linux/video_capture_device_linux.cc

 // Copyright (c) 2012 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 "media/capture/video/linux/video_capture_device_linux.h"
 
 #include <stddef.h>
 
 #include <list>
 
@@ skipping 39 matching lines @@
 void VideoCaptureDeviceLinux::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(!capture_impl_);
   if (v4l2_thread_.IsRunning())
     return;  // Wrong state.
   v4l2_thread_.Start();
 
   const int line_frequency =
       TranslatePowerLineFrequencyToV4L2(GetPowerLineFrequency(params));
-  capture_impl_ = new V4L2CaptureDelegate(
+  capture_impl_ = base::MakeUnique<V4L2CaptureDelegate>(
       device_descriptor_, v4l2_thread_.task_runner(), line_frequency);
   if (!capture_impl_) {
     client->OnError(FROM_HERE, "Failed to create VideoCaptureDelegate");
     return;
   }
   v4l2_thread_.task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&V4L2CaptureDelegate::AllocateAndStart, capture_impl_,
+      base::Bind(&V4L2CaptureDelegate::AllocateAndStart,
+                 base::Unretained(capture_impl_.get()),

[mcasas, 2017/04/12 17:32:55]

Get a WeakPtr to |capture_impl_| to be used on |v4l2_thread_|
for these PostTask()s.

[Chandan, 2017/04/13 09:06:07]

Done.

                  params.requested_format.frame_size.width(),
                  params.requested_format.frame_size.height(),
                  params.requested_format.frame_rate, base::Passed(&client)));

[chfremer, 2017/04/12 17:13:46]

Please add a comment explaining why the use of base::Unretained() is safe. We
should do that either for all sites where we do this, or maybe we can bundle
this information into a class-level comment, in order to avoid duplicating the
comment several times.

[Chandan, 2017/04/13 09:06:07]

We now use WeakPtr to |capture_impl_| instead of base::Unretained().

 
   for (const auto& request : photo_requests_queue_)
     v4l2_thread_.task_runner()->PostTask(FROM_HERE, request);
   photo_requests_queue_.clear();
 }
 
 void VideoCaptureDeviceLinux::StopAndDeAllocate() {
   if (!v4l2_thread_.IsRunning())
     return;  // Wrong state.
   v4l2_thread_.task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2CaptureDelegate::StopAndDeAllocate, capture_impl_));
+      FROM_HERE, base::Bind(&V4L2CaptureDelegate::StopAndDeAllocate,
+                            base::Unretained(capture_impl_.get())));
+  v4l2_thread_.task_runner()->DeleteSoon(FROM_HERE, capture_impl_.release());
   v4l2_thread_.Stop();
-
-  capture_impl_ = nullptr;
 }
 
 void VideoCaptureDeviceLinux::TakePhoto(TakePhotoCallback callback) {
   DCHECK(capture_impl_);
-  auto functor = base::Bind(&V4L2CaptureDelegate::TakePhoto, capture_impl_,
+  auto functor = base::Bind(&V4L2CaptureDelegate::TakePhoto,
+                            base::Unretained(capture_impl_.get()),
                             base::Passed(&callback));
   if (!v4l2_thread_.IsRunning()) {
     // We have to wait until we get the device AllocateAndStart()ed.
     photo_requests_queue_.push_back(std::move(functor));
     return;
   }
   v4l2_thread_.task_runner()->PostTask(FROM_HERE, std::move(functor));
 }
 
 void VideoCaptureDeviceLinux::GetPhotoCapabilities(
     GetPhotoCapabilitiesCallback callback) {
   auto functor = base::Bind(&V4L2CaptureDelegate::GetPhotoCapabilities,
-                            capture_impl_, base::Passed(&callback));
+                            base::Unretained(capture_impl_.get()),
+                            base::Passed(&callback));
   if (!v4l2_thread_.IsRunning()) {
     // We have to wait until we get the device AllocateAndStart()ed.
     photo_requests_queue_.push_back(std::move(functor));
     return;
   }
   v4l2_thread_.task_runner()->PostTask(FROM_HERE, std::move(functor));
 }
 
 void VideoCaptureDeviceLinux::SetPhotoOptions(
     mojom::PhotoSettingsPtr settings,
     SetPhotoOptionsCallback callback) {
-  auto functor =
-      base::Bind(&V4L2CaptureDelegate::SetPhotoOptions, capture_impl_,
-                 base::Passed(&settings), base::Passed(&callback));
+  auto functor = base::Bind(&V4L2CaptureDelegate::SetPhotoOptions,
+                            base::Unretained(capture_impl_.get()),
+                            base::Passed(&settings), base::Passed(&callback));
   if (!v4l2_thread_.IsRunning()) {
     // We have to wait until we get the device AllocateAndStart()ed.
     photo_requests_queue_.push_back(std::move(functor));
     return;
   }
   v4l2_thread_.task_runner()->PostTask(FROM_HERE, std::move(functor));
 }
 
 void VideoCaptureDeviceLinux::SetRotation(int rotation) {
   if (v4l2_thread_.IsRunning()) {
     v4l2_thread_.task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&V4L2CaptureDelegate::SetRotation, capture_impl_, rotation));
+        FROM_HERE, base::Bind(&V4L2CaptureDelegate::SetRotation,
+                              base::Unretained(capture_impl_.get()), rotation));
   }
 }
 
 // static
 int VideoCaptureDeviceLinux::TranslatePowerLineFrequencyToV4L2(
     PowerLineFrequency frequency) {
   switch (frequency) {
     case media::PowerLineFrequency::FREQUENCY_50HZ:
       return V4L2_CID_POWER_LINE_FREQUENCY_50HZ;
     case media::PowerLineFrequency::FREQUENCY_60HZ:
       return V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
     default:
       // If we have no idea of the frequency, at least try and set it to AUTO.
       return V4L2_CID_POWER_LINE_FREQUENCY_AUTO;
   }
 }
 
 }  // namespace media