Convert IsolatedXRGamepadProvider to new Mojo types

This CL converts IsolatedXRGamepadProvider{Ptr, Request} in device
to the new Mojo type, and use
pending_receiver<IsolatedXRGamepadProvider> in
isolated_xr_service.mojom.

Bug: 955171
Change-Id: Ib42d1a7f36c748849bbab5f058fbe7f2c0d129e1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1847531Reviewed-by: Sam McNally <sammc@chromium.org>
Reviewed-by: Piotr Bialecki <bialpio@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Miyoung Shin <myid.shin@igalia.com>
Cr-Commit-Position: refs/heads/master@{#704439}

device/vr/isolated_gamepad_data_fetcher.cc

@@ -77,8 +77,9 @@ IsolatedGamepadDataFetcher::Factory::~Factory() {}
 
 std::unique_ptr<GamepadDataFetcher>
 IsolatedGamepadDataFetcher::Factory::CreateDataFetcher() {
-  device::mojom::IsolatedXRGamepadProviderPtr provider;
-  factory_->GetIsolatedXRGamepadProvider(mojo::MakeRequest(&provider));
+  mojo::PendingRemote<device::mojom::IsolatedXRGamepadProvider> provider;
+  factory_->GetIsolatedXRGamepadProvider(
+      provider.InitWithNewPipeAndPassReceiver());
   return std::make_unique<IsolatedGamepadDataFetcher>(display_id_,
                                                       std::move(provider));
 }
@@ -89,11 +90,11 @@ GamepadSource IsolatedGamepadDataFetcher::Factory::source() {
 
 IsolatedGamepadDataFetcher::IsolatedGamepadDataFetcher(
     device::mojom::XRDeviceId display_id,
-    device::mojom::IsolatedXRGamepadProviderPtr provider)
+    mojo::PendingRemote<device::mojom::IsolatedXRGamepadProvider> provider)
     : display_id_(display_id) {
   // We bind provider_ on the poling thread, but we're created on the main UI
   // thread.
-  provider_info_ = provider.PassInterface();
+  pending_provider_ = std::move(provider);
 }
 
 IsolatedGamepadDataFetcher::~IsolatedGamepadDataFetcher() = default;
@@ -162,8 +163,8 @@ GamepadPose GamepadPoseFromXRPose(device::mojom::VRPose* pose) {
 }
 
 void IsolatedGamepadDataFetcher::GetGamepadData(bool devices_changed_hint) {
-  if (!provider_ && provider_info_) {
-    provider_.Bind(std::move(provider_info_));
+  if (!provider_ && pending_provider_) {
+    provider_.Bind(std::move(pending_provider_));
   }
 
   // If we don't have a provider, we can't give out data.

device/vr/isolated_gamepad_data_fetcher.h

@@ -8,6 +8,8 @@
 #include "device/gamepad/gamepad_data_fetcher.h"
 #include "device/vr/public/mojom/isolated_xr_service.mojom.h"
 #include "device/vr/vr_device.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace device {
 
@@ -33,7 +35,7 @@ class IsolatedGamepadDataFetcher : public GamepadDataFetcher {
 
   IsolatedGamepadDataFetcher(
       device::mojom::XRDeviceId display_id,
-      device::mojom::IsolatedXRGamepadProviderPtr provider);
+      mojo::PendingRemote<device::mojom::IsolatedXRGamepadProvider> provider);
   ~IsolatedGamepadDataFetcher() override;
 
   GamepadSource source() override;
@@ -49,10 +51,10 @@ class IsolatedGamepadDataFetcher : public GamepadDataFetcher {
   bool have_outstanding_request_ = false;
   std::set<unsigned int> active_gamepads_;
   device::mojom::XRGamepadDataPtr data_;
-  device::mojom::IsolatedXRGamepadProviderPtr
+  mojo::Remote<device::mojom::IsolatedXRGamepadProvider>
       provider_;  // Bound on the polling thread.
-  device::mojom::IsolatedXRGamepadProviderPtrInfo
-      provider_info_;  // Received on the UI thread, bound when polled.
+  mojo::PendingRemote<device::mojom::IsolatedXRGamepadProvider>
+      pending_provider_;  // Received on the UI thread, bound when polled.
 
   DISALLOW_COPY_AND_ASSIGN(IsolatedGamepadDataFetcher);
 };

device/vr/oculus/oculus_device.cc

@@ -154,13 +154,13 @@ void OculusDevice::RequestSession(
       return;
     }
 
-    // If we have a pending gamepad provider request when starting the render
-    // loop, post the request over to the render loop to be bound.
-    if (provider_request_) {
+    // If we have a pending gamepad provider receiver when starting the render
+    // loop, post the receiver over to the render loop to be bound.
+    if (provider_receiver_) {
       render_loop_->task_runner()->PostTask(
           FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                     base::Unretained(render_loop_.get()),
-                                    std::move(provider_request_)));
+                                    std::move(provider_receiver_)));
     }
 
     if (overlay_request_) {
@@ -290,18 +290,18 @@ void OculusDevice::StopOvrSession() {
 }
 
 void OculusDevice::GetIsolatedXRGamepadProvider(
-    mojom::IsolatedXRGamepadProviderRequest provider_request) {
-  // We bind the provider_request on the render loop thread, so gamepad data is
+    mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver) {
+  // We bind the provider_receiver on the render loop thread, so gamepad data is
   // updated at the rendering rate.
-  // If we haven't started the render loop yet, postpone binding the request
+  // If we haven't started the render loop yet, postpone binding the receiver
   // until we do.
   if (render_loop_->IsRunning()) {
     render_loop_->task_runner()->PostTask(
         FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                   base::Unretained(render_loop_.get()),
-                                  std::move(provider_request)));
+                                  std::move(provider_receiver)));
   } else {
-    provider_request_ = std::move(provider_request);
+    provider_receiver_ = std::move(provider_receiver);
   }
 }
 

