dom/vr/VRServiceTest.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/VRServiceTest.h"
   8 #include "mozilla/dom/VRServiceTestBinding.h"
   9 #include "mozilla/dom/GamepadPoseState.h"
  10 #include "mozilla/dom/Promise.h"
  11 #include "VRManagerChild.h"
  12 #include "VRPuppetCommandBuffer.h"
  13 #include <type_traits>
  14
  15 namespace mozilla {
  16 using namespace gfx;
  17 namespace dom {
  18
  19 NS_IMPL_CYCLE_COLLECTION_INHERITED(VRMockDisplay, DOMEventTargetHelper,
  20                                    mVRServiceTest)
  21
  22 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(VRMockDisplay,
  23                                                DOMEventTargetHelper)
  24
  25 namespace {
  26 template <class T>
  27 bool ReadFloat32Array(T* aDestination, const Float32Array& aSource,
  28                       ErrorResult& aRv) {
  29   if (!aSource.CopyDataTo(aDestination)) {
  30     aRv.Throw(NS_ERROR_INVALID_ARG);
  31     // We don't want to MOZ_ASSERT here, as that would cause the
  32     // browser to crash, making it difficult to debug the problem
  33     // in JS code calling this API.
  34     return false;
  35   }
  36   return true;
  37 }
  38 };  // anonymous namespace
  39
  40 VRMockDisplay::VRMockDisplay(VRServiceTest* aVRServiceTest)
  41     : DOMEventTargetHelper(aVRServiceTest->GetOwnerGlobal()),
  42       mVRServiceTest(aVRServiceTest) {}
  43
  44 JSObject* VRMockDisplay::WrapObject(JSContext* aCx,
  45                                     JS::Handle<JSObject*> aGivenProto) {
  46   return VRMockDisplay_Binding::Wrap(aCx, this, aGivenProto);
  47 }
  48
  49 VRHMDSensorState& VRMockDisplay::SensorState() const {
  50   return mVRServiceTest->SystemState().sensorState;
  51 }
  52
  53 VRDisplayState& VRMockDisplay::DisplayState() const {
  54   return mVRServiceTest->SystemState().displayState;
  55 }
  56
  57 void VRMockDisplay::Clear() {
  58   VRDisplayState& displayState = DisplayState();
  59   displayState.Clear();
  60   VRHMDSensorState& sensorState = SensorState();
  61   sensorState.Clear();
  62 }
  63
  64 void VRMockDisplay::Create() {
  65   Clear();
  66   VRDisplayState& state = DisplayState();
  67
  68   strncpy(state.displayName.data(), "Puppet HMD", kVRDisplayNameMaxLen);
  69   state.eightCC = GFX_VR_EIGHTCC('P', 'u', 'p', 'p', 'e', 't', ' ', ' ');
  70   state.isConnected = true;
  71   state.isMounted = false;
  72   state.capabilityFlags = VRDisplayCapabilityFlags::Cap_None |
  73                           VRDisplayCapabilityFlags::Cap_Orientation |
  74                           VRDisplayCapabilityFlags::Cap_Position |
  75                           VRDisplayCapabilityFlags::Cap_External |
  76                           VRDisplayCapabilityFlags::Cap_Present |
  77                           VRDisplayCapabilityFlags::Cap_StageParameters |
  78                           VRDisplayCapabilityFlags::Cap_MountDetection |
  79                           VRDisplayCapabilityFlags::Cap_ImmersiveVR;
  80   state.blendMode = VRDisplayBlendMode::Opaque;
  81
  82   // 1836 x 2040 resolution is arbitrary and can be overridden.
  83   // This default resolution was chosen to be within range of a
  84   // typical VR eye buffer size.  This value is derived by
  85   // scaling a 1080x1200 per-eye panel resolution by the
  86   // commonly used pre-lens-distortion pass scaling factor of 1.7x.
  87   // 1.7x is commonly used in HMD's employing fresnel lenses to ensure
  88   // a sufficient fragment shading rate in the peripheral area of the
  89   // post-warp eye buffers.
  90   state.eyeResolution.width = 1836;   // 1080 * 1.7
  91   state.eyeResolution.height = 2040;  // 1200 * 1.7
  92
  93   for (uint32_t eye = 0; eye < VRDisplayState::NumEyes; ++eye) {
  94     state.eyeTranslation[eye].x = 0.0f;
  95     state.eyeTranslation[eye].y = 0.0f;
  96     state.eyeTranslation[eye].z = 0.0f;
  97     state.eyeFOV[eye] = gfx::VRFieldOfView(45.0, 45.0, 45.0, 45.0);
  98   }
  99
 100   // default: 1m x 1m space, 0.75m high in seated position
 101   state.stageSize.width = 1.0f;
 102   state.stageSize.height = 1.0f;
 103
 104   state.sittingToStandingTransform[0] = 1.0f;
 105   state.sittingToStandingTransform[1] = 0.0f;
 106   state.sittingToStandingTransform[2] = 0.0f;
 107   state.sittingToStandingTransform[3] = 0.0f;
 108
 109   state.sittingToStandingTransform[4] = 0.0f;
 110   state.sittingToStandingTransform[5] = 1.0f;
 111   state.sittingToStandingTransform[6] = 0.0f;
 112   state.sittingToStandingTransform[7] = 0.0f;
 113
 114   state.sittingToStandingTransform[8] = 0.0f;
 115   state.sittingToStandingTransform[9] = 0.0f;
 116   state.sittingToStandingTransform[10] = 1.0f;
 117   state.sittingToStandingTransform[11] = 0.0f;
 118
 119   state.sittingToStandingTransform[12] = 0.0f;
 120   state.sittingToStandingTransform[13] = 0.75f;
 121   state.sittingToStandingTransform[14] = 0.0f;
 122   state.sittingToStandingTransform[15] = 1.0f;
 123
 124   VRHMDSensorState& sensorState = SensorState();
 125   gfx::Quaternion rot;
 126   sensorState.flags |= VRDisplayCapabilityFlags::Cap_Orientation;
 127   sensorState.pose.orientation[0] = rot.x;
 128   sensorState.pose.orientation[1] = rot.y;
 129   sensorState.pose.orientation[2] = rot.z;
 130   sensorState.pose.orientation[3] = rot.w;
 131   sensorState.pose.angularVelocity[0] = 0.0f;
 132   sensorState.pose.angularVelocity[1] = 0.0f;
 133   sensorState.pose.angularVelocity[2] = 0.0f;
 134
 135   sensorState.flags |= VRDisplayCapabilityFlags::Cap_Position;
 136   sensorState.pose.position[0] = 0.0f;
 137   sensorState.pose.position[1] = 0.0f;
 138   sensorState.pose.position[2] = 0.0f;
 139   sensorState.pose.linearVelocity[0] = 0.0f;
 140   sensorState.pose.linearVelocity[1] = 0.0f;
 141   sensorState.pose.linearVelocity[2] = 0.0f;
 142 }
 143
 144 void VRMockDisplay::SetConnected(bool aConnected) {
 145   DisplayState().isConnected = aConnected;
 146 }
 147 bool VRMockDisplay::Connected() const { return DisplayState().isConnected; }
 148
 149 void VRMockDisplay::SetMounted(bool aMounted) {
 150   DisplayState().isMounted = aMounted;
 151 }
 152
 153 bool VRMockDisplay::Mounted() const { return DisplayState().isMounted; }
 154
 155 void VRMockDisplay::SetCapFlag(VRDisplayCapabilityFlags aFlag, bool aEnabled) {
 156   if (aEnabled) {
 157     DisplayState().capabilityFlags |= aFlag;
 158   } else {
 159     DisplayState().capabilityFlags &= ~aFlag;
 160   }
 161 }
 162 bool VRMockDisplay::GetCapFlag(VRDisplayCapabilityFlags aFlag) const {
 163   return ((DisplayState().capabilityFlags & aFlag) !=
 164           VRDisplayCapabilityFlags::Cap_None);
 165 }
 166
 167 void VRMockDisplay::SetCapPosition(bool aEnabled) {
 168   SetCapFlag(VRDisplayCapabilityFlags::Cap_Position, aEnabled);
 169 }
 170
 171 void VRMockDisplay::SetCapOrientation(bool aEnabled) {
 172   SetCapFlag(VRDisplayCapabilityFlags::Cap_Orientation, aEnabled);
 173 }
 174
 175 void VRMockDisplay::SetCapPresent(bool aEnabled) {
 176   SetCapFlag(VRDisplayCapabilityFlags::Cap_Present, aEnabled);
 177 }
 178
 179 void VRMockDisplay::SetCapExternal(bool aEnabled) {
 180   SetCapFlag(VRDisplayCapabilityFlags::Cap_External, aEnabled);
 181 }
 182
 183 void VRMockDisplay::SetCapAngularAcceleration(bool aEnabled) {
 184   SetCapFlag(VRDisplayCapabilityFlags::Cap_AngularAcceleration, aEnabled);
 185 }
 186
 187 void VRMockDisplay::SetCapLinearAcceleration(bool aEnabled) {
 188   SetCapFlag(VRDisplayCapabilityFlags::Cap_LinearAcceleration, aEnabled);
 189 }
 190
 191 void VRMockDisplay::SetCapStageParameters(bool aEnabled) {
 192   SetCapFlag(VRDisplayCapabilityFlags::Cap_StageParameters, aEnabled);
 193 }
 194
 195 void VRMockDisplay::SetCapMountDetection(bool aEnabled) {
 196   SetCapFlag(VRDisplayCapabilityFlags::Cap_MountDetection, aEnabled);
 197 }
 198
 199 void VRMockDisplay::SetCapPositionEmulated(bool aEnabled) {
 200   SetCapFlag(VRDisplayCapabilityFlags::Cap_PositionEmulated, aEnabled);
 201 }
 202
 203 void VRMockDisplay::SetEyeFOV(VREye aEye, double aUpDegree, double aRightDegree,
 204                               double aDownDegree, double aLeftDegree) {
 205   gfx::VRDisplayState::Eye eye = aEye == VREye::Left
 206                                      ? gfx::VRDisplayState::Eye_Left
 207                                      : gfx::VRDisplayState::Eye_Right;
 208   VRDisplayState& state = DisplayState();
 209   state.eyeFOV[eye] =
 210       gfx::VRFieldOfView(aUpDegree, aRightDegree, aDownDegree, aLeftDegree);
 211 }
 212
 213 void VRMockDisplay::SetEyeOffset(VREye aEye, double aOffsetX, double aOffsetY,
 214                                  double aOffsetZ) {
 215   gfx::VRDisplayState::Eye eye = aEye == VREye::Left
 216                                      ? gfx::VRDisplayState::Eye_Left
 217                                      : gfx::VRDisplayState::Eye_Right;
 218   VRDisplayState& state = DisplayState();
 219   state.eyeTranslation[eye].x = (float)aOffsetX;
 220   state.eyeTranslation[eye].y = (float)aOffsetY;
 221   state.eyeTranslation[eye].z = (float)aOffsetZ;
 222 }
 223
 224 bool VRMockDisplay::CapPosition() const {
 225   return GetCapFlag(VRDisplayCapabilityFlags::Cap_Position);
 226 }
 227
 228 bool VRMockDisplay::CapOrientation() const {
 229   return GetCapFlag(VRDisplayCapabilityFlags::Cap_Orientation);
 230 }
 231
 232 bool VRMockDisplay::CapPresent() const {
 233   return GetCapFlag(VRDisplayCapabilityFlags::Cap_Present);
 234 }
 235
 236 bool VRMockDisplay::CapExternal() const {
 237   return GetCapFlag(VRDisplayCapabilityFlags::Cap_External);
 238 }
 239
 240 bool VRMockDisplay::CapAngularAcceleration() const {
 241   return GetCapFlag(VRDisplayCapabilityFlags::Cap_AngularAcceleration);
 242 }
 243
 244 bool VRMockDisplay::CapLinearAcceleration() const {
 245   return GetCapFlag(VRDisplayCapabilityFlags::Cap_LinearAcceleration);
 246 }
 247
 248 bool VRMockDisplay::CapStageParameters() const {
 249   return GetCapFlag(VRDisplayCapabilityFlags::Cap_StageParameters);
 250 }
 251
 252 bool VRMockDisplay::CapMountDetection() const {
 253   return GetCapFlag(VRDisplayCapabilityFlags::Cap_MountDetection);
 254 }
 255
 256 bool VRMockDisplay::CapPositionEmulated() const {
 257   return GetCapFlag(VRDisplayCapabilityFlags::Cap_PositionEmulated);
 258 }
 259
 260 void VRMockDisplay::SetEyeResolution(uint32_t aRenderWidth,
 261                                      uint32_t aRenderHeight) {
 262   DisplayState().eyeResolution.width = aRenderWidth;
 263   DisplayState().eyeResolution.height = aRenderHeight;
 264 }
 265
 266 void VRMockDisplay::SetStageSize(double aWidth, double aHeight) {
 267   VRDisplayState& displayState = DisplayState();
 268   displayState.stageSize.width = (float)aWidth;
 269   displayState.stageSize.height = (float)aHeight;
 270 }
 271
 272 void VRMockDisplay::SetSittingToStandingTransform(
 273     const Float32Array& aTransform, ErrorResult& aRv) {
 274   Unused << ReadFloat32Array(&DisplayState().sittingToStandingTransform,
 275                              aTransform, aRv);
 276 }
 277
 278 void VRMockDisplay::SetPose(const Nullable<Float32Array>& aPosition,
 279                             const Nullable<Float32Array>& aLinearVelocity,
 280                             const Nullable<Float32Array>& aLinearAcceleration,
 281                             const Nullable<Float32Array>& aOrientation,
 282                             const Nullable<Float32Array>& aAngularVelocity,
 283                             const Nullable<Float32Array>& aAngularAcceleration,
 284                             ErrorResult& aRv) {
 285   VRHMDSensorState& sensorState = mVRServiceTest->SystemState().sensorState;
 286   sensorState.Clear();
 287   sensorState.flags = VRDisplayCapabilityFlags::Cap_None;
 288   // sensorState.timestamp will be set automatically during
 289   // puppet script execution
 290
 291   if (!aOrientation.IsNull()) {
 292     if (!ReadFloat32Array(&sensorState.pose.orientation, aOrientation.Value(),
 293                           aRv)) {
 294       return;
 295     }
 296     sensorState.flags |= VRDisplayCapabilityFlags::Cap_Orientation;
 297   }
 298   if (!aAngularVelocity.IsNull()) {
 299     if (!ReadFloat32Array(&sensorState.pose.angularVelocity,
 300                           aAngularVelocity.Value(), aRv)) {
 301       return;
 302     }
 303     sensorState.flags |= VRDisplayCapabilityFlags::Cap_AngularAcceleration;
 304   }
 305   if (!aAngularAcceleration.IsNull()) {
 306     if (!ReadFloat32Array(&sensorState.pose.angularAcceleration,
 307                           aAngularAcceleration.Value(), aRv)) {
 308       return;
 309     }
 310     sensorState.flags |= VRDisplayCapabilityFlags::Cap_AngularAcceleration;
 311   }
 312   if (!aPosition.IsNull()) {
 313     if (!ReadFloat32Array(&sensorState.pose.position, aPosition.Value(), aRv)) {
 314       return;
 315     }
 316     sensorState.flags |= VRDisplayCapabilityFlags::Cap_Position;
 317   }
 318   if (!aLinearVelocity.IsNull()) {
 319     if (!ReadFloat32Array(&sensorState.pose.linearVelocity,
 320                           aLinearVelocity.Value(), aRv)) {
 321       return;
 322     }
 323     sensorState.flags |= VRDisplayCapabilityFlags::Cap_LinearAcceleration;
 324   }
 325   if (!aLinearAcceleration.IsNull()) {
 326     if (!ReadFloat32Array(&sensorState.pose.linearAcceleration,
 327                           aLinearAcceleration.Value(), aRv)) {
 328       return;
 329     }
 330     sensorState.flags |= VRDisplayCapabilityFlags::Cap_LinearAcceleration;
 331   }
 332 }
 333
 334 NS_IMPL_CYCLE_COLLECTION_INHERITED(VRMockController, DOMEventTargetHelper,
 335                                    mVRServiceTest)
 336
 337 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(VRMockController,
 338                                                DOMEventTargetHelper)
 339
 340 VRMockController::VRMockController(VRServiceTest* aVRServiceTest,
 341                                    uint32_t aControllerIdx)
 342     : DOMEventTargetHelper(aVRServiceTest->GetOwnerGlobal()),
 343       mVRServiceTest(aVRServiceTest),
 344       mControllerIdx(aControllerIdx) {
 345   MOZ_ASSERT(aControllerIdx < kVRControllerMaxCount);
 346 }
 347
 348 JSObject* VRMockController::WrapObject(JSContext* aCx,
 349                                        JS::Handle<JSObject*> aGivenProto) {
 350   return VRMockController_Binding::Wrap(aCx, this, aGivenProto);
 351 }
 352
 353 VRControllerState& VRMockController::ControllerState() const {
 354   return mVRServiceTest->SystemState().controllerState[mControllerIdx];
 355 }
 356
 357 void VRMockController::Create() {
 358   // Initialize with a 6dof, left-handed gamepad with one haptic actuator
 359   // Tests are expected to modify the controller before it is sent to the
 360   // puppet.
 361   Clear();
 362   VRControllerState& state = ControllerState();
 363   strncpy(state.controllerName.data(), "Puppet Gamepad",
 364           kVRControllerNameMaxLen);
 365   state.hand = GamepadHand::Left;
 366   state.flags = GamepadCapabilityFlags::Cap_Position |
 367                 GamepadCapabilityFlags::Cap_Orientation;
 368   state.numButtons = 1;
 369   state.numHaptics = 1;
 370   state.triggerValue[0] = 0.0f;
 371 }
 372
 373 void VRMockController::Clear() {
 374   mVRServiceTest->ClearController(mControllerIdx);
 375 }
 376
 377 void VRMockController::SetCapFlag(GamepadCapabilityFlags aFlag, bool aEnabled) {
 378   if (aEnabled) {
 379     ControllerState().flags |= aFlag;
 380   } else {
 381     ControllerState().flags &= ~aFlag;
 382   }
 383 }
 384 bool VRMockController::GetCapFlag(GamepadCapabilityFlags aFlag) const {
 385   return (ControllerState().flags & aFlag) != GamepadCapabilityFlags::Cap_None;
 386 }
 387
 388 void VRMockController::SetHand(GamepadHand aHand) {
 389   ControllerState().hand = aHand;
 390 }
 391
 392 GamepadHand VRMockController::Hand() const { return ControllerState().hand; }
 393
 394 void VRMockController::SetCapPosition(bool aEnabled) {
 395   SetCapFlag(GamepadCapabilityFlags::Cap_Position, aEnabled);
 396 }
 397
 398 bool VRMockController::CapPosition() const {
 399   return GetCapFlag(GamepadCapabilityFlags::Cap_Position);
 400 }
 401
 402 void VRMockController::SetCapOrientation(bool aEnabled) {
 403   SetCapFlag(GamepadCapabilityFlags::Cap_Orientation, aEnabled);
 404 }
 405
 406 bool VRMockController::CapOrientation() const {
 407   return GetCapFlag(GamepadCapabilityFlags::Cap_Orientation);
 408 }
 409
 410 void VRMockController::SetCapAngularAcceleration(bool aEnabled) {
 411   SetCapFlag(GamepadCapabilityFlags::Cap_AngularAcceleration, aEnabled);
 412 }
 413
 414 bool VRMockController::CapAngularAcceleration() const {
 415   return GetCapFlag(GamepadCapabilityFlags::Cap_AngularAcceleration);
 416 }
 417
 418 void VRMockController::SetCapLinearAcceleration(bool aEnabled) {
 419   SetCapFlag(GamepadCapabilityFlags::Cap_LinearAcceleration, aEnabled);
 420 }
 421
 422 bool VRMockController::CapLinearAcceleration() const {
 423   return GetCapFlag(GamepadCapabilityFlags::Cap_LinearAcceleration);
 424 }
 425
 426 void VRMockController::SetAxisCount(uint32_t aCount) {
 427   MOZ_ASSERT(aCount <= kVRControllerMaxAxis);
 428   ControllerState().numAxes = aCount;
 429 }
 430
 431 uint32_t VRMockController::AxisCount() const {
 432   return ControllerState().numAxes;
 433 }
 434
 435 void VRMockController::SetButtonCount(uint32_t aCount) {
 436   MOZ_ASSERT(aCount <= kVRControllerMaxButtons);
 437   ControllerState().numButtons = aCount;
 438 }
 439
 440 uint32_t VRMockController::ButtonCount() const {
 441   return ControllerState().numButtons;
 442 }
 443
 444 void VRMockController::SetHapticCount(uint32_t aCount) {
 445   ControllerState().numHaptics = aCount;
 446 }
 447
 448 uint32_t VRMockController::HapticCount() const {
 449   return ControllerState().numHaptics;
 450 }
 451
 452 void VRMockController::SetButtonPressed(uint32_t aButtonIdx, bool aPressed) {
 453   MOZ_ASSERT(aButtonIdx < kVRControllerMaxButtons);
 454   if (aPressed) {
 455     ControllerState().buttonPressed |= (1 << aButtonIdx);
 456   } else {
 457     ControllerState().buttonPressed &= ~(1 << aButtonIdx);
 458   }
 459 }
 460
 461 void VRMockController::SetButtonTouched(uint32_t aButtonIdx, bool aTouched) {
 462   MOZ_ASSERT(aButtonIdx < kVRControllerMaxButtons);
 463   if (aTouched) {
 464     ControllerState().buttonTouched |= (1 << aButtonIdx);
 465   } else {
 466     ControllerState().buttonTouched &= ~(1 << aButtonIdx);
 467   }
 468 }
 469
 470 void VRMockController::SetButtonTrigger(uint32_t aButtonIdx, double aTrigger) {
 471   MOZ_ASSERT(aButtonIdx < kVRControllerMaxButtons);
 472
 473   ControllerState().triggerValue[aButtonIdx] = (float)aTrigger;
 474 }
 475
 476 void VRMockController::SetAxisValue(uint32_t aAxisIdx, double aValue) {
 477   MOZ_ASSERT(aAxisIdx < kVRControllerMaxAxis);
 478   ControllerState().axisValue[aAxisIdx] = (float)aValue;
 479 }
 480
 481 void VRMockController::SetPose(
 482     const Nullable<Float32Array>& aPosition,
 483     const Nullable<Float32Array>& aLinearVelocity,
 484     const Nullable<Float32Array>& aLinearAcceleration,
 485     const Nullable<Float32Array>& aOrientation,
 486     const Nullable<Float32Array>& aAngularVelocity,
 487     const Nullable<Float32Array>& aAngularAcceleration, ErrorResult& aRv) {
 488   VRControllerState& controllerState = ControllerState();
 489   controllerState.flags = GamepadCapabilityFlags::Cap_None;
 490
 491   if (!aOrientation.IsNull()) {
 492     if (!ReadFloat32Array(&controllerState.pose.orientation,
 493                           aOrientation.Value(), aRv)) {
 494       return;
 495     }
 496     controllerState.flags |= GamepadCapabilityFlags::Cap_Orientation;
 497   }
 498   if (!aAngularVelocity.IsNull()) {
 499     if (!ReadFloat32Array(&controllerState.pose.angularVelocity,
 500                           aAngularVelocity.Value(), aRv)) {
 501       return;
 502     }
 503     controllerState.flags |= GamepadCapabilityFlags::Cap_AngularAcceleration;
 504   }
 505   if (!aAngularAcceleration.IsNull()) {
 506     if (!ReadFloat32Array(&controllerState.pose.angularAcceleration,
 507                           aAngularAcceleration.Value(), aRv)) {
 508       return;
 509     }
 510     controllerState.flags |= GamepadCapabilityFlags::Cap_AngularAcceleration;
 511   }
 512   if (!aPosition.IsNull()) {
 513     if (!ReadFloat32Array(&controllerState.pose.position, aPosition.Value(),
 514                           aRv)) {
 515       return;
 516     }
 517     controllerState.flags |= GamepadCapabilityFlags::Cap_Position;
 518   }
 519   if (!aLinearVelocity.IsNull()) {
 520     if (!ReadFloat32Array(&controllerState.pose.linearVelocity,
 521                           aLinearVelocity.Value(), aRv)) {
 522       return;
 523     }
 524     controllerState.flags |= GamepadCapabilityFlags::Cap_LinearAcceleration;
 525   }
 526   if (!aLinearAcceleration.IsNull()) {
 527     if (!ReadFloat32Array(&controllerState.pose.linearAcceleration,
 528                           aLinearAcceleration.Value(), aRv)) {
 529       return;
 530     }
 531     controllerState.flags |= GamepadCapabilityFlags::Cap_LinearAcceleration;
 532   }
 533 }
 534
 535 NS_IMPL_CYCLE_COLLECTION_INHERITED(VRServiceTest, DOMEventTargetHelper,
 536                                    mDisplay, mControllers, mWindow)
 537
 538 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(VRServiceTest,
 539                                                DOMEventTargetHelper)
 540
 541 JSObject* VRServiceTest::WrapObject(JSContext* aCx,
 542                                     JS::Handle<JSObject*> aGivenProto) {
 543   return VRServiceTest_Binding::Wrap(aCx, this, aGivenProto);
 544 }
 545
 546 // static
 547 already_AddRefed<VRServiceTest> VRServiceTest::CreateTestService(
 548     nsPIDOMWindowInner* aWindow) {
 549   MOZ_ASSERT(aWindow);
 550   RefPtr<VRServiceTest> service = new VRServiceTest(aWindow);
 551   return service.forget();
 552 }
 553
 554 VRServiceTest::VRServiceTest(nsPIDOMWindowInner* aWindow)
 555     : mWindow(aWindow), mPendingState{}, mEncodedState{}, mShuttingDown(false) {
 556   mDisplay = new VRMockDisplay(this);
 557   for (int i = 0; i < kVRControllerMaxCount; i++) {
 558     mControllers.AppendElement(new VRMockController(this, i));
 559   }
 560   ClearAll();
 561 }
 562
 563 gfx::VRSystemState& VRServiceTest::SystemState() { return mPendingState; }
 564
 565 VRMockDisplay* VRServiceTest::GetVRDisplay() { return mDisplay; }
 566
 567 VRMockController* VRServiceTest::GetVRController(uint32_t aControllerIdx,
 568                                                  ErrorResult& aRv) {
 569   if (aControllerIdx >= kVRControllerMaxCount) {
 570     aRv.Throw(NS_ERROR_INVALID_ARG);
 571     return nullptr;
 572   }
 573   return mControllers[aControllerIdx];
 574 }
 575
 576 void VRServiceTest::Shutdown() {
 577   MOZ_ASSERT(!mShuttingDown);
 578   mShuttingDown = true;
 579   mWindow = nullptr;
 580 }
 581
 582 void VRServiceTest::AddCommand(uint64_t aCommand) {
 583   EncodeData();
 584   mCommandBuffer.AppendElement(aCommand);
 585 }
 586
 587 void VRServiceTest::End() {
 588   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_End);
 589 }
 590
 591 void VRServiceTest::ClearAll() {
 592   memset(&mPendingState, 0, sizeof(VRSystemState));
 593   memset(&mEncodedState, 0, sizeof(VRSystemState));
 594   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_ClearAll);
 595 }
 596
 597 void VRServiceTest::ClearController(uint32_t aControllerIdx) {
 598   MOZ_ASSERT(aControllerIdx < kVRControllerMaxCount);
 599   mPendingState.controllerState[aControllerIdx].Clear();
 600   mEncodedState.controllerState[aControllerIdx].Clear();
 601   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_ClearController |
 602              (uint64_t)aControllerIdx);
 603 }
 604
 605 void VRServiceTest::Timeout(uint32_t aDuration) {
 606   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_Timeout |
 607              (uint64_t)aDuration);
 608 }
 609
 610 void VRServiceTest::Wait(uint32_t aDuration) {
 611   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_Wait | (uint64_t)aDuration);
 612 }
 613
 614 void VRServiceTest::WaitHapticIntensity(uint32_t aControllerIdx,
 615                                         uint32_t aHapticIdx, double aIntensity,
 616                                         ErrorResult& aRv) {
 617   if (aControllerIdx >= kVRControllerMaxCount) {
 618     aRv.Throw(NS_ERROR_INVALID_ARG);
 619     return;
 620   }
 621   if (aHapticIdx >= kVRHapticsMaxCount) {
 622     aRv.Throw(NS_ERROR_INVALID_ARG);
 623     return;
 624   }
 625   // convert to 16.16 fixed point.  This must match conversion in
 626   // VRPuppetCommandBuffer::RunCommand
 627   uint64_t iIntensity = round((float)aIntensity * (1 << 16));
 628   if (iIntensity > 0xffffffff) {
 629     iIntensity = 0xffffffff;
 630   }
 631   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_WaitHapticIntensity |
 632              ((uint64_t)aControllerIdx << 40) | ((uint64_t)aHapticIdx << 32) |
 633              iIntensity);
 634 }
 635
 636 void VRServiceTest::WaitSubmit() {
 637   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_WaitSubmit);
 638 }
 639
 640 void VRServiceTest::WaitPresentationStart() {
 641   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_WaitPresentationStart);
 642 }
 643 void VRServiceTest::WaitPresentationEnd() {
 644   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_WaitPresentationEnd);
 645 }
 646
 647 void VRServiceTest::EncodeData() {
 648   VRPuppetCommandBuffer::EncodeStruct(
 649       mCommandBuffer, (uint8_t*)&mPendingState.displayState,
 650       (uint8_t*)&mEncodedState.displayState, sizeof(VRDisplayState),
 651       VRPuppet_Command::VRPuppet_UpdateDisplay);
 652   VRPuppetCommandBuffer::EncodeStruct(
 653       mCommandBuffer, (uint8_t*)&mPendingState.sensorState,
 654       (uint8_t*)&mEncodedState.sensorState, sizeof(VRHMDSensorState),
 655       VRPuppet_Command::VRPuppet_UpdateSensor);
 656   VRPuppetCommandBuffer::EncodeStruct(
 657       mCommandBuffer, (uint8_t*)&mPendingState.controllerState,
 658       (uint8_t*)&mEncodedState.controllerState,
 659       sizeof(VRControllerState) * kVRControllerMaxCount,
 660       VRPuppet_Command::VRPuppet_UpdateControllers);
 661 }
 662
 663 void VRServiceTest::CaptureFrame() {
 664   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_CaptureFrame);
 665 }
 666
 667 void VRServiceTest::AcknowledgeFrame() {
 668   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_AcknowledgeFrame);
 669 }
 670
 671 void VRServiceTest::RejectFrame() {
 672   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_RejectFrame);
 673 }
 674
 675 void VRServiceTest::StartTimer() {
 676   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_StartTimer);
 677 }
 678
 679 void VRServiceTest::StopTimer() {
 680   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_StopTimer);
 681 }
 682
 683 void VRServiceTest::Commit() {
 684   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_Commit);
 685 }
 686
 687 already_AddRefed<Promise> VRServiceTest::Run(ErrorResult& aRv) {
 688   if (mShuttingDown) {
 689     return nullptr;
 690   }
 691
 692   AddCommand((uint64_t)VRPuppet_Command::VRPuppet_End);
 693
 694   RefPtr<dom::Promise> runPuppetPromise =
 695       Promise::Create(mWindow->AsGlobal(), aRv);
 696   if (NS_WARN_IF(aRv.Failed())) {
 697     return nullptr;
 698   }
 699
 700   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
 701   vm->RunPuppet(mCommandBuffer, runPuppetPromise, aRv);
 702   if (NS_WARN_IF(aRv.Failed())) {
 703     return nullptr;
 704   }
 705
 706   mCommandBuffer.Clear();
 707
 708   return runPuppetPromise.forget();
 709 }
 710
 711 already_AddRefed<Promise> VRServiceTest::Reset(ErrorResult& aRv) {
 712   if (mShuttingDown) {
 713     return nullptr;
 714   }
 715
 716   RefPtr<dom::Promise> resetPuppetPromise =
 717       Promise::Create(mWindow->AsGlobal(), aRv);
 718   if (NS_WARN_IF(aRv.Failed())) {
 719     return nullptr;
 720   }
 721
 722   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
 723   vm->ResetPuppet(resetPuppetPromise, aRv);
 724   if (NS_WARN_IF(aRv.Failed())) {
 725     return nullptr;
 726   }
 727
 728   memset(&mPendingState, 0, sizeof(VRSystemState));
 729   memset(&mEncodedState, 0, sizeof(VRSystemState));
 730   mCommandBuffer.Clear();
 731
 732   return resetPuppetPromise.forget();
 733 }
 734
 735 }  // namespace dom
 736 }  // namespace mozilla