Convert Camera3DeviceOps to new Mojo types

This CL converts Camera3DeviceOps{Ptr, Request} in media to the
new Mojo type, and uses pending_receiver<Camera3DeviceOps> in
camera_common.mojom.

Bug: 955171
Change-Id: I8c751cf880c39e80e00cab5055e96c583bf908ed
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1862443
Commit-Queue: Miyoung Shin <myid.shin@igalia.com>
Reviewed-by: Sam McNally <sammc@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Tommi <tommi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#707811}

media/capture/video/chromeos/camera_device_delegate.cc

@@ -202,17 +202,15 @@ void CameraDeviceDelegate::AllocateAndStart(
   }
   device_context_->SetSensorOrientation(sensor_orientation[0]);
 
-  // |device_ops_| is bound after the MakeRequest call.
-  cros::mojom::Camera3DeviceOpsRequest device_ops_request =
-      mojo::MakeRequest(&device_ops_);
-  device_ops_.set_connection_error_handler(base::BindOnce(
-      &CameraDeviceDelegate::OnMojoConnectionError, GetWeakPtr()));
+  // |device_ops_| is bound after the BindNewPipeAndPassReceiver call.
   camera_hal_delegate_->OpenDevice(
       camera_hal_delegate_->GetCameraIdFromDeviceId(
           device_descriptor_.device_id),
-      std::move(device_ops_request),
+      device_ops_.BindNewPipeAndPassReceiver(),
       BindToCurrentLoop(
           base::BindOnce(&CameraDeviceDelegate::OnOpenedDevice, GetWeakPtr())));
