Migrate DeviceFactory to new Mojo types

This CL applies new Mojo types to DeviceFactory interface.

 - Convert FooRequest to mojo::PendingReceiver.
 - Convert FooPtr to mojo::PendingRemote or mojo::Remote.

Bug: 955171
Change-Id: I10429fd35a8268e947b5ba8a61b5328665092bec
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1865320Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Commit-Queue: Gyuyoung Kim <gyuyoung@igalia.com>
Cr-Commit-Position: refs/heads/master@{#707643}

content/browser/webrtc/webrtc_video_capture_service_browsertest.cc

@@ -238,16 +238,16 @@ class SharedMemoryDeviceExerciser : public VirtualDeviceExerciser,
  public:
   explicit SharedMemoryDeviceExerciser(
       media::mojom::PlaneStridesPtr strides = nullptr)
-      : strides_(std::move(strides)), producer_binding_(this) {}
+      : strides_(std::move(strides)) {}
 
   // VirtualDeviceExerciser implementation.
   void Initialize() override {}
   void RegisterVirtualDeviceAtFactory(
       video_capture::mojom::DeviceFactoryPtr* factory,
       const media::VideoCaptureDeviceInfo& info) override {
-    video_capture::mojom::ProducerPtr producer;
+    mojo::PendingRemote<video_capture::mojom::Producer> producer;
     static const bool kSendBufferHandlesToProducerAsRawFileDescriptors = false;
-    producer_binding_.Bind(mojo::MakeRequest(&producer));
+    producer_receiver_.Bind(producer.InitWithNewPipeAndPassReceiver());
     (*factory)->AddSharedMemoryVirtualDevice(
         info, std::move(producer),
         kSendBufferHandlesToProducerAsRawFileDescriptors,
@@ -266,7 +266,7 @@ class SharedMemoryDeviceExerciser : public VirtualDeviceExerciser,
   }
   void ShutDown() override {
     virtual_device_ = nullptr;
-    producer_binding_.Close();
+    producer_receiver_.reset();
     weak_factory_.InvalidateWeakPtrs();
   }
 
@@ -387,7 +387,7 @@ class SharedMemoryDeviceExerciser : public VirtualDeviceExerciser,
   }
 
   media::mojom::PlaneStridesPtr strides_;
-  mojo::Binding<video_capture::mojom::Producer> producer_binding_;
+  mojo::Receiver<video_capture::mojom::Producer> producer_receiver_{this};
   video_capture::mojom::SharedMemoryVirtualDevicePtr virtual_device_;
   std::map<int32_t /*buffer_id*/, base::WritableSharedMemoryMapping>
       outgoing_buffer_id_to_buffer_map_;

content/browser/webrtc/webrtc_video_capture_service_enumeration_browsertest.cc

@@ -102,20 +102,21 @@ class WebRtcVideoCaptureServiceEnumerationBrowserTest
     closure_to_be_called_on_devices_changed_ = wait_loop.QuitClosure();
     switch (GetParam().device_type) {
       case VirtualDeviceType::kSharedMemory: {
-        video_capture::mojom::SharedMemoryVirtualDevicePtr virtual_device;
-        video_capture::mojom::ProducerPtr producer;
+        mojo::PendingRemote<video_capture::mojom::SharedMemoryVirtualDevice>
+            virtual_device;
+        mojo::PendingRemote<video_capture::mojom::Producer> producer;
         auto mock_producer = std::make_unique<video_capture::MockProducer>(
-            mojo::MakeRequest(&producer));
+            producer.InitWithNewPipeAndPassReceiver());
         switch (GetParam().api_to_use) {
           case ServiceApi::kSingleClient:
             factory_->AddSharedMemoryVirtualDevice(
                 info, std::move(producer), false,
-                mojo::MakeRequest(&virtual_device));
+                virtual_device.InitWithNewPipeAndPassReceiver());
             break;
           case ServiceApi::kMultiClient:
             video_source_provider_->AddSharedMemoryVirtualDevice(
                 info, std::move(producer), false,
-                mojo::MakeRequest(&virtual_device));
+                virtual_device.InitWithNewPipeAndPassReceiver());
             break;
         }
         shared_memory_devices_by_id_.insert(std::make_pair(

services/video_capture/device_factory_media_to_mojo_adapter.cc

@@ -142,15 +142,17 @@ void DeviceFactoryMediaToMojoAdapter::CreateDevice(
 
 void DeviceFactoryMediaToMojoAdapter::AddSharedMemoryVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    mojom::ProducerPtr producer,
+    mojo::PendingRemote<mojom::Producer> producer,
     bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-    mojom::SharedMemoryVirtualDeviceRequest virtual_device_request) {
+    mojo::PendingReceiver<mojom::SharedMemoryVirtualDevice>
+        virtual_device_receiver) {
   NOTIMPLEMENTED();
 }
 
 void DeviceFactoryMediaToMojoAdapter::AddTextureVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    mojom::TextureVirtualDeviceRequest virtual_device_request) {
+    mojo::PendingReceiver<mojom::TextureVirtualDevice>
+        virtual_device_receiver) {
   NOTIMPLEMENTED();
 }
 

services/video_capture/device_factory_media_to_mojo_adapter.h

@@ -10,6 +10,8 @@
 #include "media/capture/video/video_capture_device_client.h"
 #include "media/capture/video/video_capture_system.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/video_capture/device_factory.h"
 #include "services/video_capture/public/mojom/devices_changed_observer.mojom.h"
 
@@ -45,12 +47,14 @@ class DeviceFactoryMediaToMojoAdapter : public DeviceFactory {
                     CreateDeviceCallback callback) override;
   void AddSharedMemoryVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      mojom::ProducerPtr producer,
+      mojo::PendingRemote<mojom::Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-      mojom::SharedMemoryVirtualDeviceRequest virtual_device) override;
+      mojo::PendingReceiver<mojom::SharedMemoryVirtualDevice>
+          virtual_device_receiver) override;
   void AddTextureVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      mojom::TextureVirtualDeviceRequest virtual_device) override;
