VideoCaptureImpl: check that there's still a channel in ~VideoCaptureImpl() before sending

content/renderer/media/video_capture_impl.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.
 //
 // Notes about usage of this object by VideoCaptureImplManager.
 //
 // VideoCaptureImplManager access this object by using a Unretained()
 // binding and tasks on the IO thread. It is then important that
 // VideoCaptureImpl never post task to itself. All operations must be
 // synchronous.
@@ skipping 94 matching lines @@
 VideoCaptureImpl::ClientInfo::~ClientInfo() {}
 
 VideoCaptureImpl::VideoCaptureImpl(
     media::VideoCaptureSessionId session_id,
     VideoCaptureMessageFilter* filter,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : message_filter_(filter),
       device_id_(0),
       session_id_(session_id),
       video_capture_host_for_testing_(nullptr),
-      suspended_(false),
       state_(VIDEO_CAPTURE_STATE_STOPPED),
       io_task_runner_(std::move(io_task_runner)),
       weak_factory_(this) {
   DCHECK(filter);
   io_task_runner_->PostTask(FROM_HERE,
                             base::Bind(&VideoCaptureMessageFilter::AddDelegate,
                                        message_filter_, this));
 }
 
 VideoCaptureImpl::~VideoCaptureImpl() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  if (state_ == VIDEO_CAPTURE_STATE_STARTED)
+  if (state_ == VIDEO_CAPTURE_STATE_STARTED && GetVideoCaptureHost())
     GetVideoCaptureHost()->Stop(device_id_);
   message_filter_->RemoveDelegate(this);
 }
 
 void VideoCaptureImpl::SuspendCapture(bool suspend) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (suspend)
     GetVideoCaptureHost()->Pause(device_id_);
   else
     GetVideoCaptureHost()->Resume(device_id_, session_id_, params_);
@@ skipping 159 matching lines @@
 
 void VideoCaptureImpl::OnBufferReceived(
     int buffer_id,
     base::TimeDelta timestamp,
     const base::DictionaryValue& metadata,
     media::VideoPixelFormat pixel_format,
     media::VideoFrame::StorageType storage_type,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_ ||
+  if (state_ != VIDEO_CAPTURE_STATE_STARTED ||
       pixel_format != media::PIXEL_FORMAT_I420 ||
       (storage_type != media::VideoFrame::STORAGE_SHMEM &&
        storage_type != media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS)) {
     // Crash in debug builds since the host should not have provided a buffer
     // with an unsupported pixel format or storage type.
     DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
     DCHECK(storage_type == media::VideoFrame::STORAGE_SHMEM ||
            storage_type == media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS);
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
                                              gpu::SyncToken(), -1.0));
@@ skipping 218 matching lines @@
   state_ = VIDEO_CAPTURE_STATE_STARTED;
 }
 
 void VideoCaptureImpl::Send(IPC::Message* message) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   message_filter_->Send(message);
 }
 
 bool VideoCaptureImpl::RemoveClient(int client_id, ClientInfoMap* clients) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  bool found = false;
 
   const ClientInfoMap::iterator it = clients->find(client_id);
-  if (it != clients->end()) {
-    it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
-    clients->erase(it);
-    found = true;
-  }
-  return found;
+  if (it == clients->end())
+    return false;
+
+  it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
+  clients->erase(it);
+  return true;
 }
 
 mojom::VideoCaptureHost* VideoCaptureImpl::GetVideoCaptureHost() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (video_capture_host_for_testing_)
     return video_capture_host_for_testing_;
 
   if (!video_capture_host_.get()) {
     DCHECK(message_filter_->channel());
-    message_filter_->channel()
-        ->GetAssociatedInterfaceSupport()
-        ->GetRemoteAssociatedInterface(&video_capture_host_);
+    auto interface_support =
+        message_filter_->channel()->GetAssociatedInterfaceSupport();
+    if (!interface_support)
+      return nullptr;
+    interface_support->GetRemoteAssociatedInterface(&video_capture_host_);
   }
   return video_capture_host_.get();
 };
 
 // static
 void VideoCaptureImpl::DidFinishConsumingFrame(
     const media::VideoFrameMetadata* metadata,
     std::unique_ptr<gpu::SyncToken> release_sync_token,
     const BufferFinishedCallback& callback_to_io_thread) {
   // Note: This function may be called on any thread by the VideoFrame
   // destructor.  |metadata| is still valid for read-access at this point.
   double consumer_resource_utilization = -1.0;
   if (!metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                            &consumer_resource_utilization)) {
     consumer_resource_utilization = -1.0;
   }
 
   callback_to_io_thread.Run(*release_sync_token, consumer_resource_utilization);
 }
 
 }  // namespace content