Convert XRTestHook to new Mojo types

This CL converts XRTestHookPtr and mojo:Binding<XRTestHook> in
chrome to the new Mojo type, and use pending_remote<XRTestHook> in
browser_test_interfaces.mojom.

Bug: 955171
Change-Id: I0b89731dcd91ab1150f7b9f574c4b5eaa42471a7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1847594
Commit-Queue: Miyoung Shin <myid.shin@igalia.com>
Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Sam McNally <sammc@chromium.org>
Reviewed-by: Klaus Weidner <klausw@chromium.org>
Cr-Commit-Position: refs/heads/master@{#705400}

chrome/browser/vr/test/mock_xr_device_hook_base.cc

@@ -50,20 +50,16 @@ device_test::mojom::ControllerFrameDataPtr DeviceToMojoControllerFrameData(
 }
 
 MockXRDeviceHookBase::MockXRDeviceHookBase()
-    : tracked_classes_{device_test::mojom::TrackedDeviceClass::
-                           kTrackedDeviceInvalid},
-      binding_(this) {
+    : tracked_classes_{
+          device_test::mojom::TrackedDeviceClass::kTrackedDeviceInvalid} {
   vr::GetXRDeviceService()->BindTestHook(
       service_test_hook_.BindNewPipeAndPassReceiver());
 
-  device_test::mojom::XRTestHookPtr client;
-  binding_.Bind(mojo::MakeRequest(&client));
-
   mojo::ScopedAllowSyncCallForTesting scoped_allow_sync;
   // For now, always have the HMD connected.
   tracked_classes_[0] =
       device_test::mojom::TrackedDeviceClass::kTrackedDeviceHmd;
-  service_test_hook_->SetTestHook(std::move(client));
+  service_test_hook_->SetTestHook(receiver_.BindNewPipeAndPassRemote());
 }
 
 MockXRDeviceHookBase::~MockXRDeviceHookBase() {
@@ -71,10 +67,10 @@ MockXRDeviceHookBase::~MockXRDeviceHookBase() {
 }
 
 void MockXRDeviceHookBase::StopHooking() {
-  // We don't call service_test_hook_->SetTestHook(nullptr), since that
-  // will potentially deadlock with reentrant or crossing synchronous mojo
+  // We don't call service_test_hook_->SetTestHook(mojo::NullRemote()), since
+  // that will potentially deadlock with reentrant or crossing synchronous mojo
   // calls.
-  binding_.Close();
+  receiver_.reset();
   service_test_hook_.reset();
 }
 

chrome/browser/vr/test/mock_xr_device_hook_base.h

@@ -8,7 +8,7 @@
 #include "base/containers/flat_map.h"
 #include "device/vr/public/mojom/browser_test_interfaces.mojom.h"
 #include "device/vr/test/test_hook.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 
 class MockXRDeviceHookBase : public device_test::mojom::XRTestHook {
@@ -63,7 +63,7 @@ class MockXRDeviceHookBase : public device_test::mojom::XRTestHook {
       controller_data_map_;
 
  private:
-  mojo::Binding<device_test::mojom::XRTestHook> binding_;
+  mojo::Receiver<device_test::mojom::XRTestHook> receiver_{this};
   mojo::Remote<device_test::mojom::XRServiceTestHook> service_test_hook_;
 };
 

chrome/services/isolated_xr_device/xr_service_test_hook.cc

@@ -45,12 +45,11 @@ void UnsetTestHook(std::unique_ptr<device::XRTestHookWrapper> wrapper) {
 namespace device {
 
 void XRServiceTestHook::SetTestHook(
-    device_test::mojom::XRTestHookPtr hook,
+    mojo::PendingRemote<device_test::mojom::XRTestHook> hook,
     device_test::mojom::XRServiceTestHook::SetTestHookCallback callback) {
   // Create a new wrapper (or use null)
   std::unique_ptr<XRTestHookWrapper> wrapper =
-      hook ? std::make_unique<XRTestHookWrapper>(hook.PassInterface())
-           : nullptr;
+      hook ? std::make_unique<XRTestHookWrapper>(std::move(hook)) : nullptr;
 
   // Register the wrapper testhook with the VR runtimes
 #if BUILDFLAG(ENABLE_OPENVR)

chrome/services/isolated_xr_device/xr_service_test_hook.h

@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "device/vr/public/mojom/browser_test_interfaces.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace device {
 class XRTestHookWrapper;
@@ -20,7 +21,7 @@ class XRServiceTestHook : public device_test::mojom::XRServiceTestHook {
   using DeviceCrashCallback = device_test::mojom::XRServiceTestHook::
       TerminateDeviceServiceProcessForTestingCallback;
   // device_test::mojom::XRServiceTestHook
-  void SetTestHook(device_test::mojom::XRTestHookPtr hook,
+  void SetTestHook(mojo::PendingRemote<device_test::mojom::XRTestHook> hook,
                    device_test::mojom::XRServiceTestHook::SetTestHookCallback
                        callback) override;
   void TerminateDeviceServiceProcessForTesting(

chrome/services/isolated_xr_device/xr_test_hook_wrapper.cc

@@ -35,8 +35,8 @@ PoseFrameData MojoToDevicePoseFrameData(
 }
 
 XRTestHookWrapper::XRTestHookWrapper(
-    device_test::mojom::XRTestHookPtrInfo hook_info)
-    : hook_info_(std::move(hook_info)) {}
+    mojo::PendingRemote<device_test::mojom::XRTestHook> pending_hook)
+    : pending_hook_(std::move(pending_hook)) {}
 
 void XRTestHookWrapper::OnFrameSubmitted(SubmittedFrameData frame_data) {
   if (hook_) {
@@ -176,17 +176,15 @@ bool XRTestHookWrapper::WaitGetSessionStateStopping() {
 }
 
 void XRTestHookWrapper::AttachCurrentThread() {
-  if (hook_info_) {
-    hook_.Bind(std::move(hook_info_));
-  }
+  if (pending_hook_)
+    hook_.Bind(std::move(pending_hook_));
 
   current_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 void XRTestHookWrapper::DetachCurrentThread() {
-  if (hook_) {
-    hook_info_ = hook_.PassInterface();
-  }
+  if (hook_)
+    pending_hook_ = hook_.Unbind();
 
   current_task_runner_ = nullptr;
 }

chrome/services/isolated_xr_device/xr_test_hook_wrapper.h

@@ -7,6 +7,8 @@
 
 #include "device/vr/public/mojom/browser_test_interfaces.mojom.h"
 #include "device/vr/test/test_hook.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace device {
 
@@ -14,12 +16,13 @@ namespace device {
 // of VR runtimes are single-threaded at a time, and we initialize/uninitialize
 // as we switch between immersive and non-immersive sessions.
 // The mojo pointer is thread-affine, but we can keep the same mojo connection
-// by getting its PtrInfo so we temporarily make the test hook mojo pointer
-// live on the thread that we are using the VR runtime on while the runtime is
-// initialized.
+// by getting its pending remote so we temporarily make the test hook mojo
+// pointer live on the thread that we are using the VR runtime on while the
+// runtime is initialized.
 class XRTestHookWrapper : public VRTestHook {
  public:
-  explicit XRTestHookWrapper(device_test::mojom::XRTestHookPtrInfo hook_info);
+  explicit XRTestHookWrapper(
+      mojo::PendingRemote<device_test::mojom::XRTestHook> hook_info);
   virtual ~XRTestHookWrapper();
 
   void OnFrameSubmitted(SubmittedFrameData frame_data) override;
@@ -37,8 +40,8 @@ class XRTestHookWrapper : public VRTestHook {
   scoped_refptr<base::SingleThreadTaskRunner> GetBoundTaskRunner();
 
  private:
-  device_test::mojom::XRTestHookPtr hook_;
-  device_test::mojom::XRTestHookPtrInfo hook_info_;
+  mojo::Remote<device_test::mojom::XRTestHook> hook_;
+  mojo::PendingRemote<device_test::mojom::XRTestHook> pending_hook_;
   scoped_refptr<base::SingleThreadTaskRunner> current_task_runner_;
 };
 

device/vr/public/mojom/browser_test_interfaces.mojom

@@ -128,7 +128,7 @@ interface XRTestHook {
 // It is always hosted in the XRDevice process, but only has effects while
 // running in browser tests with mock implementations of runtimes.
 interface XRServiceTestHook {
-  [Sync] SetTestHook(XRTestHook? hook) => ();
+  [Sync] SetTestHook(pending_remote<XRTestHook>? hook) => ();
 
   // Called by tests to trigger a termination of the Device Service Process
   // To test that the product can properly handle the service either crashing