Remove WebVR support from OpenXr Runtime

WebXr uses a different channel than WebVR to send up gamepad data, as
such, runtime specific support for this WebVr-only channel can now be
removed.

Fixed: 1017854
Change-Id: Ic597ce27c26b8a70258d5991a3f0ff68bd6f86fa
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1880078
Commit-Queue: Alexander Cooper <alcooper@chromium.org>
Reviewed-by: Jacob DeWitt <jacde@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709709}

device/vr/openxr/openxr_controller.cc

@@ -9,7 +9,6 @@
 #include "base/logging.h"
 #include "device/gamepad/public/cpp/gamepads.h"
 #include "device/vr/openxr/openxr_util.h"
-#include "device/vr/public/mojom/vr_service.mojom.h"
 #include "device/vr/util/xr_standard_gamepad_builder.h"
 #include "ui/gfx/geometry/quaternion.h"
 #include "ui/gfx/transform_util.h"
@@ -33,15 +32,6 @@ const char* GetStringFromType(OpenXrHandednessType type) {
   }
 }
 
-mojom::XRGamepadButtonPtr GetXRGamepadButtonPtr(
-    base::Optional<GamepadButton> button) {
-  mojom::XRGamepadButtonPtr ret = mojom::XRGamepadButton::New();
-  ret->pressed = button->pressed;
-  ret->touched = button->touched;
-  ret->value = button->value;
-  return ret;
-}
-
 }  // namespace
 
 OpenXrController::OpenXrController()
@@ -222,25 +212,6 @@ device::mojom::XRInputSourceDescriptionPtr OpenXrController::GetDescription(
   return description_.Clone();
 }
 
