Refactor remaining WMR wrappers

Refactors the remaining WMR wrappers that have mock implementations
(those in wmr_timestamp.h and wmr_rendering.h) in the same way as
https://crrev.com/c/1603748.

Bug: 961020
Change-Id: I0a28f981cf705c4950b660058712c9643546a784
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1611422
Commit-Queue: Brian Sheedy <bsheedy@chromium.org>
Auto-Submit: Brian Sheedy <bsheedy@chromium.org>
Reviewed-by: Alexander Cooper <alcooper@chromium.org>
Cr-Commit-Position: refs/heads/master@{#659656}

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

@@ -21,4 +21,9 @@ ABI::Windows::Foundation::TimeSpan MockWMRTimestamp::PredictionAmount() const {
   return ret;
 }
 
+ABI::Windows::Perception::IPerceptionTimestamp* MockWMRTimestamp::GetRawPtr()
+    const {
+  return nullptr;
+}
+
 }  // namespace device

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

@@ -15,6 +15,7 @@ class MockWMRTimestamp : public WMRTimestamp {
 
   ABI::Windows::Foundation::DateTime TargetTime() const override;
   ABI::Windows::Foundation::TimeSpan PredictionAmount() const override;
+  ABI::Windows::Perception::IPerceptionTimestamp* GetRawPtr() const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockWMRTimestamp);

device/vr/windows_mixed_reality/wrappers/wmr_holographic_frame.cc

@@ -44,7 +44,7 @@ std::unique_ptr<WMRTimestamp> WMRHolographicFramePredictionImpl::Timestamp() {
   ComPtr<IPerceptionTimestamp> timestamp;
   HRESULT hr = prediction_->get_Timestamp(&timestamp);
   DCHECK(SUCCEEDED(hr));
-  return std::make_unique<WMRTimestamp>(timestamp);
+  return std::make_unique<WMRTimestampImpl>(timestamp);
 }
 
 std::vector<std::unique_ptr<WMRCameraPose>>