+      mojo::PendingReceiver<mojom::TextureVirtualDevice>
+          virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
       mojom::DevicesChangedObserverPtr observer,
       bool raise_event_if_virtual_devices_already_present) override;

services/video_capture/public/cpp/mock_device_factory.cc

@@ -23,16 +23,19 @@ void MockDeviceFactory::CreateDevice(
 
 void MockDeviceFactory::AddSharedMemoryVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    video_capture::mojom::ProducerPtr producer,
+    mojo::PendingRemote<video_capture::mojom::Producer> producer,
     bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-    video_capture::mojom::SharedMemoryVirtualDeviceRequest virtual_device) {
-  DoAddVirtualDevice(device_info, producer.get(), &virtual_device);
+    mojo::PendingReceiver<video_capture::mojom::SharedMemoryVirtualDevice>
+        virtual_device_receiver) {
+  DoAddVirtualDevice(device_info, std::move(producer),
+                     std::move(virtual_device_receiver));
 }
 
 void MockDeviceFactory::AddTextureVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    video_capture::mojom::TextureVirtualDeviceRequest virtual_device) {
-  DoAddTextureVirtualDevice(device_info, &virtual_device);
+    mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
+        virtual_device_receiver) {
+  DoAddTextureVirtualDevice(device_info, std::move(virtual_device_receiver));
 }
 
 }  // namespace video_capture

services/video_capture/public/cpp/mock_device_factory.h

@@ -5,6 +5,8 @@
 #ifndef SERVICES_VIDEO_CAPTURE_PUBLIC_CPP_MOCK_DEVICE_FACTORY_H_
 #define SERVICES_VIDEO_CAPTURE_PUBLIC_CPP_MOCK_DEVICE_FACTORY_H_
 
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/video_capture/public/mojom/device_factory.mojom.h"
 #include "services/video_capture/public/mojom/devices_changed_observer.mojom.h"
 #include "services/video_capture/public/mojom/producer.mojom.h"
@@ -23,13 +25,14 @@ class MockDeviceFactory : public video_capture::mojom::DeviceFactory {
                     CreateDeviceCallback callback) override;
   void AddSharedMemoryVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      video_capture::mojom::ProducerPtr producer,
+      mojo::PendingRemote<video_capture::mojom::Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-      video_capture::mojom::SharedMemoryVirtualDeviceRequest virtual_device)
-      override;
-  void AddTextureVirtualDevice(const media::VideoCaptureDeviceInfo& device_info,
-                               video_capture::mojom::TextureVirtualDeviceRequest
-                                   virtual_device) override;
+      mojo::PendingReceiver<video_capture::mojom::SharedMemoryVirtualDevice>
+          virtual_device_receiver) override;
+  void AddTextureVirtualDevice(
+      const media::VideoCaptureDeviceInfo& device_info,
+      mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
+          virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
       video_capture::mojom::DevicesChangedObserverPtr observer,
       bool raise_event_if_virtual_devices_already_present) override {
@@ -41,15 +44,18 @@ class MockDeviceFactory : public video_capture::mojom::DeviceFactory {
                void(const std::string& device_id,
                     video_capture::mojom::DeviceRequest* device_request,
                     CreateDeviceCallback& callback));
-  MOCK_METHOD3(DoAddVirtualDevice,
-               void(const media::VideoCaptureDeviceInfo& device_info,
-                    video_capture::mojom::ProducerProxy* producer,
-                    video_capture::mojom::SharedMemoryVirtualDeviceRequest*
-                        virtual_device_request));
+  MOCK_METHOD3(
+      DoAddVirtualDevice,
+      void(
+          const media::VideoCaptureDeviceInfo& device_info,
+          mojo::PendingRemote<video_capture::mojom::Producer> producer,
+          mojo::PendingReceiver<video_capture::mojom::SharedMemoryVirtualDevice>
+              virtual_device_receiver));
   MOCK_METHOD2(
       DoAddTextureVirtualDevice,
       void(const media::VideoCaptureDeviceInfo& device_info,
-           video_capture::mojom::TextureVirtualDeviceRequest* virtual_device));
+           mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
+               virtual_device_receiver));
 };
 
 }  // namespace video_capture

services/video_capture/public/cpp/mock_video_source_provider.cc

@@ -22,16 +22,19 @@ void MockVideoSourceProvider::GetSourceInfos(GetSourceInfosCallback callback) {
 
 void MockVideoSourceProvider::AddSharedMemoryVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    video_capture::mojom::ProducerPtr producer,
+    mojo::PendingRemote<video_capture::mojom::Producer> producer,
     bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-    video_capture::mojom::SharedMemoryVirtualDeviceRequest virtual_device) {
-  DoAddVirtualDevice(device_info, producer.get(), &virtual_device);
+    mojo::PendingReceiver<video_capture::mojom::SharedMemoryVirtualDevice>
+        virtual_device_receiver) {
+  DoAddVirtualDevice(device_info, std::move(producer),
+                     std::move(virtual_device_receiver));
 }
 
 void MockVideoSourceProvider::AddTextureVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    video_capture::mojom::TextureVirtualDeviceRequest virtual_device) {
-  DoAddTextureVirtualDevice(device_info, &virtual_device);
+    mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
+        virtual_device_receiver) {
+  DoAddTextureVirtualDevice(device_info, std::move(virtual_device_receiver));
 }
 
 void MockVideoSourceProvider::Close(CloseCallback callback) {

services/video_capture/public/cpp/mock_video_source_provider.h

@@ -5,6 +5,8 @@
 #ifndef SERVICES_VIDEO_CAPTURE_PUBLIC_CPP_MOCK_VIDEO_SOURCE_PROVIDER_H_
 #define SERVICES_VIDEO_CAPTURE_PUBLIC_CPP_MOCK_VIDEO_SOURCE_PROVIDER_H_
 
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/video_capture/public/mojom/devices_changed_observer.mojom.h"
 #include "services/video_capture/public/mojom/producer.mojom.h"
 #include "services/video_capture/public/mojom/video_source_provider.mojom.h"
@@ -26,14 +28,15 @@ class MockVideoSourceProvider
 
   void AddSharedMemoryVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      video_capture::mojom::ProducerPtr producer,
+      mojo::PendingRemote<video_capture::mojom::Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-      video_capture::mojom::SharedMemoryVirtualDeviceRequest virtual_device)
-      override;
+      mojo::PendingReceiver<video_capture::mojom::SharedMemoryVirtualDevice>
+          virtual_device_receiver) override;
 
