Migrate VideoSourceProvider to new Mojo types more

This CL applies new Mojo types to VideoSourceProvider interface.

 - Replace MakeStrongBinding with MakeSelfOwnedReceiver.
 - Convert FooRequest to mojo::PendingReceiver.
 - Convert FooPtr to mojo::PendingRemote or mojo::Remote.
 - Replace std::find_if with a for-loop.
 - Replace mojo::Binding with mojo::Receiver

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

content/browser/renderer_host/media/service_video_capture_provider.cc

@@ -157,10 +157,10 @@ void ServiceVideoCaptureProvider::OnServiceStarted() {
   // change events when virtual devices are added to or removed from the
   // service.
   auto service_connection = LazyConnectToService();
-  video_capture::mojom::DevicesChangedObserverPtr observer;
-  mojo::MakeStrongBinding(
+  mojo::PendingRemote<video_capture::mojom::DevicesChangedObserver> observer;
+  mojo::MakeSelfOwnedReceiver(
       std::make_unique<VirtualVideoCaptureDevicesChangedObserver>(),
-      mojo::MakeRequest(&observer));
+      observer.InitWithNewPipeAndPassReceiver());
   service_connection->source_provider()->RegisterVirtualDevicesChangedObserver(
       std::move(observer),
       true /*raise_event_if_virtual_devices_already_present*/);

content/browser/webrtc/webrtc_video_capture_service_enumeration_browsertest.cc

@@ -14,7 +14,8 @@
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "media/base/media_switches.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "services/video_capture/public/cpp/mock_producer.h"
 #include "services/video_capture/public/mojom/device_factory.mojom.h"
@@ -64,16 +65,16 @@ class WebRtcVideoCaptureServiceEnumerationBrowserTest
       public testing::WithParamInterface<TestParams>,
       public video_capture::mojom::DevicesChangedObserver {
  public:
-  WebRtcVideoCaptureServiceEnumerationBrowserTest()
-      : devices_changed_observer_binding_(this) {
+  WebRtcVideoCaptureServiceEnumerationBrowserTest() {
     scoped_feature_list_.InitAndEnableFeature(features::kMojoVideoCapture);
   }
 
   ~WebRtcVideoCaptureServiceEnumerationBrowserTest() override {}
 
   void ConnectToService() {
-    video_capture::mojom::DevicesChangedObserverPtr observer;
-    devices_changed_observer_binding_.Bind(mojo::MakeRequest(&observer));
+    mojo::PendingRemote<video_capture::mojom::DevicesChangedObserver> observer;
+    devices_changed_observer_receiver_.Bind(
+        observer.InitWithNewPipeAndPassReceiver());
     switch (GetParam().api_to_use) {
       case ServiceApi::kSingleClient:
         GetVideoCaptureService().ConnectToDeviceFactory(
@@ -225,8 +226,8 @@ class WebRtcVideoCaptureServiceEnumerationBrowserTest
       shared_memory_devices_by_id_;
 
  private:
-  mojo::Binding<video_capture::mojom::DevicesChangedObserver>
-      devices_changed_observer_binding_;
+  mojo::Receiver<video_capture::mojom::DevicesChangedObserver>
+      devices_changed_observer_receiver_{this};
   base::test::ScopedFeatureList scoped_feature_list_;
   video_capture::mojom::DeviceFactoryPtr factory_;
   video_capture::mojom::VideoSourceProviderPtr video_source_provider_;

services/video_capture/device_factory_media_to_mojo_adapter.cc

@@ -13,7 +13,7 @@
 #include "base/strings/stringprintf.h"
 #include "media/capture/video/fake_video_capture_device.h"
 #include "media/capture/video/video_capture_device_info.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/video_capture/device_media_to_mojo_adapter.h"
 #include "services/video_capture/public/mojom/producer.mojom.h"
 #include "services/video_capture/public/uma/video_capture_service_event.h"
@@ -157,7 +157,7 @@ void DeviceFactoryMediaToMojoAdapter::AddTextureVirtualDevice(
 }
 
 void DeviceFactoryMediaToMojoAdapter::RegisterVirtualDevicesChangedObserver(
-    mojom::DevicesChangedObserverPtr observer,
+    mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
     bool raise_event_if_virtual_devices_already_present) {
   NOTIMPLEMENTED();
 }

services/video_capture/device_factory_media_to_mojo_adapter.h

@@ -56,8 +56,9 @@ class DeviceFactoryMediaToMojoAdapter : public DeviceFactory {
       mojo::PendingReceiver<mojom::TextureVirtualDevice>
           virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
-      mojom::DevicesChangedObserverPtr observer,
+      mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
       bool raise_event_if_virtual_devices_already_present) override;
+
  private:
   struct ActiveDeviceEntry {
     ActiveDeviceEntry();

services/video_capture/public/cpp/mock_device_factory.h

@@ -34,7 +34,8 @@ class MockDeviceFactory : public video_capture::mojom::DeviceFactory {
       mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
           virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
-      video_capture::mojom::DevicesChangedObserverPtr observer,
+      mojo::PendingRemote<video_capture::mojom::DevicesChangedObserver>
+          observer,
       bool raise_event_if_virtual_devices_already_present) override {
     NOTIMPLEMENTED();
   }

services/video_capture/public/cpp/mock_video_source_provider.h

@@ -38,7 +38,8 @@ class MockVideoSourceProvider
       mojo::PendingReceiver<video_capture::mojom::TextureVirtualDevice>
           virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
-      video_capture::mojom::DevicesChangedObserverPtr observer,
+      mojo::PendingRemote<video_capture::mojom::DevicesChangedObserver>
+          observer,
       bool raise_event_if_virtual_devices_already_present) override {
     NOTIMPLEMENTED();
   }

services/video_capture/public/mojom/device_factory.mojom

@@ -70,6 +70,6 @@ interface DeviceFactory {
   // monitored outside the video capture service, and therefore the service
   // does not offer such monitoring.
   RegisterVirtualDevicesChangedObserver(
-      DevicesChangedObserver observer,
+      pending_remote<DevicesChangedObserver> observer,
       bool raise_event_if_virtual_devices_already_present);
 };

services/video_capture/public/mojom/video_source_provider.mojom

@@ -48,7 +48,7 @@ interface VideoSourceProvider {
   // monitored outside the video capture service, and therefore the service
   // does not offer such monitoring.
   RegisterVirtualDevicesChangedObserver(
-      DevicesChangedObserver observer,
+      pending_remote<DevicesChangedObserver> observer,
       bool raise_event_if_virtual_devices_already_present);
 
   // Closes the connection and allows clients to wait until the disconnect has

services/video_capture/test/video_capture_service_unittest.cc

@@ -5,7 +5,8 @@
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/test/mock_callback.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "services/video_capture/public/cpp/mock_producer.h"
 #include "services/video_capture/public/mojom/constants.mojom.h"
 #include "services/video_capture/public/mojom/device.mojom.h"
@@ -78,10 +79,10 @@ TEST_F(VideoCaptureServiceTest, VirtualDeviceEnumeratedAfterAdd) {
 
 TEST_F(VideoCaptureServiceTest,
        AddingAndRemovingVirtualDevicesRaisesDevicesChangedEvent) {
-  mojom::DevicesChangedObserverPtr observer;
+  mojo::PendingRemote<mojom::DevicesChangedObserver> observer;
   MockDevicesChangedObserver mock_observer;
-  mojo::Binding<mojom::DevicesChangedObserver> observer_binding(
-      &mock_observer, mojo::MakeRequest(&observer));
+  mojo::Receiver<mojom::DevicesChangedObserver> observer_receiver(
+      &mock_observer, observer.InitWithNewPipeAndPassReceiver());
   factory_->RegisterVirtualDevicesChangedObserver(
       std::move(observer),
       false /*raise_event_if_virtual_devices_already_present*/);
@@ -125,16 +126,16 @@ TEST_F(VideoCaptureServiceTest,
 // crash or bad state.
 TEST_F(VideoCaptureServiceTest,
        AddAndRemoveVirtualDeviceAfterObserverHasDisconnected) {
-  mojom::DevicesChangedObserverPtr observer;
+  mojo::PendingRemote<mojom::DevicesChangedObserver> observer;
   MockDevicesChangedObserver mock_observer;
-  mojo::Binding<mojom::DevicesChangedObserver> observer_binding(
-      &mock_observer, mojo::MakeRequest(&observer));
+  mojo::Receiver<mojom::DevicesChangedObserver> observer_receiver(
+      &mock_observer, observer.InitWithNewPipeAndPassReceiver());
   factory_->RegisterVirtualDevicesChangedObserver(
       std::move(observer),
       false /*raise_event_if_virtual_devices_already_present*/);
 
   // Disconnect observer
-  observer_binding.Close();
+  observer_receiver.reset();
 
   auto device_context = AddTextureVirtualDevice("TestDevice");
   device_context = nullptr;

services/video_capture/video_source_provider_impl.cc

@@ -72,7 +72,7 @@ void VideoSourceProviderImpl::AddTextureVirtualDevice(
 }
 
 void VideoSourceProviderImpl::RegisterVirtualDevicesChangedObserver(
-    mojom::DevicesChangedObserverPtr observer,
+    mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
     bool raise_event_if_virtual_devices_already_present) {
   device_factory_->RegisterVirtualDevicesChangedObserver(
       std::move(observer), raise_event_if_virtual_devices_already_present);

services/video_capture/video_source_provider_impl.h

@@ -41,7 +41,7 @@ class VideoSourceProviderImpl : public mojom::VideoSourceProvider {
       mojo::PendingReceiver<mojom::TextureVirtualDevice>
           virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
-      mojom::DevicesChangedObserverPtr observer,
+      mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
       bool raise_event_if_virtual_devices_already_present) override;
   void Close(CloseCallback callback) override;
 

services/video_capture/virtual_device_enabled_device_factory.cc

@@ -7,6 +7,9 @@
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/capture/video/video_capture_device_info.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/video_capture/device_factory.h"
 #include "services/video_capture/shared_memory_virtual_device_mojo_adapter.h"
 #include "services/video_capture/texture_virtual_device_mojo_adapter.h"
@@ -18,44 +21,45 @@ class VirtualDeviceEnabledDeviceFactory::VirtualDeviceEntry {
   VirtualDeviceEntry(
       const media::VideoCaptureDeviceInfo& device_info,
       std::unique_ptr<SharedMemoryVirtualDeviceMojoAdapter> device,
-      std::unique_ptr<mojo::Binding<mojom::SharedMemoryVirtualDevice>>
-          producer_binding)
+      std::unique_ptr<mojo::Receiver<mojom::SharedMemoryVirtualDevice>>
+          producer_receiver)
       : device_info_(device_info),
         device_type_(DeviceType::kSharedMemory),
         shared_memory_device_(std::move(device)),
-        shared_memory_producer_binding_(std::move(producer_binding)) {}
+        shared_memory_producer_receiver_(std::move(producer_receiver)) {}
 
-  VirtualDeviceEntry(const media::VideoCaptureDeviceInfo& device_info,
-                     std::unique_ptr<TextureVirtualDeviceMojoAdapter> device,
-                     std::unique_ptr<mojo::Binding<mojom::TextureVirtualDevice>>
-                         producer_binding)
+  VirtualDeviceEntry(
+      const media::VideoCaptureDeviceInfo& device_info,
+      std::unique_ptr<TextureVirtualDeviceMojoAdapter> device,
+      std::unique_ptr<mojo::Receiver<mojom::TextureVirtualDevice>>
+          producer_receiver)
       : device_info_(device_info),
         device_type_(DeviceType::kTexture),
         texture_device_(std::move(device)),
-        texture_producer_binding_(std::move(producer_binding)) {}
+        texture_producer_receiver_(std::move(producer_receiver)) {}
 
   VirtualDeviceEntry(VirtualDeviceEntry&& other) = default;
   VirtualDeviceEntry& operator=(VirtualDeviceEntry&& other) = default;
 
-  bool HasConsumerBinding() { return consumer_binding_ != nullptr; }
+  bool HasConsumerBinding() { return consumer_receiver_ != nullptr; }
 
   void EstablishConsumerBinding(mojom::DeviceRequest device_request,
                                 base::OnceClosure connection_error_handler) {
     switch (device_type_) {
       case DeviceType::kSharedMemory:
-        consumer_binding_ = std::make_unique<mojo::Binding<mojom::Device>>(
+        consumer_receiver_ = std::make_unique<mojo::Receiver<mojom::Device>>(
             shared_memory_device_.get(), std::move(device_request));
         break;
       case DeviceType::kTexture:
-        consumer_binding_ = std::make_unique<mojo::Binding<mojom::Device>>(
+        consumer_receiver_ = std::make_unique<mojo::Receiver<mojom::Device>>(
             texture_device_.get(), std::move(device_request));
         break;
     }
-    consumer_binding_->set_connection_error_handler(
+    consumer_receiver_->set_disconnect_handler(
         std::move(connection_error_handler));
   }
 
-  void ResetConsumerBinding() { consumer_binding_.reset(); }
+  void ResetConsumerBinding() { consumer_receiver_.reset(); }
 
   void StopDevice() {
     if (shared_memory_device_)
@@ -74,15 +78,15 @@ class VirtualDeviceEnabledDeviceFactory::VirtualDeviceEntry {
 
   // Only valid for |device_type_ == kSharedMemory|
   std::unique_ptr<SharedMemoryVirtualDeviceMojoAdapter> shared_memory_device_;
-  std::unique_ptr<mojo::Binding<mojom::SharedMemoryVirtualDevice>>
-      shared_memory_producer_binding_;
+  std::unique_ptr<mojo::Receiver<mojom::SharedMemoryVirtualDevice>>
+      shared_memory_producer_receiver_;
 
   // Only valid for |device_type_ == kTexture|
   std::unique_ptr<TextureVirtualDeviceMojoAdapter> texture_device_;
-  std::unique_ptr<mojo::Binding<mojom::TextureVirtualDevice>>
-      texture_producer_binding_;
+  std::unique_ptr<mojo::Receiver<mojom::TextureVirtualDevice>>
+      texture_producer_receiver_;
 
-  std::unique_ptr<mojo::Binding<mojom::Device>> consumer_binding_;
+  std::unique_ptr<mojo::Receiver<mojom::Device>> consumer_receiver_;
 };
 
 VirtualDeviceEnabledDeviceFactory::VirtualDeviceEnabledDeviceFactory(
@@ -147,15 +151,15 @@ void VirtualDeviceEnabledDeviceFactory::AddSharedMemoryVirtualDevice(
   auto device = std::make_unique<SharedMemoryVirtualDeviceMojoAdapter>(
       std::move(producer),
       send_buffer_handles_to_producer_as_raw_file_descriptors);
-  auto producer_binding =
-      std::make_unique<mojo::Binding<mojom::SharedMemoryVirtualDevice>>(
+  auto producer_receiver =
+      std::make_unique<mojo::Receiver<mojom::SharedMemoryVirtualDevice>>(
           device.get(), std::move(virtual_device_receiver));
-  producer_binding->set_connection_error_handler(
+  producer_receiver->set_disconnect_handler(
       base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
                          OnVirtualDeviceProducerConnectionErrorOrClose,
                      base::Unretained(this), device_id));
   VirtualDeviceEntry device_entry(device_info, std::move(device),
-                                  std::move(producer_binding));
+                                  std::move(producer_receiver));
   virtual_devices_by_id_.insert(
       std::make_pair(device_id, std::move(device_entry)));
   EmitDevicesChangedEvent();
@@ -174,24 +178,26 @@ void VirtualDeviceEnabledDeviceFactory::AddTextureVirtualDevice(
   }
 
   auto device = std::make_unique<TextureVirtualDeviceMojoAdapter>();
-  auto producer_binding =
-      std::make_unique<mojo::Binding<mojom::TextureVirtualDevice>>(
+  auto producer_receiver =
+      std::make_unique<mojo::Receiver<mojom::TextureVirtualDevice>>(
           device.get(), std::move(virtual_device_receiver));
-  producer_binding->set_connection_error_handler(
+  producer_receiver->set_disconnect_handler(
       base::BindOnce(&VirtualDeviceEnabledDeviceFactory::
                          OnVirtualDeviceProducerConnectionErrorOrClose,
                      base::Unretained(this), device_id));
   VirtualDeviceEntry device_entry(device_info, std::move(device),
-                                  std::move(producer_binding));
+                                  std::move(producer_receiver));
   virtual_devices_by_id_.insert(
       std::make_pair(device_id, std::move(device_entry)));
   EmitDevicesChangedEvent();
 }
 
 void VirtualDeviceEnabledDeviceFactory::RegisterVirtualDevicesChangedObserver(
-    mojom::DevicesChangedObserverPtr observer,
+    mojo::PendingRemote<mojom::DevicesChangedObserver> observer_pending_remote,
     bool raise_event_if_virtual_devices_already_present) {
-  observer.set_connection_error_handler(base::BindOnce(
+  mojo::Remote<mojom::DevicesChangedObserver> observer(
+      std::move(observer_pending_remote));
+  observer.set_disconnect_handler(base::BindOnce(
       &VirtualDeviceEnabledDeviceFactory::OnDevicesChangedObserverDisconnected,
       weak_factory_.GetWeakPtr(), observer.get()));
   if (!virtual_devices_by_id_.empty() &&
@@ -234,16 +240,13 @@ void VirtualDeviceEnabledDeviceFactory::EmitDevicesChangedEvent() {
 
 void VirtualDeviceEnabledDeviceFactory::OnDevicesChangedObserverDisconnected(
     mojom::DevicesChangedObserverPtr::Proxy* observer) {
-  auto iter = std::find_if(
-      devices_changed_observers_.begin(), devices_changed_observers_.end(),
-      [observer](const mojom::DevicesChangedObserverPtr& entry) {
-        return entry.get() == observer;
-      });
-  if (iter == devices_changed_observers_.end()) {
-    DCHECK(false);
-    return;
+  for (auto iter = devices_changed_observers_.begin();
+       iter != devices_changed_observers_.end(); ++iter) {
+    if (iter->get() == observer) {
+      devices_changed_observers_.erase(iter);
+      break;
+    }
   }
-  devices_changed_observers_.erase(iter);
 }
 
 }  // namespace video_capture

services/video_capture/virtual_device_enabled_device_factory.h

@@ -8,9 +8,9 @@
 #include <map>
 #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 "mojo/public/cpp/bindings/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"
@@ -41,8 +41,9 @@ class VirtualDeviceEnabledDeviceFactory : public DeviceFactory {
       mojo::PendingReceiver<mojom::TextureVirtualDevice>
           virtual_device_receiver) override;
   void RegisterVirtualDevicesChangedObserver(
-      mojom::DevicesChangedObserverPtr observer,
+      mojo::PendingRemote<mojom::DevicesChangedObserver> observer,
       bool raise_event_if_virtual_devices_already_present) override;
+
  private:
   class VirtualDeviceEntry;
 
@@ -60,7 +61,8 @@ class VirtualDeviceEnabledDeviceFactory : public DeviceFactory {
 
   std::map<std::string, VirtualDeviceEntry> virtual_devices_by_id_;
   const std::unique_ptr<DeviceFactory> device_factory_;
-  std::vector<mojom::DevicesChangedObserverPtr> devices_changed_observers_;
+  std::vector<mojo::Remote<mojom::DevicesChangedObserver>>
+      devices_changed_observers_;
 
   base::WeakPtrFactory<VirtualDeviceEnabledDeviceFactory> weak_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(VirtualDeviceEnabledDeviceFactory);