Commit 795af3c8 authored by Rafael Cintron's avatar Rafael Cintron Committed by Chromium LUCI CQ

Establish Connection Between XR and GPU Process

This CL establishes a connection between the XR and GPU processes
when the XR process gets created for the OpenXR runtime. Context lost
callbacks from viz::ContextProvider are handled by recreating the GPU
process connection.

A future change will use the connection to open a shared image for
the WebXR backbuffer. The shared image will allow the GPU process to
render directly into the XR backbuffer and avoid the copy + flip
operation we perform today.

Bug: 1131616
Change-Id: I46262927ce116f043c04828bed0299537f250e53
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2567411
Commit-Queue: Rafael Cintron <rafael.cintron@microsoft.com>
Reviewed-by: default avatarDaniel Cheng <dcheng@chromium.org>
Reviewed-by: default avatarKhushal <khushalsagar@chromium.org>
Reviewed-by: default avatarAlexander Cooper <alcooper@chromium.org>
Cr-Commit-Position: refs/heads/master@{#837927}
parent 12321f84
......@@ -99,7 +99,8 @@ void IsolatedVRDeviceProvider::OnDevicesEnumerated() {
void IsolatedVRDeviceProvider::SetupDeviceProvider() {
GetXRDeviceService()->BindRuntimeProvider(
device_provider_.BindNewPipeAndPassReceiver());
device_provider_.BindNewPipeAndPassReceiver(),
CreateXRDeviceServiceHost());
device_provider_.set_disconnect_handler(base::BindOnce(
&IsolatedVRDeviceProvider::OnServerError, base::Unretained(this)));
......
......@@ -7,7 +7,10 @@
#include "base/no_destructor.h"
#include "build/build_config.h"
#include "content/browser/service_sandbox_type.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/gpu_client.h"
#include "content/public/browser/service_process_host.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
namespace content {
......@@ -18,6 +21,33 @@ base::RepeatingClosure& GetStartupCallback() {
return *callback;
}
// XRDeviceServiceHostImpl is the browser process implementation of
// XRDeviceServiceHost
class XRDeviceServiceHostImpl : public device::mojom::XRDeviceServiceHost {
public:
XRDeviceServiceHostImpl()
: gpu_client_(nullptr, base::OnTaskRunnerDeleter(nullptr)) {}
// BindGpu is called from the XR process to establish a connection to the GPU
// process.
void BindGpu(::mojo::PendingReceiver<::viz::mojom::Gpu> receiver) override {
gpu_client_ =
content::CreateGpuClient(std::move(receiver), base::DoNothing(),
content::GetIOThreadTaskRunner({}));
}
private:
// The GpuClient associated with the XRDeviceService's GPU connection, if
// any.
std::unique_ptr<viz::GpuClient, base::OnTaskRunnerDeleter> gpu_client_;
};
void BindHost(
mojo::PendingReceiver<device::mojom::XRDeviceServiceHost> receiver) {
mojo::MakeSelfOwnedReceiver(std::make_unique<XRDeviceServiceHostImpl>(),
std::move(receiver));
}
} // namespace
const mojo::Remote<device::mojom::XRDeviceService>& GetXRDeviceService() {
......@@ -46,6 +76,20 @@ const mojo::Remote<device::mojom::XRDeviceService>& GetXRDeviceService() {
return *remote;
}
mojo::PendingRemote<device::mojom::XRDeviceServiceHost>
CreateXRDeviceServiceHost() {
// XRDeviceServiceHostImpl doesn't need to live on the IO thread but GpuClient
// does and it will own GpuClient. Might as well have them both live on the IO
// thread.
mojo::PendingRemote<device::mojom::XRDeviceServiceHost> device_service_host;
content::GetIOThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&BindHost,
device_service_host.InitWithNewPipeAndPassReceiver()));
return device_service_host;
}
void SetXRDeviceServiceStartupCallbackForTestingInternal(
base::RepeatingClosure callback) {
GetStartupCallback() = std::move(callback);
......
......@@ -17,6 +17,11 @@ namespace content {
const CONTENT_EXPORT mojo::Remote<device::mojom::XRDeviceService>&
GetXRDeviceService();
// Acquires a pending remote handle to the device service host and posts
// a message to the io thread task runner to bind the host.
CONTENT_EXPORT mojo::PendingRemote<device::mojom::XRDeviceServiceHost>
CreateXRDeviceServiceHost();
void CONTENT_EXPORT SetXRDeviceServiceStartupCallbackForTestingInternal(
base::RepeatingClosure callback);
} // namespace content
......
......@@ -30,5 +30,6 @@ source_set("lib") {
"//device/vr:vr_base",
"//device/vr/public/mojom:isolated_xr_service",
"//device/vr/public/mojom:test_mojom",
"//services/viz/public/cpp/gpu",
]
}
include_rules = [
"+components/viz/common/gpu/context_provider.h",
"+device/base",
"+device/vr",
"+mojo/public",
"+services/viz/public/cpp/gpu"
]
......@@ -16,8 +16,10 @@
namespace device {
XrDeviceService::XrDeviceService(
mojo::PendingReceiver<mojom::XRDeviceService> receiver)
: receiver_(this, std::move(receiver)) {
mojo::PendingReceiver<device::mojom::XRDeviceService> receiver,
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
: receiver_(this, std::move(receiver)),
io_task_runner_(std::move(io_task_runner)) {
#if defined(OS_WIN)
base::win::ComInitCheckHook::DisableCOMChecksForProcess();
#endif // defined(OS_WIN)
......@@ -26,8 +28,12 @@ XrDeviceService::XrDeviceService(
XrDeviceService::~XrDeviceService() = default;
void XrDeviceService::BindRuntimeProvider(
mojo::PendingReceiver<mojom::IsolatedXRRuntimeProvider> receiver) {
mojo::MakeSelfOwnedReceiver(std::make_unique<IsolatedXRRuntimeProvider>(),
mojo::PendingReceiver<mojom::IsolatedXRRuntimeProvider> receiver,
mojo::PendingRemote<mojom::XRDeviceServiceHost> device_service_host) {
mojo::MakeSelfOwnedReceiver(std::make_unique<IsolatedXRRuntimeProvider>(
mojo::Remote<mojom::XRDeviceServiceHost>(
std::move(device_service_host)),
io_task_runner_),
std::move(receiver));
}
......
......@@ -9,24 +9,28 @@
#include "device/vr/public/mojom/isolated_xr_service.mojom.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
namespace device {
class XrDeviceService : public mojom::XRDeviceService {
public:
explicit XrDeviceService(
mojo::PendingReceiver<mojom::XRDeviceService> receiver);
mojo::PendingReceiver<mojom::XRDeviceService> receiver,
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
~XrDeviceService() override;
private:
// mojom::XRDeviceService implementation:
void BindRuntimeProvider(
mojo::PendingReceiver<mojom::IsolatedXRRuntimeProvider> receiver)
mojo::PendingReceiver<mojom::IsolatedXRRuntimeProvider> receiver,
mojo::PendingRemote<mojom::XRDeviceServiceHost> device_service_host)
override;
void BindTestHook(mojo::PendingReceiver<device_test::mojom::XRServiceTestHook>
receiver) override;
mojo::Receiver<mojom::XRDeviceService> receiver_;
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
DISALLOW_COPY_AND_ASSIGN(XrDeviceService);
};
......
......@@ -13,8 +13,10 @@
#include "device/vr/buildflags/buildflags.h"
#if BUILDFLAG(ENABLE_OPENXR)
#include "content/public/common/gpu_stream_constants.h"
#include "device/vr/openxr/openxr_device.h"
#include "device/vr/openxr/openxr_statics.h"
#include "services/viz/public/cpp/gpu/context_provider_command_buffer.h"
#endif
enum class IsolatedXRRuntimeProvider::RuntimeStatus {
......@@ -152,20 +154,62 @@ bool IsolatedXRRuntimeProvider::IsOpenXrHardwareAvailable() {
}
void IsolatedXRRuntimeProvider::SetOpenXrRuntimeStatus(RuntimeStatus status) {
SetRuntimeStatus(
client_.get(), status,
base::BindOnce(
[](device::OpenXrStatics* openxr_statics) {
// This does not give any ownership of the OpenXrStatics object to
// OpenXrDevice. The OpenXrStatics is only used in the constructor
// and a reference is not kept.
return std::make_unique<device::OpenXrDevice>(openxr_statics);
},
openxr_statics_.get()),
&openxr_device_);
auto factory_async = base::BindRepeating(
&IsolatedXRRuntimeProvider::CreateContextProviderAsync,
weak_ptr_factory_.GetWeakPtr());
SetRuntimeStatus(client_.get(), status,
base::BindOnce(
[](device::OpenXrStatics* openxr_statics,
VizContextProviderFactoryAsync factory_async) {
// This does not give any ownership of the
// OpenXrStatics object to OpenXrDevice. OpenXrStatics
// is only used in the constructor and a reference is
// not kept.
return std::make_unique<device::OpenXrDevice>(
openxr_statics, std::move(factory_async));
},
openxr_statics_.get(), std::move(factory_async)),
&openxr_device_);
}
void IsolatedXRRuntimeProvider::CreateContextProviderAsync(
VizContextProviderCallback viz_context_provider_callback,
scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
// viz_gpu_ must be kept alive so long as there are outstanding context
// providers attached to it, otherwise the GPU process channel gets closed out
// from under it.
if (!viz_gpu_ || !viz_gpu_->GetGpuChannel() ||
viz_gpu_->GetGpuChannel()->IsLost()) {
mojo::PendingRemote<viz::mojom::Gpu> remote_gpu;
device_service_host_->BindGpu(remote_gpu.InitWithNewPipeAndPassReceiver());
viz_gpu_ = viz::Gpu::Create(std::move(remote_gpu), io_task_runner_);
scoped_refptr<gpu::GpuChannelHost> gpu_channel_host =
viz_gpu_->EstablishGpuChannelSync();
}
scoped_refptr<viz::ContextProvider> context_provider =
base::MakeRefCounted<viz::ContextProviderCommandBuffer>(
viz_gpu_->GetGpuChannel(), nullptr /* gpu_memory_buffer_manager */,
content::kGpuStreamIdDefault, content::kGpuStreamPriorityUI,
gpu::kNullSurfaceHandle, GURL(std::string("chrome://gpu/XrRuntime")),
false /* automatic flushes */, false /* support locking */,
false /* support grcontext */,
gpu::SharedMemoryLimits::ForMailboxContext(),
gpu::ContextCreationAttribs(),
viz::command_buffer_metrics::ContextType::XR_COMPOSITING);
task_runner->PostTask(FROM_HERE,
base::BindOnce(std::move(viz_context_provider_callback),
std::move(context_provider)));
}
#endif // BUILDFLAG(ENABLE_OPENXR)
IsolatedXRRuntimeProvider::IsolatedXRRuntimeProvider() = default;
IsolatedXRRuntimeProvider::IsolatedXRRuntimeProvider(
mojo::Remote<device::mojom::XRDeviceServiceHost> device_service_host,
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
: device_service_host_(std::move(device_service_host)),
io_task_runner_(std::move(io_task_runner)) {}
IsolatedXRRuntimeProvider::~IsolatedXRRuntimeProvider() = default;
......@@ -12,15 +12,27 @@
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#if BUILDFLAG(ENABLE_OPENXR)
#include "components/viz/common/gpu/context_provider.h"
#include "device/vr/openxr/context_provider_callbacks.h"
#include "services/viz/public/cpp/gpu/gpu.h"
#endif
namespace device {
class OpenXrDevice;
class OpenXrStatics;
} // namespace device
namespace viz {
class Gpu;
} // namespace viz
class IsolatedXRRuntimeProvider
: public device::mojom::IsolatedXRRuntimeProvider {
public:
IsolatedXRRuntimeProvider();
explicit IsolatedXRRuntimeProvider(
mojo::Remote<device::mojom::XRDeviceServiceHost> device_service_host,
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner);
~IsolatedXRRuntimeProvider() final;
void RequestDevices(
......@@ -36,11 +48,19 @@ class IsolatedXRRuntimeProvider
#if BUILDFLAG(ENABLE_OPENXR)
bool IsOpenXrHardwareAvailable();
void SetOpenXrRuntimeStatus(RuntimeStatus status);
void CreateContextProviderAsync(
VizContextProviderCallback viz_context_provider_callback,
scoped_refptr<base::SingleThreadTaskRunner> task_runner);
bool should_check_openxr_ = false;
std::unique_ptr<device::OpenXrDevice> openxr_device_;
std::unique_ptr<device::OpenXrStatics> openxr_statics_;
std::unique_ptr<viz::Gpu> viz_gpu_;
#endif
mojo::Remote<device::mojom::XRDeviceServiceHost> device_service_host_;
scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
mojo::Remote<device::mojom::IsolatedXRRuntimeProviderClient> client_;
base::WeakPtrFactory<IsolatedXRRuntimeProvider> weak_ptr_factory_{this};
};
......
......@@ -218,7 +218,8 @@ auto RunVideoCapture(
#if BUILDFLAG(ENABLE_VR) && !defined(OS_ANDROID)
auto RunXrDeviceService(
mojo::PendingReceiver<device::mojom::XRDeviceService> receiver) {
return std::make_unique<device::XrDeviceService>(std::move(receiver));
return std::make_unique<device::XrDeviceService>(
std::move(receiver), content::ChildProcess::current()->io_task_runner());
}
#endif
......
......@@ -144,6 +144,7 @@ if (enable_vr) {
}
sources += [
"openxr/context_provider_callbacks.h",
"openxr/openxr_api_wrapper.cc",
"openxr/openxr_api_wrapper.h",
"openxr/openxr_controller.cc",
......
include_rules = [
"+components/viz/common/gpu/context_lost_observer.h",
"+components/viz/common/gpu/context_provider.h",
"+third_party/openxr/src/include/openxr",
"+components/version_info",
]
// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef DEVICE_VR_OPENXR_CONTEXT_PROVIDER_CALLBACKS_H_
#define DEVICE_VR_OPENXR_CONTEXT_PROVIDER_CALLBACKS_H_
namespace viz {
class ContextProvider;
}
namespace base {
class SingleThreadTaskRunner;
}
// VizContextProviderCallback is implemented by OpenXrRenderLoop and is called
// by the IsolatedXRRuntimeProvider when a new viz::ContextProvider is ready for
// the render loop thread to consume.
using VizContextProviderCallback =
base::OnceCallback<void(scoped_refptr<viz::ContextProvider>)>;
// VizContextProviderFactoryAsync is implemented by IsolatedXRRuntimeProvider
// and is called when the OpenXrRenderLoop needs a new viz::ContextProvider to
// be created. The base::SingleThreadTaskRunner parameter is the destination
// task runner for the context provider, the render loop thread.
using VizContextProviderFactoryAsync =
base::RepeatingCallback<void(VizContextProviderCallback,
scoped_refptr<base::SingleThreadTaskRunner>)>;
#endif // DEVICE_VR_OPENXR_CONTEXT_PROVIDER_CALLBACKS_H_
......@@ -55,10 +55,14 @@ mojom::VRDisplayInfoPtr CreateFakeVRDisplayInfo() {
// OpenXrDevice must not take ownership of the OpenXrStatics passed in.
// The OpenXrStatics object is owned by IsolatedXRRuntimeProvider.
OpenXrDevice::OpenXrDevice(OpenXrStatics* openxr_statics)
OpenXrDevice::OpenXrDevice(
OpenXrStatics* openxr_statics,
VizContextProviderFactoryAsync context_provider_factory_async)
: VRDeviceBase(device::mojom::XRDeviceId::OPENXR_DEVICE_ID),
instance_(openxr_statics->GetXrInstance()),
extension_helper_(instance_, openxr_statics->GetExtensionEnumeration()),
context_provider_factory_async_(
std::move(context_provider_factory_async)),
weak_ptr_factory_(this) {
mojom::VRDisplayInfoPtr display_info = CreateFakeVRDisplayInfo();
SetVRDisplayInfo(std::move(display_info));
......@@ -87,7 +91,8 @@ void OpenXrDevice::EnsureRenderLoop() {
auto on_info_changed = base::BindRepeating(&OpenXrDevice::SetVRDisplayInfo,
weak_ptr_factory_.GetWeakPtr());
render_loop_ = std::make_unique<OpenXrRenderLoop>(
std::move(on_info_changed), instance_, extension_helper_);
std::move(on_info_changed), context_provider_factory_async_, instance_,
extension_helper_);
}
}
......
......@@ -8,6 +8,8 @@
#include <memory>
#include "base/macros.h"
#include "components/viz/common/gpu/context_provider.h"
#include "device/vr/openxr/context_provider_callbacks.h"
#include "device/vr/openxr/openxr_util.h"
#include "device/vr/public/mojom/vr_service.mojom.h"
#include "device/vr/vr_device_base.h"
......@@ -27,7 +29,8 @@ class DEVICE_VR_EXPORT OpenXrDevice
public mojom::XRSessionController,
public mojom::XRCompositorHost {
public:
OpenXrDevice(OpenXrStatics* openxr_statics);
OpenXrDevice(OpenXrStatics* openxr_statics,
VizContextProviderFactoryAsync context_provider_factory_async);
~OpenXrDevice() override;
// VRDeviceBase
......@@ -63,6 +66,8 @@ class DEVICE_VR_EXPORT OpenXrDevice
mojo::Receiver<mojom::XRCompositorHost> compositor_host_receiver_{this};
mojo::PendingReceiver<mojom::ImmersiveOverlay> overlay_receiver_;
VizContextProviderFactoryAsync context_provider_factory_async_;
base::WeakPtrFactory<OpenXrDevice> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(OpenXrDevice);
......
......@@ -4,6 +4,7 @@
#include "device/vr/openxr/openxr_render_loop.h"
#include "components/viz/common/gpu/context_provider.h"
#include "device/vr/openxr/openxr_api_wrapper.h"
#include "device/vr/openxr/openxr_input_helper.h"
#include "device/vr/util/stage_utils.h"
......@@ -17,12 +18,15 @@ namespace device {
OpenXrRenderLoop::OpenXrRenderLoop(
base::RepeatingCallback<void(mojom::VRDisplayInfoPtr)>
on_display_info_changed,
VizContextProviderFactoryAsync context_provider_factory_async,
XrInstance instance,
const OpenXrExtensionHelper& extension_helper)
: XRCompositorCommon(),
instance_(instance),
extension_helper_(extension_helper),
on_display_info_changed_(std::move(on_display_info_changed)) {
on_display_info_changed_(std::move(on_display_info_changed)),
context_provider_factory_async_(
std::move(context_provider_factory_async)) {
DCHECK(instance_ != XR_NULL_HANDLE);
}
......@@ -116,6 +120,11 @@ bool OpenXrRenderLoop::StartRuntime() {
&OpenXrRenderLoop::ExitPresent, weak_ptr_factory_.GetWeakPtr()));
InitializeDisplayInfo();
// TODO(https://crbug.com/1131616): In a subsequent change, refactor
// StartContextProviderIfNeeded such that we do not start the session until
// the context provider has been created.
StartContextProviderIfNeeded();
return true;
}
......@@ -269,4 +278,72 @@ void OpenXrRenderLoop::UpdateStageParameters() {
}
}
void OpenXrRenderLoop::StartContextProviderIfNeeded() {
DCHECK(task_runner()->BelongsToCurrentThread());
// We could arrive here in scenarios where we've shutdown the render loop.
// In that case, there is no need to start the context provider.
if (!context_provider_ && !HasSessionEnded()) {
main_thread_task_runner_->PostTask(
FROM_HERE,
base::BindOnce(
context_provider_factory_async_,
base::BindOnce(&OpenXrRenderLoop::OnContextProviderCreated,
weak_ptr_factory_.GetWeakPtr()),
task_runner()));
}
}
// viz::ContextLostObserver Implementation.
// Called on the render loop thread.
void OpenXrRenderLoop::OnContextLost() {
DCHECK(task_runner()->BelongsToCurrentThread());
DCHECK_NE(context_provider_, nullptr);
// Avoid OnContextLost getting called multiple times by removing
// the observer right away.
context_provider_->RemoveObserver(this);
// Destroying the context provider in the OpenXrRenderLoop::OnContextLost
// callback leads to UAF deep inside the GpuChannel callback code. To avoid
// UAF, post a task to ourselves which does the real context lost work. Pass
// the context_provider_ as a parameters to the callback to avoid the invalid
// one getting used on the context thread.
task_runner()->PostTask(
FROM_HERE, base::BindOnce(&OpenXrRenderLoop::OnContextLostCallback,
weak_ptr_factory_.GetWeakPtr(),
std::move(context_provider_)));
}
// Called on the render loop thread as a continuation of OnContextLost
void OpenXrRenderLoop::OnContextLostCallback(
scoped_refptr<viz::ContextProvider> context_provider) {
DCHECK(task_runner()->BelongsToCurrentThread());
DCHECK_EQ(context_provider_, nullptr);
// context_provider is required to be released on the context thread it was
// bound to.
context_provider.reset();
StartContextProviderIfNeeded();
}
// Called on the render loop thread by IsolatedXRRuntimeProvider when it has
// finished creating the context provider.
void OpenXrRenderLoop::OnContextProviderCreated(
scoped_refptr<viz::ContextProvider> context_provider) {
DCHECK(task_runner()->BelongsToCurrentThread());
DCHECK_EQ(context_provider_, nullptr);
const gpu::ContextResult context_result =
context_provider->BindToCurrentThread();
if (context_result != gpu::ContextResult::kSuccess) {
// TODO(https://crbug.com/1131616): Handle this by creating the context
// provider again.
return;
}
context_provider->AddObserver(this);
context_provider_ = std::move(context_provider);
}
} // namespace device
......@@ -10,6 +10,8 @@
#include "base/callback.h"
#include "base/macros.h"
#include "components/viz/common/gpu/context_lost_observer.h"
#include "device/vr/openxr/context_provider_callbacks.h"
#include "device/vr/openxr/openxr_util.h"
#include "device/vr/windows/compositor_base.h"
#include "third_party/openxr/src/include/openxr/openxr.h"
......@@ -21,12 +23,15 @@ namespace device {
class OpenXrApiWrapper;
class OpenXRInputHelper;
class OpenXrRenderLoop : public XRCompositorCommon {
class OpenXrRenderLoop : public XRCompositorCommon,
public viz::ContextLostObserver {
public:
OpenXrRenderLoop(base::RepeatingCallback<void(mojom::VRDisplayInfoPtr)>
on_display_info_changed,
XrInstance instance,
const OpenXrExtensionHelper& extension_helper_);
OpenXrRenderLoop(
base::RepeatingCallback<void(mojom::VRDisplayInfoPtr)>
on_display_info_changed,
VizContextProviderFactoryAsync context_provider_factory_async,
XrInstance instance,
const OpenXrExtensionHelper& extension_helper_);
~OpenXrRenderLoop() override;
private:
......@@ -47,6 +52,9 @@ class OpenXrRenderLoop : public XRCompositorCommon {
device::mojom::XRSessionMode session_mode) override;
bool CanEnableAntiAliasing() const override;
// viz::ContextLostObserver Implementation
void OnContextLost() override;
void InitializeDisplayInfo();
bool UpdateEyeParameters();
bool UpdateEye(const XrView& view_head,
......@@ -54,6 +62,12 @@ class OpenXrRenderLoop : public XRCompositorCommon {
mojom::VREyeParametersPtr* eye) const;
void UpdateStageParameters();
void StartContextProviderIfNeeded();
void OnContextProviderCreated(
scoped_refptr<viz::ContextProvider> context_provider);
void OnContextLostCallback(
scoped_refptr<viz::ContextProvider> context_provider);
// Owned by OpenXrStatics
XrInstance instance_;
const OpenXrExtensionHelper& extension_helper_;
......@@ -65,6 +79,9 @@ class OpenXrRenderLoop : public XRCompositorCommon {
on_display_info_changed_;
mojom::VRDisplayInfoPtr current_display_info_;
scoped_refptr<viz::ContextProvider> context_provider_;
VizContextProviderFactoryAsync context_provider_factory_async_;
// This must be the last member
base::WeakPtrFactory<OpenXrRenderLoop> weak_ptr_factory_{this};
......
......@@ -69,6 +69,8 @@ mojom_component("isolated_xr_service") {
"//skia/public/mojom",
"//ui/gfx/geometry/mojom",
]
deps = [ "//services/viz/public/mojom" ]
}
mojom_component("test_mojom") {
......
......@@ -9,6 +9,7 @@ import "device/vr/public/mojom/vr_service.mojom";
[EnableIf=is_win]
import "gpu/ipc/common/luid.mojom";
import "mojo/public/mojom/base/time.mojom";
import "services/viz/public/mojom/gpu.mojom";
import "ui/gfx/geometry/mojom/geometry.mojom";
// The XRSessionController lives in the xr runtime service, and corresponds to
......@@ -171,12 +172,23 @@ interface IsolatedXRRuntimeProvider {
RequestDevices(pending_remote<IsolatedXRRuntimeProviderClient> client);
};
// The main interface for the XR Device Service.
// The main interface for the XR Device Service. Called from the browser
// process.
interface XRDeviceService {
// Binds a IsolatedXRRuntimeProvider pipe in the service.
BindRuntimeProvider(pending_receiver<IsolatedXRRuntimeProvider> receiver);
// Binds a IsolatedXRRuntimeProvider pipe in the service and passes along
// the device service host.
BindRuntimeProvider(pending_receiver<IsolatedXRRuntimeProvider> receiver,
pending_remote<XRDeviceServiceHost> host);
// Binds the main testing interface pipe in the service. Only used by
// browser tests.
BindTestHook(pending_receiver<device_test.mojom.XRServiceTestHook> receiver);
};
// XRDeviceServiceHost is implemented in the browser process and called from
// the XR process.
interface XRDeviceServiceHost {
// BindGpu is implemented in the browser process and allows the XR process to
// establish a connection to the GPU process.
BindGpu(pending_receiver<viz.mojom.Gpu> receiver);
};
\ No newline at end of file
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment