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: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Reviewed-by: Alexander Cooper <alcooper@chromium.org>
Cr-Commit-Position: refs/heads/master@{#837927}

content/browser/xr/service/isolated_device_provider.cc

@@ -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)));
 

content/browser/xr/service/xr_device_service.cc

@@ -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);

content/browser/xr/service/xr_device_service.h

@@ -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

content/services/isolated_xr_device/BUILD.gn

@@ -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",
   ]
 }

content/services/isolated_xr_device/DEPS

 include_rules = [
+  "+components/viz/common/gpu/context_provider.h",
   "+device/base",
   "+device/vr",
   "+mojo/public",
+  "+services/viz/public/cpp/gpu"
 ]

content/services/isolated_xr_device/xr_device_service.cc

@@ -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));
 }
 

content/services/isolated_xr_device/xr_device_service.h

@@ -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);
 };

content/services/isolated_xr_device/xr_runtime_provider.cc

@@ -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;

content/services/isolated_xr_device/xr_runtime_provider.h

@@ -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};
 };

content/utility/services.cc

@@ -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
 

device/vr/BUILD.gn

@@ -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",

device/vr/openxr/DEPS

 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",
 ]

device/vr/openxr/context_provider_callbacks.h

+// 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_

device/vr/openxr/openxr_device.cc

@@ -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_);
   }
 }
 

device/vr/openxr/openxr_device.h

@@ -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);

device/vr/openxr/openxr_render_loop.cc

@@ -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

device/vr/openxr/openxr_render_loop.h

@@ -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};
 

device/vr/public/mojom/BUILD.gn

@@ -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") {

device/vr/public/mojom/isolated_xr_service.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