-  void AddTextureVirtualDevice(const media::VideoCaptureDeviceInfo& device_info,
-                               video_capture::mojom::TextureVirtualDeviceRequest
-                                   virtual_device) override;
+  void AddTextureVirtualDevice(
+      const media::VideoCaptureDeviceInfo& device_info,
+      mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
+          virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
       video_capture::mojom::DevicesChangedObserverPtr observer,
       bool raise_event_if_virtual_devices_already_present) override {
@@ -46,15 +49,18 @@ class MockVideoSourceProvider
   MOCK_METHOD2(DoGetVideoSource,
                void(const std::string& device_id,
                     video_capture::mojom::VideoSourceRequest* request));
-  MOCK_METHOD3(DoAddVirtualDevice,
-               void(const media::VideoCaptureDeviceInfo& device_info,
-                    video_capture::mojom::ProducerProxy* producer,
-                    video_capture::mojom::SharedMemoryVirtualDeviceRequest*
-                        virtual_device_request));
+  MOCK_METHOD3(
+      DoAddVirtualDevice,
+      void(
+          const media::VideoCaptureDeviceInfo& device_info,
+          mojo::PendingRemote<video_capture::mojom::Producer> producer,
+          mojo::PendingReceiver<video_capture::mojom::SharedMemoryVirtualDevice>
+              virtual_device_receiver));
   MOCK_METHOD2(
       DoAddTextureVirtualDevice,
       void(const media::VideoCaptureDeviceInfo& device_info,
-           video_capture::mojom::TextureVirtualDeviceRequest* virtual_device));
+           mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
+               virtual_device_receiver));
   MOCK_METHOD1(DoClose, void(CloseCallback& callback));
 };
 

services/video_capture/public/mojom/device_factory.mojom

@@ -54,16 +54,16 @@ interface DeviceFactory {
   // |virtual_device| or the given |producer| is closed.
   AddSharedMemoryVirtualDevice(
       media.mojom.VideoCaptureDeviceInfo device_info,
-      Producer producer,
+      pending_remote<Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-      SharedMemoryVirtualDevice& virtual_device);
+      pending_receiver<SharedMemoryVirtualDevice> virtual_device_receiver);
 
   // Similar to AddSharedMemoryVirtualDevice() but for virtual devices that
   // are fed with textures (via MailboxHolders) allocated by the caller instead
   // of shared memory buffers provided by the service on demand.
   AddTextureVirtualDevice(
       media.mojom.VideoCaptureDeviceInfo device_info,
-      TextureVirtualDevice& virtual_device);
+      pending_receiver<TextureVirtualDevice> virtual_device_receiver);
 
   // Registered observers will get notified whenever a virtual device is added
   // or removed. Note: Changes to non-virtual devices are currently being

services/video_capture/public/mojom/video_source_provider.mojom

@@ -32,16 +32,16 @@ interface VideoSourceProvider {
   // |virtual_device| or the given |producer| is closed.
   AddSharedMemoryVirtualDevice(
       media.mojom.VideoCaptureDeviceInfo device_info,
-      Producer producer,
+      pending_remote<Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-      SharedMemoryVirtualDevice& virtual_device);
+      pending_receiver<SharedMemoryVirtualDevice> virtual_device_receiver);
 
   // Similar to AddSharedMemoryVirtualDevice() but for virtual devices that
   // are fed with textures (via MailboxHolders) allocated by the caller instead
   // of shared memory buffers provided by the service on demand.
   AddTextureVirtualDevice(
       media.mojom.VideoCaptureDeviceInfo device_info,
-      TextureVirtualDevice& virtual_device);
+      pending_receiver<TextureVirtualDevice> virtual_device_receiver);
 
   // Registered observers will get notified whenever a virtual device is added
   // or removed. Note: Changes to non-virtual devices are currently being

