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

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 29 matching lines @@
       controllers_.erase(it++);
     }
   }
 }
 
 void VideoCaptureHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 void VideoCaptureHost::OnError(VideoCaptureControllerID controller_id) {
-  DVLOG(1) << "VideoCaptureHost::OnError";
+  DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureHost::DoError, this, controller_id));
 }
 
 void VideoCaptureHost::OnBufferCreated(VideoCaptureControllerID controller_id,
                                        base::SharedMemoryHandle handle,
                                        int length,
                                        int buffer_id) {
@@ skipping 74 matching lines @@
   Send(new VideoCaptureMsg_StateChanged(controller_id,
                                         VIDEO_CAPTURE_STATE_ENDED));
   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_Start, OnStartCapture)
-    IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Resume, OnResumeCapture)
     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::OnStartCapture(int device_id,
-                                      media::VideoCaptureSessionId session_id,
-                                      const media::VideoCaptureParams& params) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << "VideoCaptureHost::OnStartCapture:"
-           << " session_id=" << session_id << ", device_id=" << device_id
-           << ", format="
-           << media::VideoCaptureFormat::ToString(params.requested_format)
-           << "@" << params.requested_format.frame_rate << " ("
-           << (params.resolution_change_policy ==
-                       media::RESOLUTION_POLICY_FIXED_RESOLUTION
-                   ? "fixed resolution"
-                   : (params.resolution_change_policy ==
-                              media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO
-                          ? "fixed aspect ratio"
-                          : "variable resolution")) << ")";
-  VideoCaptureControllerID controller_id(device_id);
-  if (controllers_.find(controller_id) != controllers_.end()) {
-    Send(new VideoCaptureMsg_StateChanged(device_id,
-                                          VIDEO_CAPTURE_STATE_ERROR));
-    return;
-  }
-
-  controllers_[controller_id] = base::WeakPtr<VideoCaptureController>();
-  media_stream_manager_->video_capture_manager()->StartCaptureForClient(
-      session_id,
-      params,
-      PeerHandle(),
-      controller_id,
-      this,
-      base::Bind(&VideoCaptureHost::OnControllerAdded, this, device_id));
-}
-
-void VideoCaptureHost::OnResumeCapture(
-    int device_id,
-    media::VideoCaptureSessionId session_id,
-    const media::VideoCaptureParams& params) {
-  DVLOG(1) << __func__ << " " << device_id;
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  VideoCaptureControllerID controller_id(device_id);
-  auto it = controllers_.find(controller_id);
-  if (it == controllers_.end() || !it->second)
-    return;
-
-  media_stream_manager_->video_capture_manager()->ResumeCaptureForClient(
-      session_id, params, it->second.get(), controller_id, this);
-  Send(new VideoCaptureMsg_StateChanged(device_id,
-                                        VIDEO_CAPTURE_STATE_RESUMED));
-}
-
 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()) {
@@ skipping 30 matching lines @@
   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,
+                                          VIDEO_CAPTURE_STATE_ERROR));
+    return;
+  }
+
+  controllers_[controller_id] = base::WeakPtr<VideoCaptureController>();
+  media_stream_manager_->video_capture_manager()->StartCaptureForClient(
+      session_id,
+      params,
+      PeerHandle(),
+      controller_id,
+      this,
+      base::Bind(&VideoCaptureHost::OnControllerAdded, this, device_id));
+}
+
 void VideoCaptureHost::Stop(int32_t device_id) {
   DVLOG(1) << __func__ << " " << device_id;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   VideoCaptureControllerID controller_id(device_id);
 
   Send(new VideoCaptureMsg_StateChanged(device_id,
                                         VIDEO_CAPTURE_STATE_STOPPED));
   DeleteVideoCaptureController(controller_id, false);
 }
 
 void VideoCaptureHost::Pause(int32_t device_id) {
   DVLOG(1) << __func__ << " " << device_id;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   VideoCaptureControllerID controller_id(device_id);
   auto it = controllers_.find(controller_id);
   if (it == controllers_.end() || !it->second)
     return;
 
   media_stream_manager_->video_capture_manager()->PauseCaptureForClient(
       it->second.get(), controller_id, this);
   Send(new VideoCaptureMsg_StateChanged(device_id, VIDEO_CAPTURE_STATE_PAUSED));
 }
 
+void VideoCaptureHost::Resume(int32_t device_id,
+                              int32_t session_id,
+                              const media::VideoCaptureParams& params) {
+  DVLOG(1) << __func__ << " " << device_id;
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  VideoCaptureControllerID controller_id(device_id);
+  auto it = controllers_.find(controller_id);
+  if (it == controllers_.end() || !it->second)
+    return;
+
+  media_stream_manager_->video_capture_manager()->ResumeCaptureForClient(
+      session_id, params, it->second.get(), controller_id, this);
+  Send(new VideoCaptureMsg_StateChanged(device_id,
+                                        VIDEO_CAPTURE_STATE_RESUMED));
+}
+
 void VideoCaptureHost::RequestRefreshFrame(int32_t device_id) {
   DVLOG(1) << __func__ << " " << device_id;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   VideoCaptureControllerID controller_id(device_id);
   auto it = controllers_.find(controller_id);
   if (it == controllers_.end())
     return;
 
   if (VideoCaptureController* controller = it->second.get()) {
@@ skipping 36 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