VideoCapture: migrate last Renderer-->Host msg and start Host-->Renderer migration

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 28 matching lines @@
       // in DoControllerAdded.
       controllers_.erase(it++);
     }
   }
 }
 
 void VideoCaptureHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
+bool VideoCaptureHost::OnMessageReceived(const IPC::Message& message) {
+  NOTREACHED() << __func__ << " should not be receiving messages";
+  return true;
+}
+
 void VideoCaptureHost::OnError(VideoCaptureControllerID controller_id) {
   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,
@@ skipping 43 matching lines @@
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureHost::DoEnded, this, controller_id));
 }
 
 void VideoCaptureHost::DoError(VideoCaptureControllerID controller_id) {
   DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (controllers_.find(controller_id) == controllers_.end())
     return;
 
-  Send(new VideoCaptureMsg_StateChanged(controller_id,
-                                        VIDEO_CAPTURE_STATE_ERROR));
+  if (base::ContainsKey(device_id_to_observer_map_, controller_id)) {
+    device_id_to_observer_map_[controller_id]->OnStateChanged(
+        mojom::VideoCaptureState::FAILED);
+  }
+
   DeleteVideoCaptureController(controller_id, true);
 }
 
 void VideoCaptureHost::DoEnded(VideoCaptureControllerID controller_id) {
   DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (controllers_.find(controller_id) == controllers_.end())
     return;
 
-  Send(new VideoCaptureMsg_StateChanged(controller_id,
-                                        VIDEO_CAPTURE_STATE_ENDED));
+  if (base::ContainsKey(device_id_to_observer_map_, controller_id)) {
+    device_id_to_observer_map_[controller_id]->OnStateChanged(
+        mojom::VideoCaptureState::ENDED);
+  }
+
   DeleteVideoCaptureController(controller_id, false);
 }
 
-bool VideoCaptureHost::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(VideoCaptureHost, message)
-    IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_BufferReady,
-                        OnRendererFinishedWithBuffer)
-    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::Start(int32_t device_id,
                              int32_t session_id,
-                             const media::VideoCaptureParams& params) {
+                             const media::VideoCaptureParams& params,
+                             mojom::VideoCaptureObserverPtr observer) {
   DVLOG(1) << __func__ << " session_id=" << session_id
            << ", device_id=" << device_id << ", format="
            << media::VideoCaptureFormat::ToString(params.requested_format);
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  DCHECK(!base::ContainsKey(device_id_to_observer_map_, device_id));
+  device_id_to_observer_map_[device_id] = std::move(observer);
+
   const VideoCaptureControllerID controller_id(device_id);
   if (controllers_.find(controller_id) != controllers_.end()) {
-    Send(new VideoCaptureMsg_StateChanged(device_id,
-                                          VIDEO_CAPTURE_STATE_ERROR));
+    device_id_to_observer_map_[device_id]->OnStateChanged(
+        mojom::VideoCaptureState::STARTED);
     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));
+  if (base::ContainsKey(device_id_to_observer_map_, device_id)) {
+    device_id_to_observer_map_[device_id]->OnStateChanged(
+        mojom::VideoCaptureState::STOPPED);
+  }
+  device_id_to_observer_map_.erase(controller_id);
+
   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));
+  if (base::ContainsKey(device_id_to_observer_map_, device_id)) {
+    device_id_to_observer_map_[device_id]->OnStateChanged(
+        mojom::VideoCaptureState::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));
+  if (base::ContainsKey(device_id_to_observer_map_, device_id)) {
+    device_id_to_observer_map_[device_id]->OnStateChanged(
+        mojom::VideoCaptureState::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()) {
     media_stream_manager_->video_capture_manager()
         ->RequestRefreshFrameForClient(controller);
   }
 }
 
+void VideoCaptureHost::ReleaseBuffer(int32_t device_id,
+                                     int32_t 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())
+    return;
+
+  const base::WeakPtr<VideoCaptureController>& controller = it->second;
+  if (controller) {
+    controller->ReturnBuffer(controller_id, this, buffer_id, sync_token,
+                             consumer_resource_utilization);
+  }
+}
+
 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";
@@ skipping 23 matching lines @@
   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);
     }
     return;
   }
 
   if (!controller) {
-    Send(new VideoCaptureMsg_StateChanged(device_id,
-                                          VIDEO_CAPTURE_STATE_ERROR));
+    if (base::ContainsKey(device_id_to_observer_map_, controller_id)) {
+      device_id_to_observer_map_[device_id]->OnStateChanged(
+          mojom::VideoCaptureState::FAILED);
+    }
     controllers_.erase(controller_id);
     return;
   }
 
+  if (base::ContainsKey(device_id_to_observer_map_, controller_id)) {
+    device_id_to_observer_map_[device_id]->OnStateChanged(
+        mojom::VideoCaptureState::STARTED);
+  }
+
   DCHECK(!it->second);
   it->second = controller;
 }
 
 void VideoCaptureHost::DeleteVideoCaptureController(
     VideoCaptureControllerID controller_id, bool on_error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   auto it = controllers_.find(controller_id);
   if (it == controllers_.end())
     return;
 
   if (it->second) {
     media_stream_manager_->video_capture_manager()->StopCaptureForClient(
         it->second.get(), controller_id, this, on_error);
   }
   controllers_.erase(it);
 }
 
 }  // namespace content