+  device_ops_.set_disconnect_handler(base::BindOnce(
+      &CameraDeviceDelegate::OnMojoConnectionError, GetWeakPtr()));
 }
 
 void CameraDeviceDelegate::StopAndDeAllocate(

media/capture/video/chromeos/camera_device_delegate.h

@@ -15,6 +15,7 @@
 #include "media/capture/video/chromeos/mojom/camera_common.mojom.h"
 #include "media/capture/video/video_capture_device.h"
 #include "media/capture/video_capture_types.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/range/range.h"
 
@@ -194,7 +195,7 @@ class CAPTURE_EXPORT CameraDeviceDelegate final {
   // settings, etc.
   cros::mojom::CameraMetadataPtr static_metadata_;
 
-  cros::mojom::Camera3DeviceOpsPtr device_ops_;
+  mojo::Remote<cros::mojom::Camera3DeviceOps> device_ops_;
 
   // Where all the Mojo IPC calls takes place.
   const scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner_;

media/capture/video/chromeos/camera_device_delegate_unittest.cc

@@ -23,8 +23,8 @@
 #include "media/capture/video/chromeos/mock_video_capture_client.h"
 #include "media/capture/video/chromeos/video_capture_device_factory_chromeos.h"
 #include "media/capture/video/mock_gpu_memory_buffer_manager.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -117,7 +117,7 @@ VideoCaptureParams GetDefaultCaptureParams() {
 class CameraDeviceDelegateTest : public ::testing::Test {
  public:
   CameraDeviceDelegateTest()
-      : mock_camera_device_binding_(&mock_camera_device_),
+      : mock_camera_device_receiver_(&mock_camera_device_),
         device_delegate_thread_("DeviceDelegateThread"),
         hal_delegate_thread_("HalDelegateThread") {}
 
@@ -246,9 +246,9 @@ class CameraDeviceDelegateTest : public ::testing::Test {
 
   void OpenMockCameraDevice(
       int32_t camera_id,
-      cros::mojom::Camera3DeviceOpsRequest& device_ops_request,
+      mojo::PendingReceiver<cros::mojom::Camera3DeviceOps> device_ops_receiver,
       base::OnceCallback<void(int32_t)>& callback) {
-    mock_camera_device_binding_.Bind(std::move(device_ops_request));
+    mock_camera_device_receiver_.Bind(std::move(device_ops_receiver));
     std::move(callback).Run(0);
   }
 
@@ -307,9 +307,7 @@ class CameraDeviceDelegateTest : public ::testing::Test {
   }
 
   void CloseMockCameraDevice(base::OnceCallback<void(int32_t)>& callback) {
-    if (mock_camera_device_binding_.is_bound()) {
-      mock_camera_device_binding_.Close();
-    }
+    mock_camera_device_receiver_.reset();
     callback_ops_.reset();
     std::move(callback).Run(0);
   }
@@ -473,7 +471,7 @@ class CameraDeviceDelegateTest : public ::testing::Test {
   unittest_internal::MockGpuMemoryBufferManager mock_gpu_memory_buffer_manager_;
 
   testing::StrictMock<MockCameraDevice> mock_camera_device_;
-  mojo::Binding<cros::mojom::Camera3DeviceOps> mock_camera_device_binding_;
+  mojo::Receiver<cros::mojom::Camera3DeviceOps> mock_camera_device_receiver_;
   cros::mojom::Camera3CallbackOpsPtr callback_ops_;
 
   base::Thread device_delegate_thread_;
@@ -540,13 +538,15 @@ TEST_F(CameraDeviceDelegateTest, StopBeforeOpened) {
   base::WaitableEvent stop_posted;
   auto open_device_quit_loop_cb =
       [&](int32_t camera_id,
-          cros::mojom::Camera3DeviceOpsRequest& device_ops_request,
+          mojo::PendingReceiver<cros::mojom::Camera3DeviceOps>
+              device_ops_receiver,
           base::OnceCallback<void(int32_t)>& callback) {
         QuitRunLoop();
         // Make sure StopAndDeAllocate() is called before the device opened
         // callback.
         stop_posted.Wait();
-        OpenMockCameraDevice(camera_id, device_ops_request, callback);
+        OpenMockCameraDevice(camera_id, std::move(device_ops_receiver),
+                             callback);
       };
   EXPECT_CALL(mock_camera_module_, DoOpenDevice(0, _, _))
       .Times(1)
@@ -669,15 +669,17 @@ TEST_F(CameraDeviceDelegateTest, FailToOpenDevice) {
       .Times(AtLeast(1))
       .WillRepeatedly(InvokeWithoutArgs(stop_on_error));
 
-  // Hold the |device_ops_request| to make the behavior of CameraDeviceDelegate
+  // Hold the |device_ops_receiver| to make the behavior of CameraDeviceDelegate
   // deterministic. Otherwise the connection error handler would race with the
   // callback of OpenDevice(), because they are in different mojo channels.
-  cros::mojom::Camera3DeviceOpsRequest device_ops_request_holder;
+  mojo::PendingReceiver<cros::mojom::Camera3DeviceOps>
+      device_ops_receiver_holder;
   auto open_device_with_error_cb =
       [&](int32_t camera_id,
-          cros::mojom::Camera3DeviceOpsRequest& device_ops_request,
+          mojo::PendingReceiver<cros::mojom::Camera3DeviceOps>
+              device_ops_receiver,
           base::OnceCallback<void(int32_t)>& callback) {
-        device_ops_request_holder = std::move(device_ops_request);
+        device_ops_receiver_holder = std::move(device_ops_receiver);
         std::move(callback).Run(-ENODEV);
       };
   EXPECT_CALL(mock_camera_module_, DoOpenDevice(0, _, _))

media/capture/video/chromeos/camera_hal_delegate.cc

@@ -326,7 +326,7 @@ cros::mojom::CameraInfoPtr CameraHalDelegate::GetCameraInfoFromDeviceId(
 
 void CameraHalDelegate::OpenDevice(
     int32_t camera_id,
-    cros::mojom::Camera3DeviceOpsRequest device_ops_request,
+    mojo::PendingReceiver<cros::mojom::Camera3DeviceOps> device_ops_receiver,
     OpenDeviceCallback callback) {
   DCHECK(!ipc_task_runner_->BelongsToCurrentThread());
   // This method may be called on any thread except |ipc_task_runner_|.
@@ -336,7 +336,7 @@ void CameraHalDelegate::OpenDevice(
   ipc_task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(&CameraHalDelegate::OpenDeviceOnIpcThread, this, camera_id,
-                     base::Passed(&device_ops_request), std::move(callback)));
+                     std::move(device_ops_receiver), std::move(callback)));
 }
 
 int CameraHalDelegate::GetCameraIdFromDeviceId(const std::string& device_id) {
@@ -506,10 +506,10 @@ void CameraHalDelegate::OnGotCameraInfoOnIpcThread(
 
 void CameraHalDelegate::OpenDeviceOnIpcThread(
     int32_t camera_id,
-    cros::mojom::Camera3DeviceOpsRequest device_ops_request,
+    mojo::PendingReceiver<cros::mojom::Camera3DeviceOps> device_ops_receiver,
     OpenDeviceCallback callback) {
   DCHECK(ipc_task_runner_->BelongsToCurrentThread());
-  camera_module_->OpenDevice(camera_id, std::move(device_ops_request),
+  camera_module_->OpenDevice(camera_id, std::move(device_ops_receiver),
                              std::move(callback));
 }
 

media/capture/video/chromeos/camera_hal_delegate.h

@@ -20,6 +20,7 @@
 #include "media/capture/video/chromeos/vendor_tag_ops_delegate.h"
 #include "media/capture/video/video_capture_device_factory.h"
 #include "media/capture/video_capture_types.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
@@ -72,9 +73,10 @@ class CAPTURE_EXPORT CameraHalDelegate final
   // This method may be called on any thread; |callback| will run on
   // |ipc_task_runner_|.
   using OpenDeviceCallback = base::OnceCallback<void(int32_t)>;
-  void OpenDevice(int32_t camera_id,
-                  cros::mojom::Camera3DeviceOpsRequest device_ops_request,
-                  OpenDeviceCallback callback);
+  void OpenDevice(
+      int32_t camera_id,
+      mojo::PendingReceiver<cros::mojom::Camera3DeviceOps> device_ops_receiver,
+      OpenDeviceCallback callback);
 
   // Gets camera id from device id. Returns -1 on error.
   int GetCameraIdFromDeviceId(const std::string& device_id);
@@ -125,7 +127,7 @@ class CAPTURE_EXPORT CameraHalDelegate final
   // This method runs on |ipc_task_runner_|.
   void OpenDeviceOnIpcThread(
       int32_t camera_id,
-      cros::mojom::Camera3DeviceOpsRequest device_ops_request,
+      mojo::PendingReceiver<cros::mojom::Camera3DeviceOps> device_ops_receiver,
       OpenDeviceCallback callback);
 
   // CameraModuleCallbacks implementation. Operates on |ipc_task_runner_|.

media/capture/video/chromeos/mock_camera_module.cc

@@ -25,9 +25,9 @@ MockCameraModule::~MockCameraModule() {
 
 void MockCameraModule::OpenDevice(
     int32_t camera_id,
-    cros::mojom::Camera3DeviceOpsRequest device_ops_request,
+    mojo::PendingReceiver<cros::mojom::Camera3DeviceOps> device_ops_receiver,
     OpenDeviceCallback callback) {
-  DoOpenDevice(camera_id, device_ops_request, callback);
+  DoOpenDevice(camera_id, std::move(device_ops_receiver), callback);
 }
 
 void MockCameraModule::GetNumberOfCameras(GetNumberOfCamerasCallback callback) {

media/capture/video/chromeos/mock_camera_module.h

@@ -26,12 +26,14 @@ class MockCameraModule : public cros::mojom::CameraModule {
 
   ~MockCameraModule();
 
-  void OpenDevice(int32_t camera_id,
-                  cros::mojom::Camera3DeviceOpsRequest device_ops_request,
-                  OpenDeviceCallback callback) override;
+  void OpenDevice(
+      int32_t camera_id,
+      mojo::PendingReceiver<cros::mojom::Camera3DeviceOps> device_ops_receiver,
+      OpenDeviceCallback callback) override;
   MOCK_METHOD3(DoOpenDevice,
                void(int32_t camera_id,
-                    cros::mojom::Camera3DeviceOpsRequest& device_ops_request,
+                    mojo::PendingReceiver<cros::mojom::Camera3DeviceOps>
+                        device_ops_receiver,
                     OpenDeviceCallback& callback));
 
   void GetNumberOfCameras(GetNumberOfCamerasCallback callback) override;

media/capture/video/chromeos/mojom/camera_common.mojom

@@ -91,7 +91,8 @@ interface VendorTagOps {
 interface CameraModule {
   // Opens the camera device specified by |camera_id|.  On success, the camera
   // device is accessible through the |device_ops| returned.
-  OpenDevice@0(int32 camera_id, Camera3DeviceOps& device_ops_request)
+  OpenDevice@0(int32 camera_id,
+               pending_receiver<Camera3DeviceOps> device_ops_request)
       => (int32 result);
 
   // Gets the number of cameras currently present on the system.