@@ -62,7 +62,7 @@ WMRHolographicFramePredictionImpl::CameraPoses() {
   for (uint32_t i = 0; i < num; i++) {
     ComPtr<IHolographicCameraPose> pose;
     poses->GetAt(i, &pose);
-    ret_val.push_back(std::make_unique<WMRCameraPose>(pose));
+    ret_val.push_back(std::make_unique<WMRCameraPoseImpl>(pose));
   }
 
   return ret_val;
@@ -92,7 +92,7 @@ WMRHolographicFrameImpl::TryGetRenderingParameters(const WMRCameraPose* pose) {
                                                           &rendering_params);
   if (FAILED(hr))
     return nullptr;
-  return std::make_unique<WMRRenderingParameters>(rendering_params);
+  return std::make_unique<WMRRenderingParametersImpl>(rendering_params);
 }
 
 bool WMRHolographicFrameImpl::TryPresentUsingCurrentPrediction() {

device/vr/windows_mixed_reality/wrappers/wmr_origins.cc

@@ -40,6 +40,8 @@ using Microsoft::WRL::ComPtr;
 namespace device {
 // WMRCoordinateSystem
 ISpatialCoordinateSystem* WMRCoordinateSystem::GetRawPtr() const {
+  // This should only ever be used by the real implementation, so by default
+  // make sure it's not called.
   NOTREACHED();
   return nullptr;
 }

device/vr/windows_mixed_reality/wrappers/wmr_origins.h

@@ -22,9 +22,6 @@ class WMRCoordinateSystem {
   virtual bool TryGetTransformTo(
       const WMRCoordinateSystem* other,
       ABI::Windows::Foundation::Numerics::Matrix4x4* this_to_other) = 0;
-
-  // This should only ever be used by the real implementation, so by default
-  // make sure it's not called.
   virtual ABI::Windows::Perception::Spatial::ISpatialCoordinateSystem*
   GetRawPtr() const;
 };

device/vr/windows_mixed_reality/wrappers/wmr_rendering.cc

@@ -26,22 +26,21 @@ using Windows::Graphics::DirectX::Direct3D11::IDirect3DDxgiInterfaceAccess;
 
 namespace device {
 // WMRCamera
-WMRCamera::WMRCamera(ComPtr<IHolographicCamera> camera) : camera_(camera) {
+WMRCameraImpl::WMRCameraImpl(ComPtr<IHolographicCamera> camera)
+    : camera_(camera) {
   DCHECK(camera_);
 }
 
-WMRCamera::WMRCamera() {}
+WMRCameraImpl::~WMRCameraImpl() = default;
 
-WMRCamera::~WMRCamera() = default;
-
-WF::Size WMRCamera::RenderTargetSize() {
+WF::Size WMRCameraImpl::RenderTargetSize() {
   WF::Size val;
   HRESULT hr = camera_->get_RenderTargetSize(&val);
   DCHECK(SUCCEEDED(hr));
   return val;
 }
 
-bool WMRCamera::IsStereo() {
+bool WMRCameraImpl::IsStereo() {
   boolean val;
   HRESULT hr = camera_->get_IsStereo(&val);
   DCHECK(SUCCEEDED(hr));
@@ -49,37 +48,44 @@ bool WMRCamera::IsStereo() {
 }
 
 // WMRCameraPose
-WMRCameraPose::WMRCameraPose(ComPtr<IHolographicCameraPose> pose)
+ABI::Windows::Graphics::Holographic::IHolographicCameraPose*
+WMRCameraPose::GetRawPtr() const {
+  // This should only ever be used by the real implementation, so by default
+  // make sure it's not called.
+  NOTREACHED();
+  return nullptr;
+}
+
+WMRCameraPoseImpl::WMRCameraPoseImpl(ComPtr<IHolographicCameraPose> pose)
     : pose_(pose) {
   DCHECK(pose_);
 }
 
-WMRCameraPose::WMRCameraPose() {}
-
-WMRCameraPose::~WMRCameraPose() = default;
+WMRCameraPoseImpl::~WMRCameraPoseImpl() = default;
 
-WF::Rect WMRCameraPose::Viewport() {
+WF::Rect WMRCameraPoseImpl::Viewport() {
   WF::Rect val;
   HRESULT hr = pose_->get_Viewport(&val);
   DCHECK(SUCCEEDED(hr));
   return val;
 }
 
-std::unique_ptr<WMRCamera> WMRCameraPose::HolographicCamera() {
+std::unique_ptr<WMRCamera> WMRCameraPoseImpl::HolographicCamera() {
   ComPtr<IHolographicCamera> camera;
   HRESULT hr = pose_->get_HolographicCamera(&camera);
   DCHECK(SUCCEEDED(hr));
-  return std::make_unique<WMRCamera>(camera);
+  return std::make_unique<WMRCameraImpl>(camera);
 }
 
-HolographicStereoTransform WMRCameraPose::ProjectionTransform() {
+HolographicStereoTransform WMRCameraPoseImpl::ProjectionTransform() {
   HolographicStereoTransform val;
   HRESULT hr = pose_->get_ProjectionTransform(&val);
   DCHECK(SUCCEEDED(hr));
   return val;
 }
 
-bool WMRCameraPose::TryGetViewTransform(const WMRCoordinateSystem* origin,
+bool WMRCameraPoseImpl::TryGetViewTransform(
+    const WMRCoordinateSystem* origin,
     HolographicStereoTransform* transform) {
   ComPtr<IReference<HolographicStereoTransform>> transform_ref;
   if (FAILED(pose_->TryGetViewTransform(origin->GetRawPtr(), &transform_ref)) ||
@@ -90,22 +96,21 @@ bool WMRCameraPose::TryGetViewTransform(const WMRCoordinateSystem* origin,
   return SUCCEEDED(hr);
 }
 
-IHolographicCameraPose* WMRCameraPose::GetRawPtr() const {
+IHolographicCameraPose* WMRCameraPoseImpl::GetRawPtr() const {
   return pose_.Get();
 }
 
 // WMRRenderingParameters
-WMRRenderingParameters::WMRRenderingParameters(
+WMRRenderingParametersImpl::WMRRenderingParametersImpl(
     ComPtr<IHolographicCameraRenderingParameters> rendering_params)
     : rendering_params_(rendering_params) {
   DCHECK(rendering_params_);
 }
 
-WMRRenderingParameters::WMRRenderingParameters() {}
-
-WMRRenderingParameters::~WMRRenderingParameters() = default;
+WMRRenderingParametersImpl::~WMRRenderingParametersImpl() = default;
 
-ComPtr<ID3D11Texture2D> WMRRenderingParameters::TryGetBackbufferAsTexture2D() {
+ComPtr<ID3D11Texture2D>
+WMRRenderingParametersImpl::TryGetBackbufferAsTexture2D() {
   ComPtr<IDirect3DSurface> surface;
   if (FAILED(rendering_params_->get_Direct3D11BackBuffer(&surface)))
     return nullptr;

device/vr/windows_mixed_reality/wrappers/wmr_rendering.h

@@ -18,76 +18,98 @@ class WMRCoordinateSystem;
 
 class WMRCamera {
  public:
-  explicit WMRCamera(
+  virtual ~WMRCamera() = default;
+
+  virtual ABI::Windows::Foundation::Size RenderTargetSize() = 0;
+  virtual bool IsStereo() = 0;
+};
+
+class WMRCameraImpl : public WMRCamera {
+ public:
+  explicit WMRCameraImpl(
       Microsoft::WRL::ComPtr<
           ABI::Windows::Graphics::Holographic::IHolographicCamera> camera);
-  virtual ~WMRCamera();
-
-  virtual ABI::Windows::Foundation::Size RenderTargetSize();
-  virtual bool IsStereo();
+  ~WMRCameraImpl() override;
 
- protected:
-  // Necessary so subclasses don't call the explicit constructor.
-  WMRCamera();
+  ABI::Windows::Foundation::Size RenderTargetSize() override;
+  bool IsStereo() override;
 
  private:
   Microsoft::WRL::ComPtr<
       ABI::Windows::Graphics::Holographic::IHolographicCamera>
       camera_;
 
-  DISALLOW_COPY_AND_ASSIGN(WMRCamera);
+  DISALLOW_COPY_AND_ASSIGN(WMRCameraImpl);
 };
 
 class WMRCameraPose {
  public:
-  explicit WMRCameraPose(
-      Microsoft::WRL::ComPtr<
-          ABI::Windows::Graphics::Holographic::IHolographicCameraPose> pose);
-  virtual ~WMRCameraPose();
+  virtual ~WMRCameraPose() = default;
 
-  virtual ABI::Windows::Foundation::Rect Viewport();
-  virtual std::unique_ptr<WMRCamera> HolographicCamera();
+  virtual ABI::Windows::Foundation::Rect Viewport() = 0;
+  virtual std::unique_ptr<WMRCamera> HolographicCamera() = 0;
   virtual ABI::Windows::Graphics::Holographic::HolographicStereoTransform
-  ProjectionTransform();
+  ProjectionTransform() = 0;
   virtual bool TryGetViewTransform(
       const WMRCoordinateSystem* origin,
       ABI::Windows::Graphics::Holographic::HolographicStereoTransform*
-          transform);
-  ABI::Windows::Graphics::Holographic::IHolographicCameraPose* GetRawPtr()
-      const;
+          transform) = 0;
+  virtual ABI::Windows::Graphics::Holographic::IHolographicCameraPose*
+  GetRawPtr() const;
+};
+
+class WMRCameraPoseImpl : public WMRCameraPose {
+ public:
+  explicit WMRCameraPoseImpl(
+      Microsoft::WRL::ComPtr<
+          ABI::Windows::Graphics::Holographic::IHolographicCameraPose> pose);
+  ~WMRCameraPoseImpl() override;
 
- protected:
-  // Necessary so subclasses don't call the explicit constructor.
-  WMRCameraPose();
+  ABI::Windows::Foundation::Rect Viewport() override;
+  std::unique_ptr<WMRCamera> HolographicCamera() override;
+  ABI::Windows::Graphics::Holographic::HolographicStereoTransform
+  ProjectionTransform() override;
+  bool TryGetViewTransform(
+      const WMRCoordinateSystem* origin,
+      ABI::Windows::Graphics::Holographic::HolographicStereoTransform*
+          transform) override;
+  ABI::Windows::Graphics::Holographic::IHolographicCameraPose* GetRawPtr()
+      const override;
 
  private:
   Microsoft::WRL::ComPtr<
       ABI::Windows::Graphics::Holographic::IHolographicCameraPose>
       pose_;
 
-  DISALLOW_COPY_AND_ASSIGN(WMRCameraPose);
+  DISALLOW_COPY_AND_ASSIGN(WMRCameraPoseImpl);
 };
 
 class WMRRenderingParameters {
  public:
-  explicit WMRRenderingParameters(
+  virtual ~WMRRenderingParameters() = default;
+
+  virtual Microsoft::WRL::ComPtr<ID3D11Texture2D>
+  TryGetBackbufferAsTexture2D() = 0;
+};
+
+class WMRRenderingParametersImpl : public WMRRenderingParameters {
+ public:
+  explicit WMRRenderingParametersImpl(
       Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Holographic::
                                  IHolographicCameraRenderingParameters>
           rendering_params);
-  virtual ~WMRRenderingParameters();
+  ~WMRRenderingParametersImpl() override;
 
-  virtual Microsoft::WRL::ComPtr<ID3D11Texture2D> TryGetBackbufferAsTexture2D();
-
- protected:
-  // Necessary so subclasses don't call the explicit constructor.
-  WMRRenderingParameters();
+  Microsoft::WRL::ComPtr<ID3D11Texture2D> TryGetBackbufferAsTexture2D()
+      override;
 
  private:
   Microsoft::WRL::ComPtr<ABI::Windows::Graphics::Holographic::
                              IHolographicCameraRenderingParameters>
       rendering_params_;
 
-  DISALLOW_COPY_AND_ASSIGN(WMRRenderingParameters);
+  DISALLOW_COPY_AND_ASSIGN(WMRRenderingParametersImpl);
 };
+
 }  // namespace device
 #endif  // DEVICE_VR_WINDOWS_MIXED_REALITY_WRAPPERS_WMR_RENDERING_H_

device/vr/windows_mixed_reality/wrappers/wmr_timestamp.cc

@@ -14,30 +14,29 @@ using ABI::Windows::Perception::IPerceptionTimestamp;
 using Microsoft::WRL::ComPtr;
 
 namespace device {
-WMRTimestamp::WMRTimestamp(ComPtr<IPerceptionTimestamp> timestamp)
+
+WMRTimestampImpl::WMRTimestampImpl(ComPtr<IPerceptionTimestamp> timestamp)
     : timestamp_(timestamp) {
   DCHECK(timestamp_);
 }
 
-WMRTimestamp::WMRTimestamp() {}
-
-WMRTimestamp::~WMRTimestamp() = default;
+WMRTimestampImpl::~WMRTimestampImpl() = default;
 
-DateTime WMRTimestamp::TargetTime() const {
+DateTime WMRTimestampImpl::TargetTime() const {
   DateTime val;
   HRESULT hr = timestamp_->get_TargetTime(&val);
   DCHECK(SUCCEEDED(hr));
   return val;
 }
 
-TimeSpan WMRTimestamp::PredictionAmount() const {
+TimeSpan WMRTimestampImpl::PredictionAmount() const {
   TimeSpan val;
   HRESULT hr = timestamp_->get_PredictionAmount(&val);
   DCHECK(SUCCEEDED(hr));
   return val;
 }
 
-IPerceptionTimestamp* WMRTimestamp::GetRawPtr() const {
+IPerceptionTimestamp* WMRTimestampImpl::GetRawPtr() const {
   return timestamp_.Get();
 }
 }  // namespace device

device/vr/windows_mixed_reality/wrappers/wmr_timestamp.h

@@ -12,24 +12,33 @@
 namespace device {
 class WMRTimestamp {
  public:
-  explicit WMRTimestamp(
+  virtual ~WMRTimestamp() = default;
+
+  virtual ABI::Windows::Foundation::DateTime TargetTime() const = 0;
+  virtual ABI::Windows::Foundation::TimeSpan PredictionAmount() const = 0;
+  // No default implementation w/ a NOTREACHED like other GetRawPtr()s because
+  // this is expected to be called on both the real and mock implementations in
+  // MixedRealityInputHelper::GetInputState().
+  virtual ABI::Windows::Perception::IPerceptionTimestamp* GetRawPtr() const = 0;
+};
+
+class WMRTimestampImpl : public WMRTimestamp {
+ public:
+  explicit WMRTimestampImpl(
       Microsoft::WRL::ComPtr<ABI::Windows::Perception::IPerceptionTimestamp>
           timestamp);
-  virtual ~WMRTimestamp();
-
-  virtual ABI::Windows::Foundation::DateTime TargetTime() const;
-  virtual ABI::Windows::Foundation::TimeSpan PredictionAmount() const;
-  ABI::Windows::Perception::IPerceptionTimestamp* GetRawPtr() const;
+  ~WMRTimestampImpl() override;
 
- protected:
-  // Necessary so subclasses don't call the explicit constructor.
-  WMRTimestamp();
+  ABI::Windows::Foundation::DateTime TargetTime() const override;
+  ABI::Windows::Foundation::TimeSpan PredictionAmount() const override;
+  ABI::Windows::Perception::IPerceptionTimestamp* GetRawPtr() const override;
 
  private:
   Microsoft::WRL::ComPtr<ABI::Windows::Perception::IPerceptionTimestamp>
       timestamp_;
 
-  DISALLOW_COPY_AND_ASSIGN(WMRTimestamp);
+  DISALLOW_COPY_AND_ASSIGN(WMRTimestampImpl);
 };
+
 }  // namespace device
 #endif  // DEVICE_VR_WINDOWS_MIXED_REALITY_WRAPPERS_WMR_TIMESTAMP_H_