WebXR: use XRSessionDeviceConfig to simplify APIs

Passing device-specific options was getting messy in xr_system/
xr_session. Use a containing structure to simplify this, and to avoid
merge conflicts as in https://crrev.com/c/2438207 going forward.

Bug: 1135789
Change-Id: Ie26affa410a1fad8a8ff9cd6686de452d2393ee8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2440222Reviewed-by: Brandon Jones <bajones@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Klaus Weidner <klausw@chromium.org>
Cr-Commit-Position: refs/heads/master@{#816230}

chrome/browser/android/vr/gvr_scheduler_delegate.cc

@@ -211,15 +211,19 @@ void GvrSchedulerDelegate::ConnectPresentingService(
   session->data_provider = frame_data_receiver_.BindNewPipeAndPassRemote();
   session->submit_frame_sink = std::move(submit_frame_sink);
   session->display_info = std::move(display_info);
-  session->supports_viewport_scaling = true;
+
+  session->device_config = device::mojom::XRSessionDeviceConfig::New();
+  auto* config = session->device_config.get();
+
+  config->supports_viewport_scaling = true;
 
   // This scalar will be applied in the renderer to the recommended render
   // target sizes. For WebVR it will always be applied, for WebXR it can be
   // overridden.
   if (base::AndroidHardwareBufferCompat::IsSupportAvailable()) {
-    session->default_framebuffer_scale = kRecommendedResolutionScale;
+    config->default_framebuffer_scale = kRecommendedResolutionScale;
   } else {
-    session->default_framebuffer_scale = kNoSharedBufferResolutionScale;
+    config->default_framebuffer_scale = kNoSharedBufferResolutionScale;
   }
 
   if (CanSendWebXrVSync())

device/vr/android/arcore/arcore_device.cc

@@ -276,7 +276,11 @@ void ArCoreDevice::OnCreateSessionCallback(
   session->data_provider = std::move(frame_data_provider);
   session->display_info = std::move(display_info);
   session->submit_frame_sink = std::move(presentation_connection);
-  session->supports_viewport_scaling = true;
+
+  session->device_config = device::mojom::XRSessionDeviceConfig::New();
+  auto* config = session->device_config.get();
+
+  config->supports_viewport_scaling = true;
 
   std::move(deferred_callback)
       .Run(std::move(session), std::move(session_controller));

device/vr/orientation/orientation_device.cc

@@ -139,6 +139,7 @@ void VROrientationDevice::RequestSession(
   if (display_info_) {
     session->display_info = display_info_.Clone();
   }
+  session->device_config = device::mojom::XRSessionDeviceConfig::New();
 
   std::move(callback).Run(std::move(session), std::move(controller));
 

device/vr/public/mojom/vr_service.mojom

@@ -102,6 +102,25 @@ struct XRSessionOptions {
   array<XRSessionFeature> optional_features;
 };
 
+// This structure contains a description of the device's active configuration
+// for the session being established.
+struct XRSessionDeviceConfig {
+  // Indicates whether the device backing this session sends input events solely
+  // via eventing (as opposed to polling).
+  bool uses_input_eventing;
+
+  // The default scale that should be applied to the native framebuffer size
+  // unless overridden by the developer.
+  float default_framebuffer_scale = 1.0;
+
+  // Indicates whether the device supports dynamic viewport scaling via
+  // XRView.requestViewportScale which results in UpdateLayerBounds mojo calls.
+  // This is opt-in to avoid problems with devices that assume default bounds,
+  // this would result in broken rendering due to inconsistency between the
+  // drawn and displayed viewports.
+  bool supports_viewport_scaling;
+};
+
 // This structure contains all the mojo interfaces for different kinds of
 // XRSession. The only interface required by all sessions is the
 // XRFrameDataProvider. It must always be present. Other interfaces are set as
@@ -126,20 +145,8 @@ struct XRSession {
   // runtime, and have been consented to by the user.
   array<XRSessionFeature> enabled_features;
 
-  // Indicates whether the device backing this session sends input events solely
-  // via eventing (as opposed to polling).
-  bool uses_input_eventing;
-
-  // The default scale that should be applied to the native framebuffer size
-  // unless overridden by the developer.
-  float default_framebuffer_scale = 1.0;
-
-  // Indicates whether the device supports dynamic viewport scaling via
-  // XRView.requestViewportScale which results in UpdateLayerBounds mojo calls.
-  // This is opt-in to avoid problems with devices that assume default bounds,
-  // this would result in broken rendering due to inconsistency between the
-  // drawn and displayed viewports.
-  bool supports_viewport_scaling;
+  // Description of the device's active configuration.
+  XRSessionDeviceConfig device_config;
 };
 
 // This structure contains the infomation and interfaces needed to create a two

device/vr/windows/compositor_base.cc

@@ -239,7 +239,9 @@ void XRCompositorCommon::RequestSession(
   auto session = device::mojom::XRSession::New();
   session->data_provider = frame_data_receiver_.BindNewPipeAndPassRemote();
   session->submit_frame_sink = std::move(submit_frame_sink);
-  session->uses_input_eventing = UsesInputEventing();
+
+  session->device_config = device::mojom::XRSessionDeviceConfig::New();
+  session->device_config->uses_input_eventing = UsesInputEventing();
 
   main_thread_task_runner_->PostTask(
       FROM_HERE, base::BindOnce(std::move(callback), true, std::move(session)));

third_party/blink/renderer/modules/xr/xr_session.cc

@@ -309,9 +309,7 @@ XRSession::XRSession(
     device::mojom::blink::XRSessionMode mode,
     EnvironmentBlendMode environment_blend_mode,
     InteractionMode interaction_mode,
-    bool uses_input_eventing,
-    float default_framebuffer_scale,
-    bool supports_viewport_scaling,
+    device::mojom::blink::XRSessionDeviceConfigPtr device_config,
     bool sensorless_session,
     XRSessionFeatureSet enabled_features)
     : xr_(xr),
@@ -326,8 +324,8 @@ XRSession::XRSession(
       callback_collection_(
           MakeGarbageCollected<XRFrameRequestCallbackCollection>(
               xr->GetExecutionContext())),
-      uses_input_eventing_(uses_input_eventing),
-      supports_viewport_scaling_(supports_viewport_scaling),
+      uses_input_eventing_(device_config->uses_input_eventing),
+      supports_viewport_scaling_(device_config->supports_viewport_scaling),
       sensorless_session_(sensorless_session) {
   client_receiver_.Bind(
       std::move(client_receiver),
@@ -337,9 +335,9 @@ XRSession::XRSession(
   UpdateVisibilityState();
 
   // Clamp to a reasonable min/max size for the default framebuffer scale.
-  default_framebuffer_scale_ =
-      base::ClampToRange(default_framebuffer_scale, kMinDefaultFramebufferScale,
-                         kMaxDefaultFramebufferScale);
+  default_framebuffer_scale_ = base::ClampToRange(
+      device_config->default_framebuffer_scale, kMinDefaultFramebufferScale,
+      kMaxDefaultFramebufferScale);
 
   world_tracking_state_ = MakeGarbageCollected<XRWorldTrackingState>(
       IsFeatureEnabled(device::mojom::XRSessionFeature::PLANE_DETECTION));

third_party/blink/renderer/modules/xr/xr_session.h

@@ -116,9 +116,7 @@ class XRSession final
             device::mojom::blink::XRSessionMode mode,
             EnvironmentBlendMode environment_blend_mode,
             InteractionMode interaction_mode,
-            bool uses_input_eventing,
-            float default_framebuffer_scale,
-            bool supports_viewport_scaling,
+            device::mojom::blink::XRSessionDeviceConfigPtr device_config,
             bool sensorless_session,
             XRSessionFeatureSet enabled_features);
   ~XRSession() override = default;

third_party/blink/renderer/modules/xr/xr_system.cc

@@ -1423,12 +1423,11 @@ void XRSystem::OnRequestSessionReturned(
     enabled_features.insert(feature);
   }
 
-  XRSession* session = CreateSession(
-      query->mode(), blend_mode, interaction_mode,
-      std::move(session_ptr->client_receiver),
-      std::move(session_ptr->display_info), session_ptr->uses_input_eventing,
-      session_ptr->default_framebuffer_scale,
-      session_ptr->supports_viewport_scaling, enabled_features);
+  XRSession* session =
+      CreateSession(query->mode(), blend_mode, interaction_mode,
+                    std::move(session_ptr->client_receiver),
+                    std::move(session_ptr->display_info),
+                    std::move(session_ptr->device_config), enabled_features);
 
   frameProvider()->OnSessionStarted(session, std::move(session_ptr));
 
@@ -1532,15 +1531,13 @@ XRSession* XRSystem::CreateSession(
     mojo::PendingReceiver<device::mojom::blink::XRSessionClient>
         client_receiver,
     device::mojom::blink::VRDisplayInfoPtr display_info,
-    bool uses_input_eventing,
-    float default_framebuffer_scale,
-    bool supports_viewport_scaling,
+    device::mojom::blink::XRSessionDeviceConfigPtr device_config,
     XRSessionFeatureSet enabled_features,
     bool sensorless_session) {
   XRSession* session = MakeGarbageCollected<XRSession>(
       this, std::move(client_receiver), mode, blend_mode, interaction_mode,
-      uses_input_eventing, default_framebuffer_scale, supports_viewport_scaling,
-      sensorless_session, std::move(enabled_features));
+      std::move(device_config), sensorless_session,
+      std::move(enabled_features));
   if (display_info)
     session->SetXRDisplayInfo(std::move(display_info));
   sessions_.insert(session);
@@ -1552,14 +1549,14 @@ XRSession* XRSystem::CreateSensorlessInlineSession() {
   XRSession::EnvironmentBlendMode blend_mode = XRSession::kBlendModeOpaque;
   XRSession::InteractionMode interaction_mode =
       XRSession::kInteractionModeScreen;
-  return CreateSession(
-      device::mojom::blink::XRSessionMode::kInline, blend_mode,
-      interaction_mode, mojo::NullReceiver() /* client receiver */,
-      nullptr /* display_info */, false /* uses_input_eventing */,
-      1.0 /* default_framebuffer_scale */,
-      false /* supports_viewport_scaling */,
-      {device::mojom::XRSessionFeature::REF_SPACE_VIEWER},
-      true /* sensorless_session */);
+  device::mojom::blink::XRSessionDeviceConfigPtr device_config =
+      device::mojom::blink::XRSessionDeviceConfig::New();
+  return CreateSession(device::mojom::blink::XRSessionMode::kInline, blend_mode,
+                       interaction_mode,
+                       mojo::NullReceiver() /* client receiver */,
+                       nullptr /* display_info */, std::move(device_config),
+                       {device::mojom::XRSessionFeature::REF_SPACE_VIEWER},
+                       true /* sensorless_session */);
 }
 
 void XRSystem::Dispose(DisposeType dispose_type) {

third_party/blink/renderer/modules/xr/xr_system.h

@@ -393,9 +393,7 @@ class XRSystem final : public EventTargetWithInlineData,
       mojo::PendingReceiver<device::mojom::blink::XRSessionClient>
           client_receiver,
       device::mojom::blink::VRDisplayInfoPtr display_info,
-      bool uses_input_eventing,
-      float default_framebuffer_scale,
-      bool supports_viewport_scaling,
+      device::mojom::blink::XRSessionDeviceConfigPtr device_config,
       XRSessionFeatureSet enabled_features,
       bool sensorless_session = false);
 

third_party/blink/web_tests/external/wpt/resources/chromium/webxr-test.js

@@ -1016,8 +1016,10 @@ class MockRuntime {
             clientReceiver: clientReceiver,
             displayInfo: this.displayInfo_,
             enabledFeatures: enabled_features,
-            defaultFramebufferScale: this.defaultFramebufferScale_,
-            supportsViewportScaling: true
+            deviceConfig: {
+              defaultFramebufferScale: this.defaultFramebufferScale_,
+              supportsViewportScaling: true
+            }
           }
         });
       } else {