VideoCapture: moar VideoCapture renderer-->host messages to mojo, part 3

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 197 matching lines @@
 }
 
 void VideoCaptureImpl::RequestRefreshFrame() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   GetVideoCaptureHost()->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) {
-    Send(new VideoCaptureHostMsg_GetDeviceSupportedFormats(device_id_,
-                                                           session_id_));
-  }
+  GetVideoCaptureHost()->GetDeviceSupportedFormats(
+      device_id_, session_id_,
+      base::Bind(&VideoCaptureImpl::OnDeviceSupportedFormats,
+                 weak_factory_.GetWeakPtr(), callback));
 }
 
 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) {
-    Send(
-        new VideoCaptureHostMsg_GetDeviceFormatsInUse(device_id_, session_id_));
-  }
+  GetVideoCaptureHost()->GetDeviceFormatsInUse(
+      device_id_, session_id_,
+      base::Bind(&VideoCaptureImpl::OnDeviceFormatsInUse,
+                 weak_factory_.GetWeakPtr(), callback));
 }
 
 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 216 matching lines @@
         client.second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
       }
       clients_.clear();
       state_ = VIDEO_CAPTURE_STATE_ENDED;
       break;
     default:
       break;
   }
 }
 
-void VideoCaptureImpl::OnDeviceSupportedFormatsEnumerated(
-    const media::VideoCaptureFormats& supported_formats) {
+void VideoCaptureImpl::OnDelegateAdded(int32_t device_id) {
+  DVLOG(1) << __func__ << " " << device_id;
   DCHECK(io_task_runner_->BelongsToCurrentThread());
-  for (size_t i = 0; i < device_formats_cb_queue_.size(); ++i)
-    device_formats_cb_queue_[i].Run(supported_formats);
-  device_formats_cb_queue_.clear();
-}
-
-void VideoCaptureImpl::OnDeviceFormatsInUseReceived(
-    const media::VideoCaptureFormats& formats_in_use) {
-  DCHECK(io_task_runner_->BelongsToCurrentThread());
-  for (size_t i = 0; i < device_formats_in_use_cb_queue_.size(); ++i)
-    device_formats_in_use_cb_queue_[i].Run(formats_in_use);
-  device_formats_in_use_cb_queue_.clear();
-}
-
-void VideoCaptureImpl::OnDelegateAdded(int32_t device_id) {
-  DCHECK(io_task_runner_->BelongsToCurrentThread());
-  DVLOG(1) << "OnDelegateAdded: device_id " << device_id;
 
   device_id_ = device_id;
   ClientInfoMap::iterator it = clients_pending_on_filter_.begin();
   while (it != clients_pending_on_filter_.end()) {
     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);
   }
@@ skipping 30 matching lines @@
 }
 
 void VideoCaptureImpl::StartCaptureInternal() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   DCHECK(device_id_);
 
   GetVideoCaptureHost()->Start(device_id_, session_id_, params_);
   state_ = VIDEO_CAPTURE_STATE_STARTED;
 }
 
+void VideoCaptureImpl::OnDeviceSupportedFormats(
+    const VideoCaptureDeviceFormatsCB& callback,
+    const media::VideoCaptureFormats& supported_formats) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  callback.Run(supported_formats);
+}
+
+void VideoCaptureImpl::OnDeviceFormatsInUse(
+    const VideoCaptureDeviceFormatsCB& callback,
+    const media::VideoCaptureFormats& formats_in_use) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  callback.Run(formats_in_use);
+}
+
 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());
 
   const ClientInfoMap::iterator it = clients->find(client_id);
   if (it == clients->end())
@@ skipping 30 matching lines @@
   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