-std::vector<mojom::XRGamepadButtonPtr> OpenXrController::GetWebVrButtons()
-    const {
-  std::vector<mojom::XRGamepadButtonPtr> buttons;
-
-  constexpr uint32_t kNumButtons =
-      static_cast<uint32_t>(OpenXrButtonType::kMaxValue) + 1;
-  for (uint32_t i = 0; i < kNumButtons; i++) {
-    base::Optional<GamepadButton> button =
-        GetButton(static_cast<OpenXrButtonType>(i));
-    if (button) {
-      buttons.push_back(GetXRGamepadButtonPtr(button.value()));
-    } else {
-      return {};
-    }
-  }
-
-  return buttons;
-}
-
 base::Optional<GamepadButton> OpenXrController::GetButton(
     OpenXrButtonType type) const {
   GamepadButton ret;
@@ -278,24 +249,6 @@ base::Optional<GamepadButton> OpenXrController::GetButton(
   return ret;
 }
 
-std::vector<double> OpenXrController::GetWebVrAxes() const {
-  std::vector<double> axes;
-
-  constexpr uint32_t kNumAxes =
-      static_cast<uint32_t>(OpenXrAxisType::kMaxValue) + 1;
-  for (uint32_t i = 0; i < kNumAxes; i++) {
-    std::vector<double> axis = GetAxis(static_cast<OpenXrAxisType>(i));
-    if (axis.empty()) {
-      return {};
-    }
-
-    DCHECK(axis.size() == kAxisDimensions);
-    axes.insert(axes.end(), axis.begin(), axis.end());
-  }
-
-  return axes;
-}
-
 std::vector<double> OpenXrController::GetAxis(OpenXrAxisType type) const {
   XrActionStateVector2f axis_state_v2f = {XR_TYPE_ACTION_STATE_VECTOR2F};
   if (XR_FAILED(QueryState(axis_action_map_.at(type), &axis_state_v2f)) ||
@@ -306,55 +259,6 @@ std::vector<double> OpenXrController::GetAxis(OpenXrAxisType type) const {
   return {axis_state_v2f.currentState.x, axis_state_v2f.currentState.y};
 }
 
-mojom::VRPosePtr OpenXrController::GetPose(XrTime predicted_display_time,
-                                           XrSpace local_space) const {
-  XrActionStatePose grip_state_pose = {XR_TYPE_ACTION_STATE_POSE};
-  if (XR_FAILED(QueryState(grip_pose_action_, &grip_state_pose)) ||
-      !grip_state_pose.isActive) {
-    return nullptr;
-  }
-
-  XrSpaceVelocity local_from_grip_speed = {XR_TYPE_SPACE_VELOCITY};
-  XrSpaceLocation local_from_grip = {XR_TYPE_SPACE_LOCATION};
-  local_from_grip.next = &local_from_grip_speed;
-  if (XR_FAILED(xrLocateSpace(grip_pose_space_, local_space,
-                              predicted_display_time, &local_from_grip))) {
-    return nullptr;
-  }
-
-  mojom::VRPosePtr pose = mojom::VRPose::New();
-
-  if (local_from_grip.locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) {
-    pose->position = gfx::Point3F(local_from_grip.pose.position.x,
-                                  local_from_grip.pose.position.y,
-                                  local_from_grip.pose.position.z);
-  }
-
-  if (local_from_grip.locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT) {
-    pose->orientation = gfx::Quaternion(
-        local_from_grip.pose.orientation.x, local_from_grip.pose.orientation.y,
-        local_from_grip.pose.orientation.z, local_from_grip.pose.orientation.w);
-  }
-
-  if (local_from_grip_speed.velocityFlags &
-      XR_SPACE_VELOCITY_LINEAR_VALID_BIT) {
-    pose->linear_velocity =
-        gfx::Vector3dF(local_from_grip_speed.linearVelocity.x,
-                       local_from_grip_speed.linearVelocity.y,
-                       local_from_grip_speed.linearVelocity.z);
-  }
-
-  if (local_from_grip_speed.velocityFlags &
-      XR_SPACE_VELOCITY_ANGULAR_VALID_BIT) {
-    pose->angular_velocity =
-        gfx::Vector3dF(local_from_grip_speed.angularVelocity.x,
-                       local_from_grip_speed.angularVelocity.y,
-                       local_from_grip_speed.angularVelocity.z);
-  }
-
-  return pose;
-}
-
 base::Optional<gfx::Transform> OpenXrController::GetMojoFromGripTransform(
     XrTime predicted_display_time,
     XrSpace local_space) const {

device/vr/openxr/openxr_controller.h

@@ -6,10 +6,11 @@
 #define DEVICE_VR_OPENXR_OPENXR_CONTROLLER_H_
 
 #include <stdint.h>
+#include <map>
 #include <unordered_map>
 
 #include "base/optional.h"
-#include "device/vr/public/mojom/isolated_xr_service.mojom.h"
+#include "device/vr/public/mojom/vr_service.mojom.h"
 #include "third_party/openxr/src/include/openxr/openxr.h"
 #include "ui/gfx/transform.h"
 
@@ -56,11 +57,7 @@ class OpenXrController {
       XrTime predicted_display_time);
 
   base::Optional<GamepadButton> GetButton(OpenXrButtonType type) const;
-  std::vector<mojom::XRGamepadButtonPtr> GetWebVrButtons() const;
   std::vector<double> GetAxis(OpenXrAxisType type) const;
-  std::vector<double> GetWebVrAxes() const;
-  mojom::VRPosePtr GetPose(XrTime predicted_display_time,
-                           XrSpace local_space) const;
 
   base::Optional<gfx::Transform> GetMojoFromGripTransform(
       XrTime predicted_display_time,

device/vr/openxr/openxr_device.cc

@@ -91,11 +91,6 @@ OpenXrDevice::~OpenXrDevice() {
   }
 }
 
-mojo::PendingRemote<mojom::IsolatedXRGamepadProviderFactory>
-OpenXrDevice::BindGamepadFactory() {
-  return gamepad_provider_factory_receiver_.BindNewPipeAndPassRemote();
-}
-
 mojo::PendingRemote<mojom::XRCompositorHost>
 OpenXrDevice::BindCompositorHost() {
   return compositor_host_receiver_.BindNewPipeAndPassRemote();
@@ -124,13 +119,6 @@ void OpenXrDevice::RequestSession(
       return;
     }
 
-    if (provider_receiver_) {
-      render_loop_->task_runner()->PostTask(
-          FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
-                                    base::Unretained(render_loop_.get()),
-                                    std::move(provider_receiver_)));
-    }
-
     if (overlay_receiver_) {
       render_loop_->task_runner()->PostTask(
           FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestOverlay,
@@ -203,19 +191,6 @@ void OpenXrDevice::SetFrameDataRestricted(bool restricted) {
   NOTREACHED();
 }
 
-void OpenXrDevice::GetIsolatedXRGamepadProvider(
-    mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver) {
-  EnsureRenderLoop();
-  if (render_loop_->IsRunning()) {
-    render_loop_->task_runner()->PostTask(
-        FROM_HERE, base::BindOnce(&XRCompositorCommon::RequestGamepadProvider,
-                                  base::Unretained(render_loop_.get()),
-                                  std::move(provider_receiver)));
-  } else {
-    provider_receiver_ = std::move(provider_receiver);
-  }
-}
-
 void OpenXrDevice::CreateImmersiveOverlay(
     mojo::PendingReceiver<mojom::ImmersiveOverlay> overlay_receiver) {
   EnsureRenderLoop();

device/vr/openxr/openxr_device.h

@@ -21,7 +21,6 @@ class OpenXrRenderLoop;
 class DEVICE_VR_EXPORT OpenXrDevice
     : public VRDeviceBase,
       public mojom::XRSessionController,
-      public mojom::IsolatedXRGamepadProviderFactory,
       public mojom::XRCompositorHost {
  public:
   OpenXrDevice();
@@ -32,19 +31,12 @@ class DEVICE_VR_EXPORT OpenXrDevice
       mojom::XRRuntimeSessionOptionsPtr options,
       mojom::XRRuntime::RequestSessionCallback callback) override;
 
-  mojo::PendingRemote<mojom::IsolatedXRGamepadProviderFactory>
-  BindGamepadFactory();
   mojo::PendingRemote<mojom::XRCompositorHost> BindCompositorHost();
 
  private:
   // XRSessionController
   void SetFrameDataRestricted(bool restricted) override;
 
-  // mojom::IsolatedXRGamepadProviderFactory
-  void GetIsolatedXRGamepadProvider(
-      mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver)
-      override;
-
   // XRCompositorHost
   void CreateImmersiveOverlay(
       mojo::PendingReceiver<mojom::ImmersiveOverlay> overlay_receiver) override;
@@ -61,10 +53,6 @@ class DEVICE_VR_EXPORT OpenXrDevice
   mojo::Receiver<mojom::XRSessionController> exclusive_controller_receiver_{
       this};
 
-  mojo::Receiver<mojom::IsolatedXRGamepadProviderFactory>
-      gamepad_provider_factory_receiver_{this};
-  mojo::PendingReceiver<mojom::IsolatedXRGamepadProvider> provider_receiver_;
-
   mojo::Receiver<mojom::XRCompositorHost> compositor_host_receiver_{this};
   mojo::PendingReceiver<mojom::ImmersiveOverlay> overlay_receiver_;
 

device/vr/openxr/openxr_input_helper.cc

@@ -91,44 +91,6 @@ OpenXRInputHelper::OpenXRInputHelper(XrSession session, XrSpace local_space)
 
 OpenXRInputHelper::~OpenXRInputHelper() = default;
 
-mojom::XRGamepadDataPtr OpenXRInputHelper::GetGamepadData(
-    XrTime predicted_display_time) {
-  if (XR_FAILED(SyncActions(predicted_display_time)))
-    return nullptr;
-
-  mojom::XRGamepadDataPtr gamepad_data_ptr = mojom::XRGamepadData::New();
-  for (const OpenXrControllerState& controller_state : controller_states_) {
-    const OpenXrController& controller = controller_state.controller;
-    mojom::XRGamepadPtr gamepad_ptr = mojom::XRGamepad::New();
-    gamepad_ptr->controller_id = controller.GetId();
-    gamepad_ptr->timestamp = base::TimeTicks::Now();
-    gamepad_ptr->hand = controller.GetHandness();
-
-    std::vector<mojom::XRGamepadButtonPtr> buttons =
-        controller.GetWebVrButtons();
-    if (buttons.empty())
-      continue;
-    gamepad_ptr->buttons = std::move(buttons);
-
-    std::vector<double> axes = controller.GetWebVrAxes();
-    if (axes.empty())
-      continue;
-    gamepad_ptr->axes = std::move(axes);
-
-    gamepad_ptr->pose =
-        controller.GetPose(predicted_display_time, local_space_);
-    if (!gamepad_ptr->pose)
-      continue;
-    gamepad_ptr->can_provide_position = gamepad_ptr->pose->position.has_value();
-    gamepad_ptr->can_provide_orientation =
-        gamepad_ptr->pose->orientation.has_value();
-
-    gamepad_data_ptr->gamepads.push_back(std::move(gamepad_ptr));
-  }
-
-  return gamepad_data_ptr;
-}
-
 std::vector<mojom::XRInputSourceStatePtr> OpenXRInputHelper::GetInputState(
     XrTime predicted_display_time) {
   std::vector<mojom::XRInputSourceStatePtr> input_states;

device/vr/openxr/openxr_input_helper.h

@@ -12,7 +12,6 @@
 #include "base/optional.h"
 
 #include "device/vr/openxr/openxr_controller.h"
-#include "device/vr/public/mojom/isolated_xr_service.mojom.h"
 
 namespace device {
 
@@ -28,8 +27,6 @@ class OpenXRInputHelper {
 
   ~OpenXRInputHelper();
 
-  mojom::XRGamepadDataPtr GetGamepadData(XrTime predicted_display_time);
-
   std::vector<mojom::XRInputSourceStatePtr> GetInputState(
       XrTime predicted_display_time);
 

device/vr/openxr/openxr_render_loop.cc

@@ -81,10 +81,6 @@ mojom::XRFrameDataPtr OpenXrRenderLoop::GetNextFrameData() {
   return frame_data;
 }
 
-mojom::XRGamepadDataPtr OpenXrRenderLoop::GetNextGamepadData() {
-  return input_helper_->GetGamepadData(openxr_->GetPredictedDisplayTime());
-}
-
 bool OpenXrRenderLoop::StartRuntime() {
   DCHECK(!openxr_);
   DCHECK(!input_helper_);

device/vr/openxr/openxr_render_loop.h

@@ -29,7 +29,6 @@ class OpenXrRenderLoop : public XRCompositorCommon {
  private:
   // XRDeviceAbstraction:
   mojom::XRFrameDataPtr GetNextFrameData() override;
-  mojom::XRGamepadDataPtr GetNextGamepadData() override;
   bool StartRuntime() override;
   void StopRuntime() override;
   void OnSessionStart() override;