Cleanup WMR test TODOs

Cleans up all remaining TODOs pointing to 926048, which covers adding
WMR support to the XR browser tests. Specifically, this properly
implements controller and pointer poses using the data provided by
the test instead of using hard coded values.

Bug: 926048
Change-Id: I014781127e8d7e5151a1766ad2a8d28761140ecc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1642960Reviewed-by: Alexander Cooper <alcooper@chromium.org>
Commit-Queue: Brian Sheedy <bsheedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#666105}

device/vr/test/test_hook.h

@@ -6,6 +6,7 @@
 #define DEVICE_VR_TEST_TEST_HOOK_H_
 
 #include "base/logging.h"
+#include "ui/gfx/transform.h"
 
 #include <cstdint>
 
@@ -120,6 +121,18 @@ struct ControllerFrameData {
   bool is_valid = false;
 };
 
+inline gfx::Transform PoseFrameDataToTransform(PoseFrameData data) {
+  // The gfx::Transform constructor takes arguments in row-major order, but
+  // we're given data in column-major order. Construct in column-major order and
+  // transpose since it looks cleaner than manually transposing the arguments
+  // passed to the constructor.
+  float* t = data.device_to_origin;
+  gfx::Transform transform(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8],
+                           t[9], t[10], t[11], t[12], t[13], t[14], t[15]);
+  transform.Transpose();
+  return transform;
+}
+
 // Tests may implement this, and register it to control behavior of VR runtime.
 class VRTestHook {
  public:

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_input_location.cc

@@ -5,28 +5,40 @@
 #include "device/vr/windows_mixed_reality/wrappers/test/mock_wmr_input_location.h"
 
 #include "base/logging.h"
+#include "device/vr/test/test_hook.h"
+#include "ui/gfx/geometry/vector3d_f.h"
+#include "ui/gfx/transform_util.h"
 
 namespace device {
 
 MockWMRInputLocation::MockWMRInputLocation(ControllerFrameData data)
-    : data_(data) {}
+    : data_(data) {
+  DecomposeTransform(&decomposed_device_to_origin_,
+                     PoseFrameDataToTransform(data.pose_data));
+}
 
 MockWMRInputLocation::~MockWMRInputLocation() = default;
 
 bool MockWMRInputLocation::TryGetPosition(
     ABI::Windows::Foundation::Numerics::Vector3* position) const {
   DCHECK(position);
-  // TODO(https://crbug.com/926048): Properly implement.
-  position->X = 0;
-  position->Y = 0;
-  position->Z = 0;
+  if (!data_.pose_data.is_valid)
+    return false;
+
+  position->X = decomposed_device_to_origin_.translate[0];
+  position->Y = decomposed_device_to_origin_.translate[1];
+  position->Z = decomposed_device_to_origin_.translate[2];
   return true;
 }
 
 bool MockWMRInputLocation::TryGetVelocity(
     ABI::Windows::Foundation::Numerics::Vector3* velocity) const {
   DCHECK(velocity);
-  // TODO(https://crbug.com/926048): Properly implement.
+  if (!data_.pose_data.is_valid)
+    return false;
+  // We could potentially store a history of poses and calculate the velocity,
+  // but that is more complicated and doesn't currently provide any benefit for
+  // tests. So, just report 0s.
   velocity->X = 0;
   velocity->Y = 0;
   velocity->Z = 0;
@@ -36,18 +48,24 @@ bool MockWMRInputLocation::TryGetVelocity(
 bool MockWMRInputLocation::TryGetOrientation(
     ABI::Windows::Foundation::Numerics::Quaternion* orientation) const {
   DCHECK(orientation);
-  // TODO(https://crbug.com/926048): Properly implement.
-  orientation->X = 0;
-  orientation->Y = 0;
-  orientation->Z = 0;
-  orientation->W = 1;
+  if (!data_.pose_data.is_valid)
+    return false;
+
+  orientation->X = decomposed_device_to_origin_.quaternion.x();
+  orientation->Y = decomposed_device_to_origin_.quaternion.y();
+  orientation->Z = decomposed_device_to_origin_.quaternion.z();
+  orientation->W = decomposed_device_to_origin_.quaternion.w();
   return true;
 }
 
 bool MockWMRInputLocation::TryGetAngularVelocity(
     ABI::Windows::Foundation::Numerics::Vector3* angular_velocity) const {
   DCHECK(angular_velocity);
-  // TODO(https://crbug.com/926048): Properly implement.
+  if (!data_.pose_data.is_valid)
+    return false;
+  // We could potentially store a history of poses and calculate the angular
+  // velocity, but that is more complicated and doesn't currently provide any
+  // benefit for tests. So, just report 0s.
   angular_velocity->X = 0;
   angular_velocity->Y = 0;
   angular_velocity->Z = 0;

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_input_location.h

@@ -6,6 +6,7 @@
 
 #include "device/vr/test/test_hook.h"
 #include "device/vr/windows_mixed_reality/wrappers/wmr_input_location.h"
+#include "ui/gfx/transform_util.h"
 
 namespace device {
 
@@ -25,6 +26,7 @@ class MockWMRInputLocation : public WMRInputLocation {
 
  private:
   ControllerFrameData data_;
+  gfx::DecomposedTransform decomposed_device_to_origin_;
 };
 
 }  // namespace device

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_input_source_state.cc

@@ -19,7 +19,7 @@ MockWMRInputSourceState::~MockWMRInputSourceState() = default;
 
 std::unique_ptr<WMRPointerPose> MockWMRInputSourceState::TryGetPointerPose(
     const WMRCoordinateSystem* origin) const {
-  return std::make_unique<MockWMRPointerPose>();
+  return std::make_unique<MockWMRPointerPose>(data_);
 }
 
 std::unique_ptr<WMRInputSource> MockWMRInputSourceState::GetSource() const {

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_pointer_pose.cc

@@ -9,18 +9,19 @@
 
 namespace device {
 
-MockWMRPointerPose::MockWMRPointerPose() {}
+MockWMRPointerPose::MockWMRPointerPose(ControllerFrameData data)
+    : data_(data) {}
 
 MockWMRPointerPose::~MockWMRPointerPose() = default;
 
 bool MockWMRPointerPose::IsValid() const {
-  return true;
+  return data_.pose_data.is_valid;
 }
 
 std::unique_ptr<WMRPointerSourcePose>
 MockWMRPointerPose::TryGetInteractionSourcePose(
     const WMRInputSource* source) const {
-  return std::make_unique<MockWMRPointerSourcePose>();
+  return std::make_unique<MockWMRPointerSourcePose>(data_);
 }
 
 ABI::Windows::Foundation::Numerics::Vector3 MockWMRPointerPose::HeadForward()

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_pointer_pose.h

@@ -4,13 +4,14 @@
 #ifndef DEVICE_VR_WINDOWS_MIXED_REALITY_WRAPPERS_TEST_MOCK_WMR_POINTER_POSE_H_
 #define DEVICE_VR_WINDOWS_MIXED_REALITY_WRAPPERS_TEST_MOCK_WMR_POINTER_POSE_H_
 
+#include "device/vr/test/test_hook.h"
 #include "device/vr/windows_mixed_reality/wrappers/wmr_pointer_pose.h"
 
 namespace device {
 
 class MockWMRPointerPose : public WMRPointerPose {
  public:
-  MockWMRPointerPose();
+  MockWMRPointerPose(ControllerFrameData data);
   ~MockWMRPointerPose() override;
 
   bool IsValid() const override;
@@ -19,6 +20,7 @@ class MockWMRPointerPose : public WMRPointerPose {
   ABI::Windows::Foundation::Numerics::Vector3 HeadForward() const override;
 
  private:
+  ControllerFrameData data_;
   DISALLOW_COPY(MockWMRPointerPose);
 };
 

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_pointer_source_pose.cc

@@ -4,27 +4,36 @@
 
 #include "device/vr/windows_mixed_reality/wrappers/test/mock_wmr_pointer_source_pose.h"
 
+#include "device/vr/windows_mixed_reality/wrappers/test/mock_wmr_input_location.h"
+
 namespace device {
 
-MockWMRPointerSourcePose::MockWMRPointerSourcePose() {}
+MockWMRPointerSourcePose::MockWMRPointerSourcePose(ControllerFrameData data)
+    : data_(data) {}
 
 MockWMRPointerSourcePose::~MockWMRPointerSourcePose() = default;
 
 bool MockWMRPointerSourcePose::IsValid() const {
-  return true;
+  return data_.pose_data.is_valid;
 }
 
 ABI::Windows::Foundation::Numerics::Vector3 MockWMRPointerSourcePose::Position()
     const {
-  // TODO(https://crbug.com/926048): Actually implement.
-  return {1, 1, 1};
+  // Providing the same position and orientation as the controller should be
+  // valid and make it easy to actually point at things in tests if ever
+  // necessary.
+  ABI::Windows::Foundation::Numerics::Vector3 ret;
+  MockWMRInputLocation loc(data_);
+  loc.TryGetPosition(&ret);
+  return ret;
 }
 
 ABI::Windows::Foundation::Numerics::Quaternion
 MockWMRPointerSourcePose::Orientation() const {
-  // TODO(https://crbug.com/926048): Actually implement.
-  // For whatever reason, W is first?
-  return {1, 0, 0, 0};
+  ABI::Windows::Foundation::Numerics::Quaternion ret;
+  MockWMRInputLocation loc(data_);
+  loc.TryGetOrientation(&ret);
+  return ret;
 }
 
 }  // namespace device

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_pointer_source_pose.h

@@ -4,13 +4,14 @@
 #ifndef DEVICE_VR_WINDOWS_MIXED_REALITY_WRAPPERS_TEST_MOCK_WMR_POINTER_SOURCE_POSE_H_
 #define DEVICE_VR_WINDOWS_MIXED_REALITY_WRAPPERS_TEST_MOCK_WMR_POINTER_SOURCE_POSE_H_
 
+#include "device/vr/test/test_hook.h"
 #include "device/vr/windows_mixed_reality/wrappers/wmr_pointer_source_pose.h"
 
 namespace device {
 
 class MockWMRPointerSourcePose : public WMRPointerSourcePose {
  public:
-  MockWMRPointerSourcePose();
+  MockWMRPointerSourcePose(ControllerFrameData data);
   ~MockWMRPointerSourcePose() override;
 
   bool IsValid() const override;
@@ -18,6 +19,7 @@ class MockWMRPointerSourcePose : public WMRPointerSourcePose {
   ABI::Windows::Foundation::Numerics::Quaternion Orientation() const override;
 
  private:
+  ControllerFrameData data_;
   DISALLOW_COPY(MockWMRPointerSourcePose);
 };
 

device/vr/windows_mixed_reality/wrappers/test/mock_wmr_rendering.cc

@@ -128,15 +128,7 @@ bool MockWMRCameraPose::TryGetViewTransform(
 
   // We need to get the inverse of the given transform, as it's the
   // device-to-origin transform and we need the origin-to-device transform.
-  float* t = pose_data.device_to_origin;
-  // The gfx::Transform constructor takes arguments in row-major order, but
-  // we're given data in column-major order. Construct in column-major order and
-  // transpose since it looks cleaner than manually transposing the arguments
-  // passed to the constructor.
-  gfx::Transform device_to_origin(t[0], t[1], t[2], t[3], t[4], t[5], t[6],
-                                  t[7], t[8], t[9], t[10], t[11], t[12], t[13],
-                                  t[14], t[15]);
-  device_to_origin.Transpose();
+  gfx::Transform device_to_origin = PoseFrameDataToTransform(pose_data);
   gfx::Transform origin_to_device = device_to_origin;
   auto success = origin_to_device.GetInverse(&origin_to_device);
   DCHECK(success);