device/vr/oculus/oculus_device.h

@@ -12,6 +12,7 @@
 #include "device/vr/public/mojom/vr_service.mojom.h"
 #include "device/vr/vr_device_base.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "third_party/libovr/src/Include/OVR_CAPI.h"
 
 namespace device {
@@ -52,7 +53,8 @@ class DEVICE_VR_EXPORT OculusDevice
 
   // mojom::IsolatedXRGamepadProviderFactory
   void GetIsolatedXRGamepadProvider(
-      mojom::IsolatedXRGamepadProviderRequest provider_request) override;
+      mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver)
+      override;
 
   // XRCompositorHost
   void CreateImmersiveOverlay(
@@ -72,7 +74,7 @@ class DEVICE_VR_EXPORT OculusDevice
   mojo::Binding<mojom::XRSessionController> exclusive_controller_binding_;
   mojo::Binding<mojom::IsolatedXRGamepadProviderFactory>
       gamepad_provider_factory_binding_;
-  mojom::IsolatedXRGamepadProviderRequest provider_request_;
+  mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver_;
 
   mojo::Binding<mojom::XRCompositorHost> compositor_host_binding_;
   mojom::ImmersiveOverlayRequest overlay_request_;

device/vr/openvr/openvr_device.cc

@@ -181,11 +181,11 @@ void OpenVRDevice::RequestSession(
       return;
     }
 
-    if (provider_request_) {
+    if (provider_receiver_) {
       render_loop_->task_runner()->PostTask(
           FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                     base::Unretained(render_loop_.get()),
-                                    std::move(provider_request_)));
+                                    std::move(provider_receiver_)));
     }
 
     if (overlay_request_) {
@@ -280,14 +280,14 @@ bool OpenVRDevice::IsAvailable() {
 }
 
 void OpenVRDevice::GetIsolatedXRGamepadProvider(
-    mojom::IsolatedXRGamepadProviderRequest provider_request) {
+    mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver) {
   if (render_loop_->IsRunning()) {
     render_loop_->task_runner()->PostTask(
         FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                   base::Unretained(render_loop_.get()),
-                                  std::move(provider_request)));
+                                  std::move(provider_receiver)));
   } else {
-    provider_request_ = std::move(provider_request);
+    provider_receiver_ = std::move(provider_receiver);
   }
 }
 

device/vr/openvr/openvr_device.h

