diff --git a/components/webxr/android/arcore_device_provider.cc b/components/webxr/android/arcore_device_provider.cc
index 6bb16b5181e343..714e8c06b0a2b5 100644
--- a/components/webxr/android/arcore_device_provider.cc
+++ b/components/webxr/android/arcore_device_provider.cc
@@ -19,16 +19,7 @@ ArCoreDeviceProvider::ArCoreDeviceProvider(
 
 ArCoreDeviceProvider::~ArCoreDeviceProvider() = default;
 
-void ArCoreDeviceProvider::Initialize(
-    base::RepeatingCallback<void(device::mojom::XRDeviceId,
-                                 device::mojom::VRDisplayInfoPtr,
-                                 device::mojom::XRDeviceDataPtr,
-                                 mojo::PendingRemote<device::mojom::XRRuntime>)>
-        add_device_callback,
-    base::RepeatingCallback<void(device::mojom::XRDeviceId)>
-        remove_device_callback,
-    base::OnceClosure initialization_complete,
-    device::XrFrameSinkClientFactory xr_frame_sink_client_factory) {
+void ArCoreDeviceProvider::Initialize(device::VRDeviceProviderClient* client) {
   if (device::IsArCoreSupported()) {
     DVLOG(2) << __func__ << ": ARCore is supported, creating device";
 
@@ -37,14 +28,14 @@ void ArCoreDeviceProvider::Initialize(
         std::make_unique<device::ArImageTransportFactory>(),
         std::make_unique<webxr::MailboxToSurfaceBridgeFactoryImpl>(),
         std::make_unique<webxr::ArCoreJavaUtils>(compositor_delegate_provider_),
-        std::move(xr_frame_sink_client_factory));
+        client->GetXrFrameSinkClientFactory());
 
-    add_device_callback.Run(
+    client->AddRuntime(
         arcore_device_->GetId(), arcore_device_->GetVRDisplayInfo(),
         arcore_device_->GetDeviceData(), arcore_device_->BindXRRuntime());
   }
   initialized_ = true;
-  std::move(initialization_complete).Run();
+  client->OnProviderInitialized();
 }
 
 bool ArCoreDeviceProvider::Initialized() {
diff --git a/components/webxr/android/arcore_device_provider.h b/components/webxr/android/arcore_device_provider.h
index 15b43d19c2afcb..74af836b143721 100644
--- a/components/webxr/android/arcore_device_provider.h
+++ b/components/webxr/android/arcore_device_provider.h
@@ -28,16 +28,7 @@ class ArCoreDeviceProvider : public device::VRDeviceProvider {
   ArCoreDeviceProvider& operator=(const ArCoreDeviceProvider&) = delete;
 
   ~ArCoreDeviceProvider() override;
-  void Initialize(
-      base::RepeatingCallback<void(
-          device::mojom::XRDeviceId,
-          device::mojom::VRDisplayInfoPtr,
-          device::mojom::XRDeviceDataPtr,
-          mojo::PendingRemote<device::mojom::XRRuntime>)> add_device_callback,
-      base::RepeatingCallback<void(device::mojom::XRDeviceId)>
-          remove_device_callback,
-      base::OnceClosure initialization_complete,
-      device::XrFrameSinkClientFactory xr_frame_sink_client_factory) override;
+  void Initialize(device::VRDeviceProviderClient* client) override;
   bool Initialized() override;
 
  private:
diff --git a/content/browser/xr/service/isolated_device_provider.cc b/content/browser/xr/service/isolated_device_provider.cc
index ee25ce297fcd06..f7b0c40f666c1d 100644
--- a/content/browser/xr/service/isolated_device_provider.cc
+++ b/content/browser/xr/service/isolated_device_provider.cc
@@ -16,19 +16,8 @@ constexpr int kMaxRetries = 3;
 namespace content {
 
 void IsolatedVRDeviceProvider::Initialize(
-    base::RepeatingCallback<void(device::mojom::XRDeviceId,
-                                 device::mojom::VRDisplayInfoPtr,
-                                 device::mojom::XRDeviceDataPtr,
-                                 mojo::PendingRemote<device::mojom::XRRuntime>)>
-        add_device_callback,
-    base::RepeatingCallback<void(device::mojom::XRDeviceId)>
-        remove_device_callback,
-    base::OnceClosure initialization_complete,
-    device::XrFrameSinkClientFactory xr_frame_sink_client_factory) {
-  add_device_callback_ = std::move(add_device_callback);
-  remove_device_callback_ = std::move(remove_device_callback);
-  initialization_complete_ = std::move(initialization_complete);
-
+    device::VRDeviceProviderClient* client) {
+  client_ = client;
   SetupDeviceProvider();
 }
 
@@ -41,8 +30,8 @@ void IsolatedVRDeviceProvider::OnDeviceAdded(
     mojo::PendingRemote<device::mojom::XRCompositorHost> compositor_host,
     device::mojom::XRDeviceDataPtr device_data,
     device::mojom::XRDeviceId device_id) {
-  add_device_callback_.Run(device_id, nullptr, std::move(device_data),
-                           std::move(device));
+  client_->AddRuntime(device_id, nullptr, std::move(device_data),
+                      std::move(device));
 
   auto* integration_client = GetXrIntegrationClient();
   if (!integration_client)
@@ -56,7 +45,7 @@ void IsolatedVRDeviceProvider::OnDeviceAdded(
 }
 
 void IsolatedVRDeviceProvider::OnDeviceRemoved(device::mojom::XRDeviceId id) {
-  remove_device_callback_.Run(id);
+  client_->RemoveRuntime(id);
   ui_host_map_.erase(id);
 }
 
@@ -65,7 +54,7 @@ void IsolatedVRDeviceProvider::OnServerError() {
   // should be removed.
   for (auto& entry : ui_host_map_) {
     auto id = entry.first;
-    remove_device_callback_.Run(id);
+    client_->RemoveRuntime(id);
   }
   ui_host_map_.clear();
 
@@ -88,7 +77,7 @@ void IsolatedVRDeviceProvider::OnServerError() {
 void IsolatedVRDeviceProvider::OnDevicesEnumerated() {
   if (!initialized_) {
     initialized_ = true;
-    std::move(initialization_complete_).Run();
+    client_->OnProviderInitialized();
   }
 
   // Either we've hit the max retries and given up (in which case we don't have
diff --git a/content/browser/xr/service/isolated_device_provider.h b/content/browser/xr/service/isolated_device_provider.h
index f65036e173571a..3bf72bec039a6e 100644
--- a/content/browser/xr/service/isolated_device_provider.h
+++ b/content/browser/xr/service/isolated_device_provider.h
@@ -26,16 +26,7 @@ class IsolatedVRDeviceProvider
   ~IsolatedVRDeviceProvider() override;
 
   // If the VR API requires initialization that should happen here.
-  void Initialize(
-      base::RepeatingCallback<void(
-          device::mojom::XRDeviceId,
-          device::mojom::VRDisplayInfoPtr,
-          device::mojom::XRDeviceDataPtr,
-          mojo::PendingRemote<device::mojom::XRRuntime>)> add_device_callback,
-      base::RepeatingCallback<void(device::mojom::XRDeviceId)>
-          remove_device_callback,
-      base::OnceClosure initialization_complete,
-      device::XrFrameSinkClientFactory xr_frame_sink_client_factory) override;
+  void Initialize(device::VRDeviceProviderClient* client) override;
 
   // Returns true if initialization is complete.
   bool Initialized() override;
@@ -56,15 +47,7 @@ class IsolatedVRDeviceProvider
   int retry_count_ = 0;
   mojo::Remote<device::mojom::IsolatedXRRuntimeProvider> device_provider_;
 
-  // TODO(crbug.com/1090029): Wrap XRDeviceId + VRDisplayInfo into XRDeviceData
-  base::RepeatingCallback<void(device::mojom::XRDeviceId,
-                               device::mojom::VRDisplayInfoPtr,
-                               device::mojom::XRDeviceDataPtr,
-                               mojo::PendingRemote<device::mojom::XRRuntime>)>
-      add_device_callback_;
-  base::RepeatingCallback<void(device::mojom::XRDeviceId)>
-      remove_device_callback_;
-  base::OnceClosure initialization_complete_;
+  device::VRDeviceProviderClient* client_ = nullptr;
   mojo::Receiver<device::mojom::IsolatedXRRuntimeProviderClient> receiver_{
       this};
 
diff --git a/content/browser/xr/service/xr_runtime_manager_impl.cc b/content/browser/xr/service/xr_runtime_manager_impl.cc
index 0bcc089ceccd84..2a212db0d14cf6 100644
--- a/content/browser/xr/service/xr_runtime_manager_impl.cc
+++ b/content/browser/xr/service/xr_runtime_manager_impl.cc
@@ -503,14 +503,10 @@ void XRRuntimeManagerImpl::InitializeProviders() {
       continue;
     }
 
-    provider->Initialize(
-        base::BindRepeating(&XRRuntimeManagerImpl::AddRuntime,
-                            base::Unretained(this)),
-        base::BindRepeating(&XRRuntimeManagerImpl::RemoveRuntime,
-                            base::Unretained(this)),
-        base::BindOnce(&XRRuntimeManagerImpl::OnProviderInitialized,
-                       base::Unretained(this)),
-        base::BindRepeating(&FrameSinkClientFactory));
+    // It is acceptable for the providers to potentially take/keep a reference
+    // to ourselves here, since we own the providers and can guarantee that they
+    // will not outlive us.
+    provider->Initialize(this);
   }
 
   providers_initialized_ = true;
@@ -573,6 +569,11 @@ void XRRuntimeManagerImpl::RemoveRuntime(device::mojom::XRDeviceId id) {
     service->RuntimesChanged();
 }
 
+device::XrFrameSinkClientFactory
+XRRuntimeManagerImpl::GetXrFrameSinkClientFactory() {
+  return base::BindRepeating(&FrameSinkClientFactory);
+}
+
 void XRRuntimeManagerImpl::ForEachRuntime(
     base::RepeatingCallback<void(BrowserXRRuntime*)> fn) {
   for (auto& runtime : runtimes_) {
diff --git a/content/browser/xr/service/xr_runtime_manager_impl.h b/content/browser/xr/service/xr_runtime_manager_impl.h
index 0f8ced406861d7..c6aa70076843e3 100644
--- a/content/browser/xr/service/xr_runtime_manager_impl.h
+++ b/content/browser/xr/service/xr_runtime_manager_impl.h
@@ -23,6 +23,7 @@
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/xr_integration_client.h"
 #include "content/public/browser/xr_runtime_manager.h"
+#include "device/vr/public/cpp/vr_device_provider.h"
 #include "device/vr/public/mojom/vr_service.mojom-forward.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 
@@ -38,7 +39,8 @@ class XRRuntimeManagerTest;
 class CONTENT_EXPORT XRRuntimeManagerImpl
     : public XRRuntimeManager,
       public base::RefCounted<XRRuntimeManagerImpl>,
-      public content::GpuDataManagerObserver {
+      public content::GpuDataManagerObserver,
+      public device::VRDeviceProviderClient {
  public:
   friend base::RefCounted<XRRuntimeManagerImpl>;
   static constexpr auto kRefCountPreference =
@@ -92,6 +94,16 @@ class CONTENT_EXPORT XRRuntimeManagerImpl
   void ForEachRuntime(
       base::RepeatingCallback<void(BrowserXRRuntime*)> fn) override;
 
+  // VRDeviceProviderClient implementation
+  void AddRuntime(
+      device::mojom::XRDeviceId id,
+      device::mojom::VRDisplayInfoPtr info,
+      device::mojom::XRDeviceDataPtr device_data,
+      mojo::PendingRemote<device::mojom::XRRuntime> runtime) override;
+  void RemoveRuntime(device::mojom::XRDeviceId id) override;
+  void OnProviderInitialized() override;
+  device::XrFrameSinkClientFactory GetXrFrameSinkClientFactory() override;
+
  private:
   // Constructor also used by tests to supply an arbitrary list of providers
   static scoped_refptr<XRRuntimeManagerImpl> CreateInstance(
@@ -108,15 +120,8 @@ class CONTENT_EXPORT XRRuntimeManagerImpl
   ~XRRuntimeManagerImpl() override;
 
   void InitializeProviders();
-  void OnProviderInitialized();
   bool AreAllProvidersInitialized();
 
-  void AddRuntime(device::mojom::XRDeviceId id,
-                  device::mojom::VRDisplayInfoPtr info,
-                  device::mojom::XRDeviceDataPtr device_data,
-                  mojo::PendingRemote<device::mojom::XRRuntime> runtime);
-  void RemoveRuntime(device::mojom::XRDeviceId id);
-
   bool IsInitializedOnCompatibleAdapter(BrowserXRRuntimeImpl* runtime);
 
   // Gets the system default immersive-vr runtime if available.
diff --git a/device/vr/android/gvr/gvr_device_provider.cc b/device/vr/android/gvr/gvr_device_provider.cc
index a5c208596262b8..6055202f0eb5dd 100644
--- a/device/vr/android/gvr/gvr_device_provider.cc
+++ b/device/vr/android/gvr/gvr_device_provider.cc
@@ -14,15 +14,7 @@ namespace device {
 GvrDeviceProvider::GvrDeviceProvider() = default;
 GvrDeviceProvider::~GvrDeviceProvider() = default;
 
-void GvrDeviceProvider::Initialize(
-    base::RepeatingCallback<void(mojom::XRDeviceId,
-                                 mojom::VRDisplayInfoPtr,
-                                 mojom::XRDeviceDataPtr,
-                                 mojo::PendingRemote<mojom::XRRuntime>)>
-        add_device_callback,
-    base::RepeatingCallback<void(mojom::XRDeviceId)> remove_device_callback,
-    base::OnceClosure initialization_complete,
-    XrFrameSinkClientFactory xr_frame_sink_client_factory) {
+void GvrDeviceProvider::Initialize(VRDeviceProviderClient* client) {
   // We only expose GvrDevice if
   //  - we could potentially install VRServices to support presentation, and
   //  - this build is a bundle and, thus, supports installing the VR module.
@@ -30,12 +22,12 @@ void GvrDeviceProvider::Initialize(
     vr_device_ = base::WrapUnique(new GvrDevice());
   }
   if (vr_device_) {
-    add_device_callback.Run(vr_device_->GetId(), vr_device_->GetVRDisplayInfo(),
-                            vr_device_->GetDeviceData(),
-                            vr_device_->BindXRRuntime());
+    client->AddRuntime(vr_device_->GetId(), vr_device_->GetVRDisplayInfo(),
+                       vr_device_->GetDeviceData(),
+                       vr_device_->BindXRRuntime());
   }
   initialized_ = true;
-  std::move(initialization_complete).Run();
+  client->OnProviderInitialized();
 }
 
 bool GvrDeviceProvider::Initialized() {
diff --git a/device/vr/android/gvr/gvr_device_provider.h b/device/vr/android/gvr/gvr_device_provider.h
index 0de4b21ad32638..46afc96d3194d7 100644
--- a/device/vr/android/gvr/gvr_device_provider.h
+++ b/device/vr/android/gvr/gvr_device_provider.h
@@ -24,16 +24,7 @@ class DEVICE_VR_EXPORT GvrDeviceProvider : public VRDeviceProvider {
 
   ~GvrDeviceProvider() override;
 
-  void Initialize(
-      base::RepeatingCallback<void(mojom::XRDeviceId,
-                                   mojom::VRDisplayInfoPtr,
-                                   mojom::XRDeviceDataPtr,
-                                   mojo::PendingRemote<mojom::XRRuntime>)>
-          add_device_callback,
-      base::RepeatingCallback<void(mojom::XRDeviceId)> remove_device_callback,
-      base::OnceClosure initialization_complete,
-      XrFrameSinkClientFactory xr_frame_sink_client_factory) override;
-
+  void Initialize(VRDeviceProviderClient* client) override;
   bool Initialized() override;
 
  private:
diff --git a/device/vr/orientation/orientation_device_provider.cc b/device/vr/orientation/orientation_device_provider.cc
index 2ac2eb2e5405a5..c2bca59efa61b0 100644
--- a/device/vr/orientation/orientation_device_provider.cc
+++ b/device/vr/orientation/orientation_device_provider.cc
@@ -19,28 +19,19 @@ VROrientationDeviceProvider::VROrientationDeviceProvider(
 
 VROrientationDeviceProvider::~VROrientationDeviceProvider() = default;
 
-void VROrientationDeviceProvider::Initialize(
-    base::RepeatingCallback<void(mojom::XRDeviceId,
-                                 mojom::VRDisplayInfoPtr,
-                                 mojom::XRDeviceDataPtr,
-                                 mojo::PendingRemote<mojom::XRRuntime>)>
-        add_device_callback,
-    base::RepeatingCallback<void(mojom::XRDeviceId)> remove_device_callback,
-    base::OnceClosure initialization_complete,
-    XrFrameSinkClientFactory xr_frame_sink_client_factory) {
+void VROrientationDeviceProvider::Initialize(VRDeviceProviderClient* client) {
   if (device_ && device_->IsAvailable()) {
-    add_device_callback.Run(device_->GetId(), device_->GetVRDisplayInfo(),
-                            device_->GetDeviceData(), device_->BindXRRuntime());
+    client->AddRuntime(device_->GetId(), device_->GetVRDisplayInfo(),
+                       device_->GetDeviceData(), device_->BindXRRuntime());
     return;
   }
 
   if (!device_) {
+    client_ = client;
     device_ = std::make_unique<VROrientationDevice>(
         sensor_provider_.get(),
         base::BindOnce(&VROrientationDeviceProvider::DeviceInitialized,
                        base::Unretained(this)));
-    add_device_callback_ = add_device_callback;
-    initialized_callback_ = std::move(initialization_complete);
   }
 }
 
@@ -56,13 +47,12 @@ void VROrientationDeviceProvider::DeviceInitialized() {
 
   // If the device successfully connected to the orientation APIs, provide it.
   if (device_->IsAvailable()) {
-    add_device_callback_.Run(device_->GetId(), device_->GetVRDisplayInfo(),
-                             device_->GetDeviceData(),
-                             device_->BindXRRuntime());
+    client_->AddRuntime(device_->GetId(), device_->GetVRDisplayInfo(),
+                        device_->GetDeviceData(), device_->BindXRRuntime());
   }
 
   initialized_ = true;
-  std::move(initialized_callback_).Run();
+  client_->OnProviderInitialized();
 }
 
 }  // namespace device
diff --git a/device/vr/orientation/orientation_device_provider.h b/device/vr/orientation/orientation_device_provider.h
index 3a4ae6445a3a86..1f46dab67a32e5 100644
--- a/device/vr/orientation/orientation_device_provider.h
+++ b/device/vr/orientation/orientation_device_provider.h
@@ -29,15 +29,7 @@ class COMPONENT_EXPORT(VR_ORIENTATION) VROrientationDeviceProvider
 
   ~VROrientationDeviceProvider() override;
 
-  void Initialize(
-      base::RepeatingCallback<void(mojom::XRDeviceId,
-                                   mojom::VRDisplayInfoPtr,
-                                   mojom::XRDeviceDataPtr,
-                                   mojo::PendingRemote<mojom::XRRuntime>)>
-          add_device_callback,
-      base::RepeatingCallback<void(mojom::XRDeviceId)> remove_device_callback,
-      base::OnceClosure initialization_complete,
-      XrFrameSinkClientFactory xr_frame_sink_client_factory) override;
+  void Initialize(VRDeviceProviderClient* client) override;
 
   bool Initialized() override;
 
@@ -49,13 +41,7 @@ class COMPONENT_EXPORT(VR_ORIENTATION) VROrientationDeviceProvider
   mojo::Remote<device::mojom::SensorProvider> sensor_provider_;
 
   std::unique_ptr<VROrientationDevice> device_;
-
-  base::RepeatingCallback<void(mojom::XRDeviceId,
-                               mojom::VRDisplayInfoPtr,
-                               mojom::XRDeviceDataPtr,
-                               mojo::PendingRemote<mojom::XRRuntime>)>
-      add_device_callback_;
-  base::OnceClosure initialized_callback_;
+  VRDeviceProviderClient* client_ = nullptr;
 };
 
 }  // namespace device
diff --git a/device/vr/orientation/orientation_device_provider_unittest.cc b/device/vr/orientation/orientation_device_provider_unittest.cc
index cb14e072913fa3..cb1f37d8877961 100644
--- a/device/vr/orientation/orientation_device_provider_unittest.cc
+++ b/device/vr/orientation/orientation_device_provider_unittest.cc
@@ -94,58 +94,6 @@ class VROrientationDeviceProviderTest : public testing::Test {
     return init_params;
   }
 
-  base::RepeatingCallback<void(device::mojom::XRDeviceId,
-                               mojom::VRDisplayInfoPtr,
-                               mojom::XRDeviceDataPtr,
-                               mojo::PendingRemote<mojom::XRRuntime> device)>
-  DeviceAndIdCallbackFailIfCalled() {
-    return base::BindRepeating(
-        [](device::mojom::XRDeviceId id, mojom::VRDisplayInfoPtr,
-           mojom::XRDeviceDataPtr,
-           mojo::PendingRemote<mojom::XRRuntime> device) { FAIL(); });
-  }
-
-  base::RepeatingCallback<void(device::mojom::XRDeviceId)>
-  DeviceIdCallbackFailIfCalled() {
-    return base::BindRepeating([](device::mojom::XRDeviceId id) { FAIL(); });
-  }
-
-  base::RepeatingCallback<void(device::mojom::XRDeviceId,
-                               mojom::VRDisplayInfoPtr,
-                               mojom::XRDeviceDataPtr,
-                               mojo::PendingRemote<mojom::XRRuntime> device)>
-  DeviceAndIdCallbackMustBeCalled(base::RunLoop* loop) {
-    return base::BindRepeating(
-        [](base::OnceClosure quit_closure, device::mojom::XRDeviceId id,
-           mojom::VRDisplayInfoPtr info, mojom::XRDeviceDataPtr data,
-           mojo::PendingRemote<mojom::XRRuntime> device) {
-          ASSERT_TRUE(device);
-          ASSERT_TRUE(info);
-          ASSERT_TRUE(data);
-          std::move(quit_closure).Run();
-        },
-        loop->QuitClosure());
-  }
-
-  base::RepeatingCallback<void(device::mojom::XRDeviceId)>
-  DeviceIdCallbackMustBeCalled(base::RunLoop* loop) {
-    return base::BindRepeating(
-        [](base::OnceClosure quit_closure, device::mojom::XRDeviceId id) {
-          std::move(quit_closure).Run();
-        },
-        loop->QuitClosure());
-  }
-
-  base::OnceClosure ClosureFailIfCalled() {
-    return base::BindOnce([]() { FAIL(); });
-  }
-
-  base::OnceClosure ClosureMustBeCalled(base::RunLoop* loop) {
-    return base::BindOnce(
-        [](base::OnceClosure quit_closure) { std::move(quit_closure).Run(); },
-        loop->QuitClosure());
-  }
-
   // Needed for MakeRequest to work.
   base::test::TaskEnvironment task_environment_;
 
@@ -161,6 +109,56 @@ class VROrientationDeviceProviderTest : public testing::Test {
   mojo::Remote<mojom::SensorClient> sensor_client_;
 };
 
+class MockOrientationDeviceProviderClient : public VRDeviceProviderClient {
+ public:
+  MockOrientationDeviceProviderClient(base::RunLoop* wait_for_device,
+                                      base::RunLoop* wait_for_init)
+      : wait_for_device_(wait_for_device), wait_for_init_(wait_for_init) {}
+  ~MockOrientationDeviceProviderClient() override = default;
+  void AddRuntime(
+      device::mojom::XRDeviceId id,
+      device::mojom::VRDisplayInfoPtr info,
+      device::mojom::XRDeviceDataPtr device_data,
+      mojo::PendingRemote<device::mojom::XRRuntime> runtime) override {
+    if (wait_for_device_) {
+      ASSERT_TRUE(info);
+      ASSERT_TRUE(device_data);
+      ASSERT_TRUE(runtime);
+      wait_for_device_->Quit();
+      return;
+    }
+
+    // If we were created without a wait_for_device runloop, then the test
+    // is not expecting us to be called.
+    FAIL();
+  }
+
+  void RemoveRuntime(device::mojom::XRDeviceId id) override {
+    // The only devices that actually create an Orientation device cannot
+    // physically remove the orientation sensors, so this should never be
+    // called.
+    FAIL();
+  }
+
+  void OnProviderInitialized() override {
+    if (!wait_for_init_) {
+      FAIL();
+    }
+
+    wait_for_init_->Quit();
+  }
+
+  device::XrFrameSinkClientFactory GetXrFrameSinkClientFactory() override {
+    ADD_FAILURE();
+
+    return base::BindRepeating(&FrameSinkClientFactory);
+  }
+
+ private:
+  base::RunLoop* wait_for_device_ = nullptr;
+  base::RunLoop* wait_for_init_ = nullptr;
+};
+
 TEST_F(VROrientationDeviceProviderTest, InitializationTest) {
   // Check that without running anything, the provider will not be initialized.
   EXPECT_FALSE(provider_->Initialized());
@@ -170,10 +168,9 @@ TEST_F(VROrientationDeviceProviderTest, InitializationCallbackSuccessTest) {
   base::RunLoop wait_for_device;
   base::RunLoop wait_for_init;
 
-  provider_->Initialize(DeviceAndIdCallbackMustBeCalled(&wait_for_device),
-                        DeviceIdCallbackFailIfCalled(),
-                        ClosureMustBeCalled(&wait_for_init),
-                        base::BindRepeating(&FrameSinkClientFactory));
+  MockOrientationDeviceProviderClient client(&wait_for_device, &wait_for_init);
+
+  provider_->Initialize(&client);
 
   InitializeDevice(FakeInitParams());
 
@@ -186,10 +183,8 @@ TEST_F(VROrientationDeviceProviderTest, InitializationCallbackSuccessTest) {
 TEST_F(VROrientationDeviceProviderTest, InitializationCallbackFailureTest) {
   base::RunLoop wait_for_init;
 
-  provider_->Initialize(DeviceAndIdCallbackFailIfCalled(),
-                        DeviceIdCallbackFailIfCalled(),
-                        ClosureMustBeCalled(&wait_for_init),
-                        base::BindRepeating(&FrameSinkClientFactory));
+  MockOrientationDeviceProviderClient client(nullptr, &wait_for_init);
+  provider_->Initialize(&client);
 
   InitializeDevice(nullptr);
 
diff --git a/device/vr/public/cpp/vr_device_provider.cc b/device/vr/public/cpp/vr_device_provider.cc
index 9919bad05604e2..d938f9ab71657e 100644
--- a/device/vr/public/cpp/vr_device_provider.cc
+++ b/device/vr/public/cpp/vr_device_provider.cc
@@ -8,4 +8,7 @@ namespace device {
 
 VRDeviceProvider::VRDeviceProvider() = default;
 VRDeviceProvider::~VRDeviceProvider() = default;
+
+VRDeviceProviderClient::VRDeviceProviderClient() = default;
+VRDeviceProviderClient::~VRDeviceProviderClient() = default;
 }  // namespace device
diff --git a/device/vr/public/cpp/vr_device_provider.h b/device/vr/public/cpp/vr_device_provider.h
index 0725439e37dd17..1b7a0ab7e58adb 100644
--- a/device/vr/public/cpp/vr_device_provider.h
+++ b/device/vr/public/cpp/vr_device_provider.h
@@ -13,22 +13,30 @@
 
 namespace device {
 
+class COMPONENT_EXPORT(VR_PUBLIC_CPP) VRDeviceProviderClient {
+ public:
+  VRDeviceProviderClient();
+  virtual ~VRDeviceProviderClient();
+
+  // TODO(crbug.com/1090029): Wrap XRDeviceId + VRDisplayInfo into XRDeviceData
+  virtual void AddRuntime(
+      device::mojom::XRDeviceId id,
+      device::mojom::VRDisplayInfoPtr info,
+      device::mojom::XRDeviceDataPtr device_data,
+      mojo::PendingRemote<device::mojom::XRRuntime> runtime) = 0;
+  virtual void RemoveRuntime(device::mojom::XRDeviceId id) = 0;
+  virtual void OnProviderInitialized() = 0;
+  virtual XrFrameSinkClientFactory GetXrFrameSinkClientFactory() = 0;
+};
+
 class COMPONENT_EXPORT(VR_PUBLIC_CPP) VRDeviceProvider {
  public:
   VRDeviceProvider();
   virtual ~VRDeviceProvider();
 
   // If the VR API requires initialization that should happen here.
-  virtual void Initialize(
-      base::RepeatingCallback<void(mojom::XRDeviceId id,
-                                   mojom::VRDisplayInfoPtr,
-                                   mojom::XRDeviceDataPtr,
-                                   mojo::PendingRemote<mojom::XRRuntime>)>
-          add_device_callback,
-      base::RepeatingCallback<void(mojom::XRDeviceId id)>
-          remove_device_callback,
-      base::OnceClosure initialization_complete,
-      XrFrameSinkClientFactory xr_frame_sink_client_factory) = 0;
+  // Note that the client must be guaranteed to outlive the device provider.
+  virtual void Initialize(VRDeviceProviderClient* client) = 0;
 
   // Returns true if initialization is complete.
   virtual bool Initialized() = 0;
diff --git a/device/vr/test/fake_vr_device_provider.cc b/device/vr/test/fake_vr_device_provider.cc
index 1888b72430c0b6..c4a7f657ba3518 100644
--- a/device/vr/test/fake_vr_device_provider.cc
+++ b/device/vr/test/fake_vr_device_provider.cc
@@ -17,9 +17,9 @@ void FakeVRDeviceProvider::AddDevice(std::unique_ptr<VRDeviceBase> device) {
   VRDeviceBase* device_base = static_cast<VRDeviceBase*>(device.get());
   devices_.push_back(std::move(device));
   if (initialized_)
-    add_device_callback_.Run(
-        device_base->GetId(), device_base->GetVRDisplayInfo(),
-        device_base->GetDeviceData(), device_base->BindXRRuntime());
+    client_->AddRuntime(device_base->GetId(), device_base->GetVRDisplayInfo(),
+                        device_base->GetDeviceData(),
+                        device_base->BindXRRuntime());
 }
 
 void FakeVRDeviceProvider::RemoveDevice(mojom::XRDeviceId device_id) {
@@ -29,30 +29,21 @@ void FakeVRDeviceProvider::RemoveDevice(mojom::XRDeviceId device_id) {
         return static_cast<VRDeviceBase*>(device.get())->GetId() == device_id;
       });
   if (initialized_)
-    remove_device_callback_.Run(device_id);
+    client_->RemoveRuntime(device_id);
   devices_.erase(it);
 }
 
-void FakeVRDeviceProvider::Initialize(
-    base::RepeatingCallback<void(mojom::XRDeviceId,
-                                 mojom::VRDisplayInfoPtr,
-                                 mojom::XRDeviceDataPtr,
-                                 mojo::PendingRemote<mojom::XRRuntime>)>
-        add_device_callback,
-    base::RepeatingCallback<void(mojom::XRDeviceId)> remove_device_callback,
-    base::OnceClosure initialization_complete,
-    XrFrameSinkClientFactory xr_frame_sink_client_factory) {
-  add_device_callback_ = std::move(add_device_callback);
-  remove_device_callback_ = std::move(remove_device_callback);
+void FakeVRDeviceProvider::Initialize(VRDeviceProviderClient* client) {
+  client_ = client;
 
   for (std::unique_ptr<VRDeviceBase>& device : devices_) {
     auto* device_base = static_cast<VRDeviceBase*>(device.get());
-    add_device_callback_.Run(
-        device_base->GetId(), device_base->GetVRDisplayInfo(),
-        device_base->GetDeviceData(), device_base->BindXRRuntime());
+    client_->AddRuntime(device_base->GetId(), device_base->GetVRDisplayInfo(),
+                        device_base->GetDeviceData(),
+                        device_base->BindXRRuntime());
   }
   initialized_ = true;
-  std::move(initialization_complete).Run();
+  client_->OnProviderInitialized();
 }
 
 bool FakeVRDeviceProvider::Initialized() {
diff --git a/device/vr/test/fake_vr_device_provider.h b/device/vr/test/fake_vr_device_provider.h
index 8eed663b2ee295..e456a282ac2c54 100644
--- a/device/vr/test/fake_vr_device_provider.h
+++ b/device/vr/test/fake_vr_device_provider.h
@@ -29,26 +29,13 @@ class DEVICE_VR_EXPORT FakeVRDeviceProvider : public VRDeviceProvider {
   void AddDevice(std::unique_ptr<VRDeviceBase> device);
   void RemoveDevice(mojom::XRDeviceId device_id);
 
-  void Initialize(
-      base::RepeatingCallback<void(mojom::XRDeviceId,
-                                   mojom::VRDisplayInfoPtr,
-                                   mojom::XRDeviceDataPtr,
-                                   mojo::PendingRemote<mojom::XRRuntime>)>
-          add_device_callback,
-      base::RepeatingCallback<void(mojom::XRDeviceId)> remove_device_callback,
-      base::OnceClosure initialization_complete,
-      XrFrameSinkClientFactory xr_frame_sink_client_factory) override;
+  void Initialize(VRDeviceProviderClient* client) override;
   bool Initialized() override;
 
  private:
   std::vector<std::unique_ptr<VRDeviceBase>> devices_;
   bool initialized_;
-  base::RepeatingCallback<void(mojom::XRDeviceId,
-                               mojom::VRDisplayInfoPtr,
-                               mojom::XRDeviceDataPtr,
-                               mojo::PendingRemote<mojom::XRRuntime>)>
-      add_device_callback_;
-  base::RepeatingCallback<void(mojom::XRDeviceId)> remove_device_callback_;
+  VRDeviceProviderClient* client_ = nullptr;
 };
 
 }  // namespace device