VideoCapture: remove last remnants of IPC

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"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
-#include "content/common/media/video_capture_messages.h"
-#include "mojo/public/cpp/system/platform_handle.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace content {
 
 VideoCaptureHost::VideoCaptureHost(MediaStreamManager* media_stream_manager)
-    : BrowserMessageFilter(VideoCaptureMsgStart),
-      BrowserAssociatedInterface(this, this),
-      media_stream_manager_(media_stream_manager) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+    : media_stream_manager_(media_stream_manager),
+      weak_factory_(this) {
+  DVLOG(1) << __func__;
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
-VideoCaptureHost::~VideoCaptureHost() {}
+// static
+void VideoCaptureHost::Create(MediaStreamManager* media_stream_manager,
+                              mojom::VideoCaptureHostRequest request) {
+  DVLOG(1) << __func__;
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  mojo::MakeStrongBinding(
+      base::MakeUnique<VideoCaptureHost>(media_stream_manager),
+      std::move(request));
+}
 
-void VideoCaptureHost::OnChannelClosing() {
-  // Since the IPC sender is gone, close all requested VideoCaptureDevices.
+VideoCaptureHost::~VideoCaptureHost() {
   for (auto it = controllers_.begin(); it != controllers_.end(); ) {
     const base::WeakPtr<VideoCaptureController>& controller = it->second;
     if (controller) {
       const VideoCaptureControllerID controller_id(it->first);
       media_stream_manager_->video_capture_manager()->StopCaptureForClient(
           controller.get(), controller_id, this, false);
       ++it;
     } else {
       // Remove the entry for this controller_id so that when the controller
       // is added, the controller will be notified to stop for this client
       // 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));
+      base::Bind(&VideoCaptureHost::DoError, weak_factory_.GetWeakPtr(),
+                 controller_id));
 }
 
 void VideoCaptureHost::OnBufferCreated(VideoCaptureControllerID controller_id,
                                        mojo::ScopedSharedBufferHandle handle,
                                        int length,
                                        int buffer_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (controllers_.find(controller_id) == controllers_.end())
     return;
 
@@ skipping 36 matching lines @@
 
   device_id_to_observer_map_[controller_id]->OnBufferReady(buffer_id,
                                                            std::move(info));
 }
 
 void VideoCaptureHost::OnEnded(VideoCaptureControllerID controller_id) {
   DVLOG(1) << __func__;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&VideoCaptureHost::DoEnded, this, controller_id));
+      base::Bind(&VideoCaptureHost::DoEnded, weak_factory_.GetWeakPtr(),
+                 controller_id));
 }
 
 void VideoCaptureHost::Start(int32_t device_id,
                              int32_t session_id,
                              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()) {
     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,
-      controller_id,
-      this,
-      base::Bind(&VideoCaptureHost::OnControllerAdded, this, device_id));
+      session_id, params, controller_id, this,
+      base::Bind(&VideoCaptureHost::OnControllerAdded,
+                 weak_factory_.GetWeakPtr(), device_id));
 }
 
 void VideoCaptureHost::Stop(int32_t device_id) {
   DVLOG(1) << __func__ << " " << device_id;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   VideoCaptureControllerID controller_id(device_id);
 
   if (base::ContainsKey(device_id_to_observer_map_, device_id)) {
     device_id_to_observer_map_[device_id]->OnStateChanged(
@@ skipping 172 matching lines @@
   const base::WeakPtr<VideoCaptureController> controller = it->second;
   controllers_.erase(it);
   if (!controller)
     return;
 
   media_stream_manager_->video_capture_manager()->StopCaptureForClient(
       controller.get(), controller_id, this, on_error);
 }
 
 }  // namespace content