@@ -13,6 +13,7 @@
 #include "device/vr/public/mojom/vr_service.mojom.h"
 #include "device/vr/vr_device_base.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 
 namespace device {
 
@@ -56,7 +57,8 @@ class DEVICE_VR_EXPORT OpenVRDevice
 
   // mojom::IsolatedXRGamepadProviderFactory
   void GetIsolatedXRGamepadProvider(
-      mojom::IsolatedXRGamepadProviderRequest provider_request) override;
+      mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver)
+      override;
 
   // XRCompositorHost
   void CreateImmersiveOverlay(
@@ -76,7 +78,7 @@ class DEVICE_VR_EXPORT OpenVRDevice
 
   mojo::Binding<mojom::IsolatedXRGamepadProviderFactory>
       gamepad_provider_factory_binding_;
-  mojom::IsolatedXRGamepadProviderRequest provider_request_;
+  mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver_;
 
   mojo::Binding<mojom::XRCompositorHost> compositor_host_binding_;
   mojom::ImmersiveOverlayRequest overlay_request_;

device/vr/openxr/openxr_device.cc

@@ -136,11 +136,11 @@ void OpenXrDevice::RequestSession(
       return;
     }
 
-    if (provider_request_) {
+    if (provider_receiver_) {
       render_loop_->task_runner()->PostTask(
           FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                     base::Unretained(render_loop_.get()),
-                                    std::move(provider_request_)));
+                                    std::move(provider_receiver_)));
     }
 
     if (overlay_request_) {
@@ -217,15 +217,15 @@ void OpenXrDevice::SetFrameDataRestricted(bool restricted) {
 }
 
 void OpenXrDevice::GetIsolatedXRGamepadProvider(
-    mojom::IsolatedXRGamepadProviderRequest provider_request) {
+    mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver) {
   EnsureRenderLoop();
   if (render_loop_->IsRunning()) {
     render_loop_->task_runner()->PostTask(
         FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                   base::Unretained(render_loop_.get()),
-                                  std::move(provider_request)));
+                                  std::move(provider_receiver)));
   } else {
-    provider_request_ = std::move(provider_request);
+    provider_receiver_ = std::move(provider_receiver);
   }
 }
 

device/vr/openxr/openxr_device.h