services/video_capture/shared_memory_virtual_device_mojo_adapter.cc

@@ -29,7 +29,7 @@ void OnNewBufferAcknowleged(
 namespace video_capture {
 
 SharedMemoryVirtualDeviceMojoAdapter::SharedMemoryVirtualDeviceMojoAdapter(
-    mojom::ProducerPtr producer,
+    mojo::Remote<mojom::Producer> producer,
     bool send_buffer_handles_to_producer_as_raw_file_descriptors)
     : producer_(std::move(producer)),
       send_buffer_handles_to_producer_as_raw_file_descriptors_(
@@ -71,7 +71,8 @@ void SharedMemoryVirtualDeviceMojoAdapter::RequestFrameBuffer(
                                 known_buffer_ids_.end(), buffer_id_to_drop);
     if (entry_iter != known_buffer_ids_.end()) {
       known_buffer_ids_.erase(entry_iter);
-      producer_->OnBufferRetired(buffer_id_to_drop);
+      if (producer_.is_bound())
+        producer_->OnBufferRetired(buffer_id_to_drop);
       if (receiver_.is_bound()) {
         receiver_->OnBufferRetired(buffer_id_to_drop);
       }
@@ -110,9 +111,11 @@ void SharedMemoryVirtualDeviceMojoAdapter::RequestFrameBuffer(
     // because the |producer_| and the |callback| are bound to different
     // message pipes, so the order for calls to |producer_| and |callback|
     // is not guaranteed.
-    producer_->OnNewBuffer(buffer_id, std::move(buffer_handle),
-                           base::BindOnce(&OnNewBufferAcknowleged,
-                                          base::Passed(&callback), buffer_id));
+    if (producer_.is_bound())
+      producer_->OnNewBuffer(
+          buffer_id, std::move(buffer_handle),
+          base::BindOnce(&OnNewBufferAcknowleged, base::Passed(&callback),
+                         buffer_id));
     return;
   }
   std::move(callback).Run(buffer_id);

services/video_capture/shared_memory_virtual_device_mojo_adapter.h

@@ -8,6 +8,7 @@
 #include "base/sequence_checker.h"
 #include "media/capture/video/video_capture_buffer_pool.h"
 #include "media/capture/video_capture_types.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "services/video_capture/public/mojom/device.mojom.h"
 #include "services/video_capture/public/mojom/producer.mojom.h"
@@ -21,7 +22,7 @@ class SharedMemoryVirtualDeviceMojoAdapter
       public mojom::Device {
  public:
   SharedMemoryVirtualDeviceMojoAdapter(
-      mojom::ProducerPtr producer,
+      mojo::Remote<mojom::Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors = false);
   ~SharedMemoryVirtualDeviceMojoAdapter() override;
 
@@ -54,7 +55,7 @@ class SharedMemoryVirtualDeviceMojoAdapter
   void OnReceiverConnectionErrorOrClose();
 
   mojo::Remote<mojom::Receiver> receiver_;
-  mojom::ProducerPtr producer_;
+  mojo::Remote<mojom::Producer> producer_;
   const bool send_buffer_handles_to_producer_as_raw_file_descriptors_;
   scoped_refptr<media::VideoCaptureBufferPool> buffer_pool_;
   std::vector<int> known_buffer_ids_;

services/video_capture/test/video_capture_service_test.cc

@@ -7,6 +7,7 @@
 #include "base/command_line.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/media_switches.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/video_capture/public/cpp/mock_producer.h"
 #include "services/video_capture/public/mojom/constants.mojom.h"
 
@@ -46,9 +47,9 @@ VideoCaptureServiceTest::AddSharedMemoryVirtualDevice(
     const std::string& device_id) {
   media::VideoCaptureDeviceInfo device_info;
   device_info.descriptor.device_id = device_id;
-  mojom::ProducerPtr producer;
+  mojo::PendingRemote<mojom::Producer> producer;
   auto result = std::make_unique<SharedMemoryVirtualDeviceContext>(
-      mojo::MakeRequest(&producer));
+      producer.InitWithNewPipeAndPassReceiver());
   factory_->AddSharedMemoryVirtualDevice(
       device_info, std::move(producer),
       false /* send_buffer_handles_to_producer_as_raw_file_descriptors */,

services/video_capture/test/virtual_device_unittest.cc

@@ -8,6 +8,7 @@
 #include "base/test/mock_callback.h"
 #include "base/test/task_environment.h"
 #include "media/capture/video/video_capture_device_info.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/video_capture/public/cpp/mock_producer.h"
 #include "services/video_capture/public/cpp/mock_receiver.h"
 #include "services/video_capture/shared_memory_virtual_device_mojo_adapter.h"
@@ -37,11 +38,11 @@ class VirtualDeviceTest : public ::testing::Test {
   void SetUp() override {
     device_info_.descriptor.device_id = kTestDeviceId;
     device_info_.descriptor.set_display_name(kTestDeviceName);
-    mojom::ProducerPtr producer_proxy;
+    mojo::Remote<mojom::Producer> producer;
     producer_ =
-        std::make_unique<MockProducer>(mojo::MakeRequest(&producer_proxy));
+        std::make_unique<MockProducer>(producer.BindNewPipeAndPassReceiver());
     device_adapter_ = std::make_unique<SharedMemoryVirtualDeviceMojoAdapter>(
-        std::move(producer_proxy));
+        std::move(producer));
   }
 
   void OnFrameBufferReceived(bool valid_buffer_expected, int32_t buffer_id) {

services/video_capture/video_source_provider_impl.cc

@@ -53,20 +53,22 @@ void VideoSourceProviderImpl::GetVideoSource(
 
 void VideoSourceProviderImpl::AddSharedMemoryVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    mojom::ProducerPtr producer,
+    mojo::PendingRemote<mojom::Producer> producer,
     bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-    mojom::SharedMemoryVirtualDeviceRequest virtual_device) {
+    mojo::PendingReceiver<mojom::SharedMemoryVirtualDevice>
+        virtual_device_receiver) {
   device_factory_->AddSharedMemoryVirtualDevice(
       device_info, std::move(producer),
       send_buffer_handles_to_producer_as_raw_file_descriptors,
-      std::move(virtual_device));
+      std::move(virtual_device_receiver));
 }
 
 void VideoSourceProviderImpl::AddTextureVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    mojom::TextureVirtualDeviceRequest virtual_device) {
+    mojo::PendingReceiver<mojom::TextureVirtualDevice>
+        virtual_device_receiver) {
   device_factory_->AddTextureVirtualDevice(device_info,
-                                           std::move(virtual_device));
+                                           std::move(virtual_device_receiver));
 }
 
 void VideoSourceProviderImpl::RegisterVirtualDevicesChangedObserver(

services/video_capture/video_source_provider_impl.h

@@ -8,6 +8,8 @@
 #include <map>
 
 #include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/video_capture/device_factory.h"
 #include "services/video_capture/public/mojom/video_source_provider.mojom.h"
 
@@ -30,12 +32,14 @@ class VideoSourceProviderImpl : public mojom::VideoSourceProvider {
                       mojom::VideoSourceRequest source_request) override;
   void AddSharedMemoryVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      mojom::ProducerPtr producer,
+      mojo::PendingRemote<mojom::Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-      mojom::SharedMemoryVirtualDeviceRequest virtual_device) override;
+      mojo::PendingReceiver<mojom::SharedMemoryVirtualDevice>
+          virtual_device_receiver) override;
   void AddTextureVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      mojom::TextureVirtualDeviceRequest virtual_device) override;
+      mojo::PendingReceiver<mojom::TextureVirtualDevice>
+          virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
       mojom::DevicesChangedObserverPtr observer,
       bool raise_event_if_virtual_devices_already_present) override;

services/video_capture/virtual_device_enabled_device_factory.cc

@@ -127,9 +127,10 @@ void VirtualDeviceEnabledDeviceFactory::CreateDevice(
 
 void VirtualDeviceEnabledDeviceFactory::AddSharedMemoryVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    mojom::ProducerPtr producer,
+    mojo::PendingRemote<mojom::Producer> producer_pending_remote,
     bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-    mojom::SharedMemoryVirtualDeviceRequest virtual_device_request) {
+    mojo::PendingReceiver<mojom::SharedMemoryVirtualDevice>
+        virtual_device_receiver) {
   auto device_id = device_info.descriptor.device_id;
   auto virtual_device_iter = virtual_devices_by_id_.find(device_id);
   if (virtual_device_iter != virtual_devices_by_id_.end()) {
@@ -138,7 +139,8 @@ void VirtualDeviceEnabledDeviceFactory::AddSharedMemoryVirtualDevice(
     virtual_devices_by_id_.erase(virtual_device_iter);
   }
 
-  producer.set_connection_error_handler(
+  mojo::Remote<mojom::Producer> producer(std::move(producer_pending_remote));
+  producer.set_disconnect_handler(
       base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
                          OnVirtualDeviceProducerConnectionErrorOrClose,
                      base::Unretained(this), device_id));
@@ -147,7 +149,7 @@ void VirtualDeviceEnabledDeviceFactory::AddSharedMemoryVirtualDevice(
       send_buffer_handles_to_producer_as_raw_file_descriptors);
   auto producer_binding =
       std::make_unique<mojo::Binding<mojom::SharedMemoryVirtualDevice>>(
-          device.get(), std::move(virtual_device_request));
+          device.get(), std::move(virtual_device_receiver));
   producer_binding->set_connection_error_handler(
       base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
                          OnVirtualDeviceProducerConnectionErrorOrClose,
@@ -161,7 +163,8 @@ void VirtualDeviceEnabledDeviceFactory::AddSharedMemoryVirtualDevice(
 
 void VirtualDeviceEnabledDeviceFactory::AddTextureVirtualDevice(
     const media::VideoCaptureDeviceInfo& device_info,
-    mojom::TextureVirtualDeviceRequest virtual_device_request) {
+    mojo::PendingReceiver<mojom::TextureVirtualDevice>
+        virtual_device_receiver) {
   auto device_id = device_info.descriptor.device_id;
   auto virtual_device_iter = virtual_devices_by_id_.find(device_id);
   if (virtual_device_iter != virtual_devices_by_id_.end()) {
@@ -173,7 +176,7 @@ void VirtualDeviceEnabledDeviceFactory::AddTextureVirtualDevice(
   auto device = std::make_unique<TextureVirtualDeviceMojoAdapter>();
   auto producer_binding =
       std::make_unique<mojo::Binding<mojom::TextureVirtualDevice>>(
-          device.get(), std::move(virtual_device_request));
+          device.get(), std::move(virtual_device_receiver));
   producer_binding->set_connection_error_handler(
       base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
                          OnVirtualDeviceProducerConnectionErrorOrClose,

services/video_capture/virtual_device_enabled_device_factory.h

@@ -9,6 +9,8 @@
 #include <utility>
 
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/video_capture/device_factory.h"
 #include "services/video_capture/public/mojom/device.mojom.h"
 #include "services/video_capture/public/mojom/devices_changed_observer.mojom.h"
@@ -30,12 +32,14 @@ class VirtualDeviceEnabledDeviceFactory : public DeviceFactory {
                     CreateDeviceCallback callback) override;
   void AddSharedMemoryVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      mojom::ProducerPtr producer,
+      mojo::PendingRemote<mojom::Producer> producer,
       bool send_buffer_handles_to_producer_as_raw_file_descriptors,
-      mojom::SharedMemoryVirtualDeviceRequest virtual_device) override;
+      mojo::PendingReceiver<mojom::SharedMemoryVirtualDevice>
+          virtual_device_receiver) override;
   void AddTextureVirtualDevice(
       const media::VideoCaptureDeviceInfo& device_info,
-      mojom::TextureVirtualDeviceRequest virtual_device) override;
+      mojo::PendingReceiver<mojom::TextureVirtualDevice>
+          virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
       mojom::DevicesChangedObserverPtr observer,
       bool raise_event_if_virtual_devices_already_present) override;