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

content/browser/renderer_host/media/video_capture_host.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 "content/browser/renderer_host/media/video_capture_host.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 126 matching lines @@
   DeleteVideoCaptureController(controller_id, false);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // IPC Messages handler.
 bool VideoCaptureHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(VideoCaptureHost, message)
     IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_BufferReady,
                         OnRendererFinishedWithBuffer)
-    IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_GetDeviceSupportedFormats,
-                        OnGetDeviceSupportedFormats)
-    IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_GetDeviceFormatsInUse,
-                        OnGetDeviceFormatsInUse)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void VideoCaptureHost::OnRendererFinishedWithBuffer(
     int device_id,
     int buffer_id,
     const gpu::SyncToken& sync_token,
     double consumer_resource_utilization) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   VideoCaptureControllerID controller_id(device_id);
   auto it = controllers_.find(controller_id);
   if (it != controllers_.end()) {
     const base::WeakPtr<VideoCaptureController>& controller = it->second;
     if (controller) {
       controller->ReturnBuffer(controller_id, this, buffer_id, sync_token,
                                consumer_resource_utilization);
     }
   }
 }
 
-void VideoCaptureHost::OnGetDeviceSupportedFormats(
-    int device_id,
-    media::VideoCaptureSessionId session_id) {
-  DVLOG(1) << __func__ << " " << device_id;
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  media::VideoCaptureFormats device_supported_formats;
-  if (!media_stream_manager_->video_capture_manager()
-           ->GetDeviceSupportedFormats(session_id,
-                                       &device_supported_formats)) {
-    DLOG(WARNING)
-        << "Could not retrieve device supported formats for device_id="
-        << device_id << " session_id=" << session_id;
-  }
-  Send(new VideoCaptureMsg_DeviceSupportedFormatsEnumerated(
-      device_id, device_supported_formats));
-}
-
-void VideoCaptureHost::OnGetDeviceFormatsInUse(
-    int device_id,
-    media::VideoCaptureSessionId session_id) {
-  DVLOG(1) << __func__ << " " << device_id;
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  media::VideoCaptureFormats formats_in_use;
-  if (!media_stream_manager_->video_capture_manager()->GetDeviceFormatsInUse(
-           session_id, &formats_in_use)) {
-    DVLOG(1) << "Could not retrieve device format(s) in use for device_id="
-             << device_id << " session_id=" << session_id;
-  }
-  Send(new VideoCaptureMsg_DeviceFormatsInUseReceived(device_id,
-                                                      formats_in_use));
-}
-
 void VideoCaptureHost::Start(int32_t device_id,
                              int32_t session_id,
                              const media::VideoCaptureParams& params) {
   DVLOG(1) << __func__ << " session_id=" << session_id
            << ", device_id=" << device_id << ", format="
            << media::VideoCaptureFormat::ToString(params.requested_format);
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const VideoCaptureControllerID controller_id(device_id);
   if (controllers_.find(controller_id) != controllers_.end()) {
     Send(new VideoCaptureMsg_StateChanged(device_id,
@@ skipping 61 matching lines @@
   auto it = controllers_.find(controller_id);
   if (it == controllers_.end())
     return;
 
   if (VideoCaptureController* controller = it->second.get()) {
     media_stream_manager_->video_capture_manager()
         ->RequestRefreshFrameForClient(controller);
   }
 }
 
+void VideoCaptureHost::GetDeviceSupportedFormats(
+    int32_t device_id,
+    int32_t session_id,
+    const GetDeviceSupportedFormatsCallback& callback) {
+  DVLOG(1) << __func__ << " " << device_id;
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  media::VideoCaptureFormats supported_formats;
+  if (!media_stream_manager_->video_capture_manager()
+           ->GetDeviceSupportedFormats(session_id, &supported_formats)) {
+    DLOG(WARNING) << "Could not retrieve device supported formats";
+  }
+  callback.Run(supported_formats);
+}
+
+void VideoCaptureHost::GetDeviceFormatsInUse(
+    int32_t device_id,
+    int32_t session_id,
+    const GetDeviceFormatsInUseCallback& callback) {
+  DVLOG(1) << __func__ << " " << device_id;
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  media::VideoCaptureFormats formats_in_use;
+  if (!media_stream_manager_->video_capture_manager()->GetDeviceFormatsInUse(
+           session_id, &formats_in_use)) {
+    DLOG(WARNING) << "Could not retrieve device format(s) in use";
+  }
+  callback.Run(formats_in_use);
+}
+
 void VideoCaptureHost::OnControllerAdded(
     int device_id,
     const base::WeakPtr<VideoCaptureController>& controller) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VideoCaptureControllerID controller_id(device_id);
   auto it = controllers_.find(controller_id);
   if (it == controllers_.end()) {
     if (controller) {
       media_stream_manager_->video_capture_manager()->StopCaptureForClient(
           controller.get(), controller_id, this, false);
@@ skipping 21 matching lines @@
     return;
 
   if (it->second) {
     media_stream_manager_->video_capture_manager()->StopCaptureForClient(
         it->second.get(), controller_id, this, on_error);
   }
   controllers_.erase(it);
 }
 
 }  // namespace content