@@ -10,6 +10,7 @@
 #include "base/macros.h"
 #include "device/vr/public/mojom/vr_service.mojom.h"
 #include "device/vr/vr_device_base.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 
 namespace device {
 
@@ -41,7 +42,8 @@ class DEVICE_VR_EXPORT OpenXrDevice
 
   // mojom::IsolatedXRGamepadProviderFactory
   void GetIsolatedXRGamepadProvider(
-      mojom::IsolatedXRGamepadProviderRequest provider_request) override;
+      mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver)
+      override;
 
   // XRCompositorHost
   void CreateImmersiveOverlay(
@@ -60,7 +62,7 @@ class DEVICE_VR_EXPORT OpenXrDevice
 
   mojo::Binding<mojom::IsolatedXRGamepadProviderFactory>
       gamepad_provider_factory_binding_;
-  mojom::IsolatedXRGamepadProviderRequest provider_request_;
+  mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver_;
 
   mojo::Binding<mojom::XRCompositorHost> compositor_host_binding_;
   mojom::ImmersiveOverlayRequest overlay_request_;

device/vr/public/mojom/isolated_xr_service.mojom

@@ -153,7 +153,8 @@ interface IsolatedXRGamepadProviderFactory {
   // Get the IsolatedXRGamepadProvider for a specific XR runtime API (Oculus, or
   // OpenVR, which are currently the only two that are hosted outside of the
   // browser process).
-  GetIsolatedXRGamepadProvider(IsolatedXRGamepadProvider& provider);
+  GetIsolatedXRGamepadProvider(
+      pending_receiver<IsolatedXRGamepadProvider> provider);
 };
 
 // Represents an overlay that the browser may show on top of or instead of WebXR

device/vr/windows/compositor_base.cc

@@ -45,7 +45,6 @@ XRCompositorCommon::XRCompositorCommon()
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       webxr_js_time_(kSlidingAverageSize),
       webxr_gpu_time_(kSlidingAverageSize),
-      gamepad_provider_(this),
       overlay_binding_(this) {
   DCHECK(main_thread_task_runner_);
 }
@@ -138,16 +137,16 @@ void XRCompositorCommon::CleanUp() {
   webxr_has_pose_ = false;
   presentation_receiver_.reset();
   frame_data_receiver_.reset();
-  gamepad_provider_.Close();
+  gamepad_provider_receiver_.reset();
   overlay_binding_.Close();
   input_event_listener_ = nullptr;
   StopRuntime();
 }
 
 void XRCompositorCommon::RequestGamepadProvider(
-    mojom::IsolatedXRGamepadProviderRequest request) {
-  gamepad_provider_.Close();
-  gamepad_provider_.Bind(std::move(request));
+    mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> receiver) {
+  gamepad_provider_receiver_.reset();
+  gamepad_provider_receiver_.Bind(std::move(receiver));
 }
 
 void XRCompositorCommon::RequestOverlay(

device/vr/windows/compositor_base.h

@@ -14,6 +14,7 @@
 #include "device/vr/util/sliding_average.h"
 #include "device/vr/vr_device.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/system/platform_handle.h"
@@ -76,7 +77,8 @@ class XRCompositorCommon : public base::Thread,
       device::mojom::XREnvironmentIntegrationProviderAssociatedRequest
           environment_provider) final;
 
-  void RequestGamepadProvider(mojom::IsolatedXRGamepadProviderRequest request);
+  void RequestGamepadProvider(
+      mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> receiver);
   void RequestOverlay(mojom::ImmersiveOverlayRequest request);
 
  protected:
@@ -181,7 +183,8 @@ class XRCompositorCommon : public base::Thread,
   mojom::IsolatedXRGamepadProvider::RequestUpdateCallback gamepad_callback_;
   mojo::Receiver<mojom::XRPresentationProvider> presentation_receiver_{this};
   mojo::Receiver<mojom::XRFrameDataProvider> frame_data_receiver_{this};
-  mojo::Binding<mojom::IsolatedXRGamepadProvider> gamepad_provider_;
+  mojo::Receiver<mojom::IsolatedXRGamepadProvider> gamepad_provider_receiver_{
+      this};
   mojo::Binding<mojom::ImmersiveOverlay> overlay_binding_;
   mojom::XRVisibilityState visibility_state_ =
       mojom::XRVisibilityState::VISIBLE;

device/vr/windows_mixed_reality/mixed_reality_device.cc

@@ -108,11 +108,11 @@ void MixedRealityDevice::RequestSession(
       return;
     }
 
-    if (provider_request_) {
+    if (provider_receiver_) {
       render_loop_->task_runner()->PostTask(
           FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                     base::Unretained(render_loop_.get()),
-                                    std::move(provider_request_)));
+                                    std::move(provider_receiver_)));
     }
 
     if (overlay_request_) {
@@ -184,16 +184,16 @@ void MixedRealityDevice::OnRequestSessionResult(
 }
 
 void MixedRealityDevice::GetIsolatedXRGamepadProvider(
-    mojom::IsolatedXRGamepadProviderRequest provider_request) {
+    mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver) {
   if (!render_loop_)
     CreateRenderLoop();
   if (render_loop_->IsRunning()) {
     render_loop_->task_runner()->PostTask(
         FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
                                   base::Unretained(render_loop_.get()),
-                                  std::move(provider_request)));
+                                  std::move(provider_receiver)));
   } else {
-    provider_request_ = std::move(provider_request);
+    provider_receiver_ = std::move(provider_receiver);
   }
 }
 

device/vr/windows_mixed_reality/mixed_reality_device.h

@@ -14,6 +14,7 @@
 #include "device/vr/vr_device_base.h"
 #include "device/vr/windows/compositor_base.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 
 namespace device {
 
@@ -40,7 +41,8 @@ class DEVICE_VR_EXPORT MixedRealityDevice
 
   // mojom::IsolatedXRGamepadProviderFactory
   void GetIsolatedXRGamepadProvider(
-      mojom::IsolatedXRGamepadProviderRequest provider_request) override;
+      mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver)
+      override;
 
   // XRCompositorHost
   void CreateImmersiveOverlay(
@@ -58,7 +60,7 @@ class DEVICE_VR_EXPORT MixedRealityDevice
 
   mojo::Binding<mojom::IsolatedXRGamepadProviderFactory>
       gamepad_provider_factory_binding_;
-  mojom::IsolatedXRGamepadProviderRequest provider_request_;
+  mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver_;
 
   mojo::Binding<mojom::XRCompositorHost> compositor_host_binding_;
   mojom::ImmersiveOverlayRequest overlay_request_;