Reland: VideoCapture: migrate VideoCapture renderer-->host messages to mojo, part 1

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 93 matching lines @@
 VideoCaptureImpl::ClientInfo::ClientInfo(const ClientInfo& other) = default;
 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_service_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)
-    Send(new VideoCaptureHostMsg_Stop(device_id_));
+    GetVideoCaptureService()->Stop(device_id_);
   message_filter_->RemoveDelegate(this);
 }
 
 void VideoCaptureImpl::SuspendCapture(bool suspend) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  Send(suspend ? static_cast<IPC::Message*>(
-                     new VideoCaptureHostMsg_Pause(device_id_))
-               : static_cast<IPC::Message*>(new VideoCaptureHostMsg_Resume(
-                     device_id_, session_id_, params_)));
+  if (suspend)
+    GetVideoCaptureService()->Pause(device_id_);
+  else
+    Send(new VideoCaptureHostMsg_Resume(device_id_, session_id_, params_));
 }
 
 void VideoCaptureImpl::StartCapture(
     int client_id,
     const media::VideoCaptureParams& params,
     const VideoCaptureStateUpdateCB& state_update_cb,
     const VideoCaptureDeliverFrameCB& deliver_frame_cb) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   ClientInfo client_info;
   client_info.params = params;
@@ skipping 44 matching lines @@
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   // A client ID can be in only one client list.
   // If this ID is in any client list, we can just remove it from
   // that client list and don't have to run the other following RemoveClient().
   if (!RemoveClient(client_id, &clients_pending_on_filter_)) {
     if (!RemoveClient(client_id, &clients_pending_on_restart_)) {
       RemoveClient(client_id, &clients_);
     }
   }
 
-  if (clients_.empty()) {
-    DVLOG(1) << "StopCapture: No more client, stopping ...";
-    StopDevice();
-    client_buffers_.clear();
-    client_buffer2s_.clear();
-    weak_factory_.InvalidateWeakPtrs();
-  }
+  if (!clients_.empty())
+    return;
+  DVLOG(1) << "StopCapture: No more client, stopping ...";
+  StopDevice();
+  client_buffers_.clear();
+  client_buffer2s_.clear();
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 void VideoCaptureImpl::RequestRefreshFrame() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  Send(new VideoCaptureHostMsg_RequestRefreshFrame(device_id_));
+  GetVideoCaptureService()->RequestRefreshFrame(device_id_);
 }
 
 void VideoCaptureImpl::GetDeviceSupportedFormats(
     const VideoCaptureDeviceFormatsCB& callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   device_formats_cb_queue_.push_back(callback);
-  if (device_formats_cb_queue_.size() == 1)
+  if (device_formats_cb_queue_.size() == 1) {
     Send(new VideoCaptureHostMsg_GetDeviceSupportedFormats(device_id_,
                                                            session_id_));
+  }
 }
 
 void VideoCaptureImpl::GetDeviceFormatsInUse(
     const VideoCaptureDeviceFormatsCB& callback) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   device_formats_in_use_cb_queue_.push_back(callback);
-  if (device_formats_in_use_cb_queue_.size() == 1)
+  if (device_formats_in_use_cb_queue_.size() == 1) {
     Send(
         new VideoCaptureHostMsg_GetDeviceFormatsInUse(device_id_, session_id_));
+  }
 }
 
 void VideoCaptureImpl::OnBufferCreated(base::SharedMemoryHandle handle,
                                        int length,
                                        int buffer_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // In case client calls StopCapture before the arrival of created buffer,
   // just close this buffer and return.
   if (state_ != VIDEO_CAPTURE_STATE_STARTED) {
@@ skipping 249 matching lines @@
     const int client_id = it->first;
     const ClientInfo client_info = it->second;
     clients_pending_on_filter_.erase(it++);
     StartCapture(client_id, client_info.params, client_info.state_update_cb,
                  client_info.deliver_frame_cb);
   }
 }
 
 void VideoCaptureImpl::StopDevice() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-
-  if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
-    state_ = VIDEO_CAPTURE_STATE_STOPPING;
-    Send(new VideoCaptureHostMsg_Stop(device_id_));
-    params_.requested_format.frame_size.SetSize(0, 0);
-  }
+  if (state_ != VIDEO_CAPTURE_STATE_STARTED)
+    return;
+  state_ = VIDEO_CAPTURE_STATE_STOPPING;
+  GetVideoCaptureService()->Stop(device_id_);
+  params_.requested_format.frame_size.SetSize(0, 0);
 }
 
 void VideoCaptureImpl::RestartCapture() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPED);
 
   int width = 0;
   int height = 0;
   clients_.insert(clients_pending_on_restart_.begin(),
                   clients_pending_on_restart_.end());
@@ skipping 29 matching lines @@
 
   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;
 }
 
+mojom::VideoCaptureService* VideoCaptureImpl::GetVideoCaptureService() {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  if (video_capture_service_for_testing_)
+    return video_capture_service_for_testing_;
+  if (video_capture_service_.get())

[Ken Rockot(use gerrit already), 2016/10/05 20:59:44]

minor nit: a more common pattern is

if (!foo.get()) {
  // initialize foo
}
return foo.get()

fewer return paths generally feels less confusing imho

[mcasas, 2016/10/05 22:23:50]

Done.

+    return video_capture_service_.get();
+
+  DCHECK(message_filter_->sender());
+  message_filter_->sender()
+      ->GetAssociatedInterfaceSupport()
+      ->GetRemoteAssociatedInterface(&video_capture_service_);
+  return video_capture_service_.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