--- a/gfx/vr/VRManager.cpp
+++ b/gfx/vr/VRManager.cpp
@@ -456,39 +456,38 @@ VRManager::NotifyGamepadChange(uint32_t
for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
Unused << iter.Get()->GetKey()->SendGamepadUpdate(e);
}
}
void
VRManager::VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
- double aIntensity, double aDuration, uint32_t aPromiseID)
+ double aIntensity, double aDuration,
+ const VRManagerPromise& aPromise)
{
for (uint32_t i = 0; i < mManagers.Length(); ++i) {
mManagers[i]->VibrateHaptic(aControllerIdx, aHapticIndex,
- aIntensity, aDuration, aPromiseID);
+ aIntensity, aDuration, aPromise);
}
}
void
VRManager::StopVibrateHaptic(uint32_t aControllerIdx)
{
for (const auto& manager: mManagers) {
manager->StopVibrateHaptic(aControllerIdx);
}
}
void
-VRManager::NotifyVibrateHapticCompleted(uint32_t aPromiseID)
+VRManager::NotifyVibrateHapticCompleted(const VRManagerPromise& aPromise)
{
- for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
- Unused << iter.Get()->GetKey()->SendReplyGamepadVibrateHaptic(aPromiseID);
- }
+ aPromise.mParent->SendReplyGamepadVibrateHaptic(aPromise.mPromiseID);
}
void
VRManager::DispatchSubmitFrameResult(uint32_t aDisplayID, const VRSubmitFrameResultInfo& aResult)
{
for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
Unused << iter.Get()->GetKey()->SendDispatchSubmitFrameResult(aDisplayID, aResult);
}
--- a/gfx/vr/VRManager.h
+++ b/gfx/vr/VRManager.h
@@ -43,19 +43,19 @@ public:
void RemoveControllers();
template<class T> void NotifyGamepadChange(uint32_t aIndex, const T& aInfo);
RefPtr<gfx::VRDisplayHost> GetDisplay(const uint32_t& aDisplayID);
void GetVRDisplayInfo(nsTArray<VRDisplayInfo>& aDisplayInfo);
RefPtr<gfx::VRControllerHost> GetController(const uint32_t& aControllerID);
void GetVRControllerInfo(nsTArray<VRControllerInfo>& aControllerInfo);
void CreateVRTestSystem();
void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
- double aIntensity, double aDuration, uint32_t aPromiseID);
+ double aIntensity, double aDuration, const VRManagerPromise& aPromise);
void StopVibrateHaptic(uint32_t aControllerIdx);
- void NotifyVibrateHapticCompleted(uint32_t aPromiseID);
+ void NotifyVibrateHapticCompleted(const VRManagerPromise& aPromise);
void DispatchSubmitFrameResult(uint32_t aDisplayID, const VRSubmitFrameResultInfo& aResult);
protected:
VRManager();
~VRManager();
private:
--- a/gfx/vr/gfxVR.h
+++ b/gfx/vr/gfxVR.h
@@ -25,16 +25,17 @@ namespace dom {
enum class GamepadMappingType : uint8_t;
enum class GamepadHand : uint8_t;
struct GamepadPoseState;
}
namespace gfx {
class VRLayerParent;
class VRDisplayHost;
class VRControllerHost;
+class VRManagerPromise;
enum class VRDeviceType : uint16_t {
Oculus,
OpenVR,
OSVR,
GVR,
Puppet,
NumVRDeviceTypes
@@ -349,17 +350,17 @@ public:
virtual void Shutdown() = 0;
virtual bool GetHMDs(nsTArray<RefPtr<VRDisplayHost>>& aHMDResult) = 0;
virtual bool GetIsPresenting() = 0;
virtual void HandleInput() = 0;
virtual void GetControllers(nsTArray<RefPtr<VRControllerHost>>& aControllerResult) = 0;
virtual void ScanForControllers() = 0;
virtual void RemoveControllers() = 0;
virtual void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
- double aIntensity, double aDuration, uint32_t aPromiseID) = 0;
+ double aIntensity, double aDuration, const VRManagerPromise& aPromise) = 0;
virtual void StopVibrateHaptic(uint32_t aControllerIdx) = 0;
void NewButtonEvent(uint32_t aIndex, uint32_t aButton, bool aPressed, bool aTouched,
double aValue);
void NewAxisMove(uint32_t aIndex, uint32_t aAxis, double aValue);
void NewPoseState(uint32_t aIndex, const dom::GamepadPoseState& aPose);
void NewHandChangeEvent(uint32_t aIndex, const dom::GamepadHand aHand);
void AddGamepad(const VRControllerInfo& controllerInfo);
void RemoveGamepad(uint32_t aIndex);
--- a/gfx/vr/gfxVRGVR.cpp
+++ b/gfx/vr/gfxVRGVR.cpp
@@ -770,17 +770,17 @@ VRSystemManagerGVR::RemoveControllers()
}
}
void
VRSystemManagerGVR::VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
}
void
VRSystemManagerGVR::StopVibrateHaptic(uint32_t aControllerIdx)
{
--- a/gfx/vr/gfxVRGVR.h
+++ b/gfx/vr/gfxVRGVR.h
@@ -111,17 +111,17 @@ public:
void GetControllers(nsTArray<RefPtr<VRControllerHost>>&
aControllerResult) override;
void ScanForControllers() override;
void RemoveControllers() override;
void VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID) override;
+ const VRManagerPromise& aPromise) override;
void StopVibrateHaptic(uint32_t aControllerIdx) override;
protected:
VRSystemManagerGVR();
virtual ~VRSystemManagerGVR();
private:
RefPtr<impl::VRDisplayGVR> mGVRHMD;
--- a/gfx/vr/gfxVROSVR.cpp
+++ b/gfx/vr/gfxVROSVR.cpp
@@ -585,17 +585,17 @@ VRSystemManagerOSVR::HandleInput()
{
}
void
VRSystemManagerOSVR::VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
}
void
VRSystemManagerOSVR::StopVibrateHaptic(uint32_t aControllerIdx)
{
}
--- a/gfx/vr/gfxVROSVR.h
+++ b/gfx/vr/gfxVROSVR.h
@@ -83,17 +83,18 @@ public:
virtual bool GetHMDs(nsTArray<RefPtr<VRDisplayHost>>& aHMDResult) override;
virtual bool GetIsPresenting() override;
virtual void HandleInput() override;
virtual void GetControllers(nsTArray<RefPtr<VRControllerHost>>&
aControllerResult) override;
virtual void ScanForControllers() override;
virtual void RemoveControllers() override;
virtual void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
- double aIntensity, double aDuration, uint32_t aPromiseID) override;
+ double aIntensity, double aDuration,
+ const VRManagerPromise& aPromise) override;
virtual void StopVibrateHaptic(uint32_t aControllerIdx) override;
protected:
VRSystemManagerOSVR()
: mOSVRInitialized(false)
, mClientContextInitialized(false)
, mDisplayConfigInitialized(false)
, mInterfaceInitialized(false)
--- a/gfx/vr/gfxVROculus.cpp
+++ b/gfx/vr/gfxVROculus.cpp
@@ -24,16 +24,17 @@
#include "mozilla/gfx/Quaternion.h"
#include <d3d11.h>
#include "CompositorD3D11.h"
#include "TextureD3D11.h"
#include "gfxVROculus.h"
+#include "VRManagerParent.h"
#include "VRThread.h"
#include "mozilla/dom/GamepadEventTypes.h"
#include "mozilla/dom/GamepadBinding.h"
#include "mozilla/Telemetry.h"
/** XXX The DX11 objects and quad blitting could be encapsulated
* into a separate object if either Oculus starts supporting
@@ -1338,29 +1339,29 @@ VRControllerOculus::~VRControllerOculus(
}
void
VRControllerOculus::UpdateVibrateHaptic(ovrSession aSession,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
uint64_t aVibrateIndex,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
// UpdateVibrateHaptic() only can be called by mVibrateThread
MOZ_ASSERT(mVibrateThread == NS_GetCurrentThread());
// It has been interrupted by loss focus.
if (mIsVibrateStopped) {
- VibrateHapticComplete(aSession, aPromiseID, true);
+ VibrateHapticComplete(aSession, aPromise, true);
return;
}
// Avoid the previous vibrate event to override the new one.
if (mVibrateIndex != aVibrateIndex) {
- VibrateHapticComplete(aSession, aPromiseID, false);
+ VibrateHapticComplete(aSession, aPromise, false);
return;
}
const double duration = (aIntensity == 0) ? 0 : aDuration;
// Vibration amplitude in the [0.0, 1.0] range.
const float amplitude = aIntensity > 1.0 ? 1.0 : aIntensity;
// Vibration is enabled by specifying the frequency.
// Specifying 0.0f will disable the vibration, 0.5f will vibrate at 160Hz,
@@ -1395,29 +1396,30 @@ VRControllerOculus::UpdateVibrateHaptic(
const double kVibrateRate = 2450.0;
const double remainingTime = (duration > kVibrateRate)
? (duration - kVibrateRate) : duration;
if (remainingTime) {
MOZ_ASSERT(mVibrateThread);
RefPtr<Runnable> runnable =
- NewRunnableMethod<ovrSession, uint32_t, double, double, uint64_t, uint32_t>(
- "VRControllerOculus::UpdateVibrateHaptic",
- this, &VRControllerOculus::UpdateVibrateHaptic, aSession,
- aHapticIndex, aIntensity, (duration > kVibrateRate) ? remainingTime : 0, aVibrateIndex, aPromiseID);
+ NewRunnableMethod<ovrSession, uint32_t, double, double, uint64_t,
+ StoreCopyPassByConstLRef<VRManagerPromise>>(
+ "VRControllerOculus::UpdateVibrateHaptic",
+ this, &VRControllerOculus::UpdateVibrateHaptic, aSession,
+ aHapticIndex, aIntensity, (duration > kVibrateRate) ? remainingTime : 0, aVibrateIndex, aPromise);
NS_DelayedDispatchToCurrentThread(runnable.forget(),
(duration > kVibrateRate) ? kVibrateRate : remainingTime);
} else {
- VibrateHapticComplete(aSession, aPromiseID, true);
+ VibrateHapticComplete(aSession, aPromise, true);
}
}
void
-VRControllerOculus::VibrateHapticComplete(ovrSession aSession, uint32_t aPromiseID,
+VRControllerOculus::VibrateHapticComplete(ovrSession aSession, const VRManagerPromise& aPromise,
bool aStop)
{
if (aStop) {
ovrControllerType hand;
switch (GetHand()) {
case GamepadHand::Left:
hand = ovrControllerType::ovrControllerType_LTouch;
@@ -1435,45 +1437,47 @@ VRControllerOculus::VibrateHapticComplet
printf_stderr("%s Haptics skipped.\n",
GamepadHandValues::strings[uint32_t(GetHand())].value);
}
}
VRManager *vm = VRManager::Get();
MOZ_ASSERT(vm);
- VRListenerThreadHolder::Loop()->PostTask(NewRunnableMethod<uint32_t>(
- "VRManager::NotifyVibrateHapticCompleted",
- vm, &VRManager::NotifyVibrateHapticCompleted, aPromiseID));
+ VRListenerThreadHolder::Loop()->PostTask(
+ NewRunnableMethod<StoreCopyPassByConstLRef<VRManagerPromise>>(
+ "VRManager::NotifyVibrateHapticCompleted",
+ vm, &VRManager::NotifyVibrateHapticCompleted, aPromise));
}
void
VRControllerOculus::VibrateHaptic(ovrSession aSession,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
// Spinning up the haptics thread at the first haptics call.
if (!mVibrateThread) {
nsresult rv = NS_NewThread(getter_AddRefs(mVibrateThread));
MOZ_ASSERT(mVibrateThread);
if (NS_FAILED(rv)) {
MOZ_ASSERT(false, "Failed to create async thread.");
}
}
++mVibrateIndex;
mIsVibrateStopped = false;
RefPtr<Runnable> runnable =
- NewRunnableMethod<ovrSession, uint32_t, double, double, uint64_t, uint32_t>
- ("VRControllerOculus::UpdateVibrateHaptic",
+ NewRunnableMethod<ovrSession, uint32_t, double, double, uint64_t,
+ StoreCopyPassByConstLRef<VRManagerPromise>>(
+ "VRControllerOculus::UpdateVibrateHaptic",
this, &VRControllerOculus::UpdateVibrateHaptic, aSession,
- aHapticIndex, aIntensity, aDuration, mVibrateIndex, aPromiseID);
+ aHapticIndex, aIntensity, aDuration, mVibrateIndex, aPromise);
mVibrateThread->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
}
void
VRControllerOculus::StopVibrateHaptic()
{
mIsVibrateStopped = true;
}
@@ -1799,28 +1803,29 @@ VRSystemManagerOculus::HandlePoseTrackin
}
}
void
VRSystemManagerOculus::VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
// The session is available after VRDisplay is created
// at GetHMDs().
- if (!mSession || !mSession->IsTrackingReady()) {
+ if (!mSession || !mSession->IsTrackingReady() ||
+ (aControllerIdx >= mOculusController.Length())) {
return;
}
RefPtr<impl::VRControllerOculus> controller = mOculusController[aControllerIdx];
MOZ_ASSERT(controller);
- controller->VibrateHaptic(mSession->Get(), aHapticIndex, aIntensity, aDuration, aPromiseID);
+ controller->VibrateHaptic(mSession->Get(), aHapticIndex, aIntensity, aDuration, aPromise);
}
void
VRSystemManagerOculus::StopVibrateHaptic(uint32_t aControllerIdx)
{
// The session is available after VRDisplay is created
// at GetHMDs().
if (!mSession || !mSession->IsTrackingReady() ||
--- a/gfx/vr/gfxVROculus.h
+++ b/gfx/vr/gfxVROculus.h
@@ -140,30 +140,30 @@ public:
float GetIndexTrigger();
void SetIndexTrigger(float aValue);
float GetHandTrigger();
void SetHandTrigger(float aValue);
void VibrateHaptic(ovrSession aSession,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID);
+ const VRManagerPromise& aPromise);
void StopVibrateHaptic();
protected:
virtual ~VRControllerOculus();
private:
void UpdateVibrateHaptic(ovrSession aSession,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
uint64_t aVibrateIndex,
- uint32_t aPromiseID);
- void VibrateHapticComplete(ovrSession aSession, uint32_t aPromiseID, bool aStop);
+ const VRManagerPromise& aPromise);
+ void VibrateHapticComplete(ovrSession aSession, const VRManagerPromise& aPromise, bool aStop);
float mAxisMove[static_cast<uint32_t>(
OculusControllerAxisType::NumVRControllerAxisType)];
float mIndexTrigger;
float mHandTrigger;
nsCOMPtr<nsIThread> mVibrateThread;
Atomic<bool> mIsVibrateStopped;
};
@@ -179,17 +179,17 @@ public:
virtual bool GetHMDs(nsTArray<RefPtr<VRDisplayHost> >& aHMDResult) override;
virtual bool GetIsPresenting() override;
virtual void HandleInput() override;
virtual void GetControllers(nsTArray<RefPtr<VRControllerHost>>&
aControllerResult) override;
virtual void ScanForControllers() override;
virtual void RemoveControllers() override;
virtual void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
- double aIntensity, double aDuration, uint32_t aPromiseID) override;
+ double aIntensity, double aDuration, const VRManagerPromise& aPromise) override;
virtual void StopVibrateHaptic(uint32_t aControllerIdx) override;
protected:
VRSystemManagerOculus();
private:
void HandleButtonPress(uint32_t aControllerIdx,
uint32_t aButton,
--- a/gfx/vr/gfxVROpenVR.cpp
+++ b/gfx/vr/gfxVROpenVR.cpp
@@ -16,16 +16,17 @@
#ifdef XP_WIN
#include "CompositorD3D11.h"
#include "TextureD3D11.h"
#elif defined(XP_MACOSX)
#include "mozilla/gfx/MacIOSurface.h"
#endif
#include "gfxVROpenVR.h"
+#include "VRManagerParent.h"
#include "VRManager.h"
#include "VRThread.h"
#include "nsServiceManagerUtils.h"
#include "nsIScreenManager.h"
#include "mozilla/dom/GamepadEventTypes.h"
#include "mozilla/dom/GamepadBinding.h"
@@ -505,29 +506,29 @@ VRControllerOpenVR::SetHand(dom::Gamepad
}
void
VRControllerOpenVR::UpdateVibrateHaptic(::vr::IVRSystem* aVRSystem,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
uint64_t aVibrateIndex,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
// UpdateVibrateHaptic() only can be called by mVibrateThread
MOZ_ASSERT(mVibrateThread == NS_GetCurrentThread());
// It has been interrupted by loss focus.
if (mIsVibrateStopped) {
- VibrateHapticComplete(aPromiseID);
+ VibrateHapticComplete(aPromise);
return;
}
// Avoid the previous vibrate event to override the new one.
if (mVibrateIndex != aVibrateIndex) {
- VibrateHapticComplete(aPromiseID);
+ VibrateHapticComplete(aPromise);
return;
}
const double duration = (aIntensity == 0) ? 0 : aDuration;
// We expect OpenVR to vibrate for 5 ms, but we found it only response the
// commend ~ 3.9 ms. For duration time longer than 3.9 ms, we separate them
// to a loop of 3.9 ms for make users feel that is a continuous events.
const uint32_t microSec = (duration < 3.9 ? duration : 3.9) * 1000 * aIntensity;
@@ -536,61 +537,63 @@ VRControllerOpenVR::UpdateVibrateHaptic(
// In OpenVR spec, it mentions TriggerHapticPulse() may not trigger another haptic pulse
// on this controller and axis combination for 5ms.
const double kVibrateRate = 5.0;
if (duration >= kVibrateRate) {
MOZ_ASSERT(mVibrateThread);
RefPtr<Runnable> runnable =
- NewRunnableMethod<::vr::IVRSystem*, uint32_t, double, double, uint64_t, uint32_t>
- ("VRControllerOpenVR::UpdateVibrateHaptic",
- this, &VRControllerOpenVR::UpdateVibrateHaptic, aVRSystem,
- aHapticIndex, aIntensity, duration - kVibrateRate, aVibrateIndex, aPromiseID);
+ NewRunnableMethod<::vr::IVRSystem*, uint32_t, double, double, uint64_t,
+ StoreCopyPassByConstLRef<VRManagerPromise>>(
+ "VRControllerOpenVR::UpdateVibrateHaptic",
+ this, &VRControllerOpenVR::UpdateVibrateHaptic, aVRSystem,
+ aHapticIndex, aIntensity, duration - kVibrateRate, aVibrateIndex, aPromise);
NS_DelayedDispatchToCurrentThread(runnable.forget(), kVibrateRate);
} else {
// The pulse has completed
- VibrateHapticComplete(aPromiseID);
+ VibrateHapticComplete(aPromise);
}
}
void
-VRControllerOpenVR::VibrateHapticComplete(uint32_t aPromiseID)
+VRControllerOpenVR::VibrateHapticComplete(const VRManagerPromise& aPromise)
{
VRManager *vm = VRManager::Get();
-
- VRListenerThreadHolder::Loop()->PostTask(NewRunnableMethod<uint32_t>(
- "VRManager::NotifyVibrateHapticCompleted",
- vm, &VRManager::NotifyVibrateHapticCompleted, aPromiseID));
+ VRListenerThreadHolder::Loop()->PostTask(
+ NewRunnableMethod<StoreCopyPassByConstLRef<VRManagerPromise>>(
+ "VRManager::NotifyVibrateHapticCompleted",
+ vm, &VRManager::NotifyVibrateHapticCompleted, aPromise));
}
void
VRControllerOpenVR::VibrateHaptic(::vr::IVRSystem* aVRSystem,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
// Spinning up the haptics thread at the first haptics call.
if (!mVibrateThread) {
nsresult rv = NS_NewThread(getter_AddRefs(mVibrateThread));
MOZ_ASSERT(mVibrateThread);
if (NS_FAILED(rv)) {
MOZ_ASSERT(false, "Failed to create async thread.");
}
}
++mVibrateIndex;
mIsVibrateStopped = false;
RefPtr<Runnable> runnable =
- NewRunnableMethod<::vr::IVRSystem*, uint32_t, double, double, uint64_t, uint32_t>
- ("VRControllerOpenVR::UpdateVibrateHaptic",
- this, &VRControllerOpenVR::UpdateVibrateHaptic, aVRSystem,
- aHapticIndex, aIntensity, aDuration, mVibrateIndex, aPromiseID);
+ NewRunnableMethod<::vr::IVRSystem*, uint32_t, double, double, uint64_t,
+ StoreCopyPassByConstLRef<VRManagerPromise>>(
+ "VRControllerOpenVR::UpdateVibrateHaptic",
+ this, &VRControllerOpenVR::UpdateVibrateHaptic, aVRSystem,
+ aHapticIndex, aIntensity, aDuration, mVibrateIndex, aPromise);
mVibrateThread->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
}
void
VRControllerOpenVR::StopVibrateHaptic()
{
mIsVibrateStopped = true;
}
@@ -969,28 +972,28 @@ VRSystemManagerOpenVR::GetGamepadHandFro
return hand;
}
void
VRSystemManagerOpenVR::VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
// mVRSystem is available after VRDisplay is created
// at GetHMDs().
- if (!mVRSystem) {
+ if (!mVRSystem || (aControllerIdx >= mOpenVRController.Length())) {
return;
}
RefPtr<impl::VRControllerOpenVR> controller = mOpenVRController[aControllerIdx];
MOZ_ASSERT(controller);
- controller->VibrateHaptic(mVRSystem, aHapticIndex, aIntensity, aDuration, aPromiseID);
+ controller->VibrateHaptic(mVRSystem, aHapticIndex, aIntensity, aDuration, aPromise);
}
void
VRSystemManagerOpenVR::StopVibrateHaptic(uint32_t aControllerIdx)
{
// mVRSystem is available after VRDisplay is created
// at GetHMDs().
if (!mVRSystem || (aControllerIdx >= mOpenVRController.Length())) {
--- a/gfx/vr/gfxVROpenVR.h
+++ b/gfx/vr/gfxVROpenVR.h
@@ -90,30 +90,30 @@ public:
void SetAxisMove(uint32_t aAxis, float aValue);
void SetTrigger(uint32_t aButton, float aValue);
float GetTrigger(uint32_t aButton);
void SetHand(dom::GamepadHand aHand);
void VibrateHaptic(::vr::IVRSystem* aVRSystem,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID);
+ const VRManagerPromise& aPromise);
void StopVibrateHaptic();
protected:
virtual ~VRControllerOpenVR();
private:
void UpdateVibrateHaptic(::vr::IVRSystem* aVRSystem,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
uint64_t aVibrateIndex,
- uint32_t aPromiseID);
- void VibrateHapticComplete(uint32_t aPromiseID);
+ const VRManagerPromise& aPromise);
+ void VibrateHapticComplete(const VRManagerPromise& aPromise);
// The index of tracked devices from ::vr::IVRSystem.
uint32_t mTrackedIndex;
nsTArray<float> mTrigger;
nsTArray<float> mAxisMove;
nsCOMPtr<nsIThread> mVibrateThread;
Atomic<bool> mIsVibrateStopped;
};
@@ -133,17 +133,17 @@ public:
virtual void GetControllers(nsTArray<RefPtr<VRControllerHost>>&
aControllerResult) override;
virtual void ScanForControllers() override;
virtual void RemoveControllers() override;
virtual void VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID) override;
+ const VRManagerPromise& aPromise) override;
virtual void StopVibrateHaptic(uint32_t aControllerIdx) override;
protected:
VRSystemManagerOpenVR();
private:
void HandleButtonPress(uint32_t aControllerIdx,
uint32_t aButton,
--- a/gfx/vr/gfxVRPuppet.cpp
+++ b/gfx/vr/gfxVRPuppet.cpp
@@ -796,17 +796,17 @@ VRSystemManagerPuppet::HandlePoseTrackin
}
}
void
VRSystemManagerPuppet::VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID)
+ const VRManagerPromise& aPromise)
{
}
void
VRSystemManagerPuppet::StopVibrateHaptic(uint32_t aControllerIdx)
{
}
--- a/gfx/vr/gfxVRPuppet.h
+++ b/gfx/vr/gfxVRPuppet.h
@@ -116,17 +116,17 @@ public:
virtual void GetControllers(nsTArray<RefPtr<VRControllerHost>>&
aControllerResult) override;
virtual void ScanForControllers() override;
virtual void RemoveControllers() override;
virtual void VibrateHaptic(uint32_t aControllerIdx,
uint32_t aHapticIndex,
double aIntensity,
double aDuration,
- uint32_t aPromiseID) override;
+ const VRManagerPromise& aPromise) override;
virtual void StopVibrateHaptic(uint32_t aControllerIdx) override;
protected:
VRSystemManagerPuppet();
private:
void HandleButtonPress(uint32_t aControllerIdx,
uint32_t aButton,
--- a/gfx/vr/ipc/VRManagerChild.h
+++ b/gfx/vr/ipc/VRManagerChild.h
@@ -127,17 +127,17 @@ private:
*/
int32_t mFrameRequestCallbackCounter;
mozilla::TimeStamp mStartTimeStamp;
nsTArray<RefPtr<dom::VREventObserver>> mListeners;
layers::LayersBackend mBackend;
RefPtr<layers::SyncObjectClient> mSyncObject;
- nsRefPtrHashtable<nsUint32HashKey, dom::Promise> mGamepadPromiseList; // TODO: check if it can merge into one list?
+ nsRefPtrHashtable<nsUint32HashKey, dom::Promise> mGamepadPromiseList;
uint32_t mPromiseID;
nsRefPtrHashtable<nsUint32HashKey, dom::Promise> mPromiseList;
RefPtr<dom::VRMockDisplay> mVRMockDisplay;
DISALLOW_COPY_AND_ASSIGN(VRManagerChild);
};
} // namespace mozilla
--- a/gfx/vr/ipc/VRManagerParent.cpp
+++ b/gfx/vr/ipc/VRManagerParent.cpp
@@ -387,18 +387,20 @@ VRManagerParent::RecvNewPoseMoveToMockCo
mozilla::ipc::IPCResult
VRManagerParent::RecvVibrateHaptic(const uint32_t& aControllerIdx,
const uint32_t& aHapticIndex,
const double& aIntensity,
const double& aDuration,
const uint32_t& aPromiseID)
{
VRManager* vm = VRManager::Get();
+ VRManagerPromise promise(this, aPromiseID);
+
vm->VibrateHaptic(aControllerIdx, aHapticIndex, aIntensity,
- aDuration, aPromiseID);
+ aDuration, promise);
return IPC_OK();
}
mozilla::ipc::IPCResult
VRManagerParent::RecvStopVibrateHaptic(const uint32_t& aControllerIdx)
{
VRManager* vm = VRManager::Get();
vm->StopVibrateHaptic(aControllerIdx);
--- a/gfx/vr/ipc/VRManagerParent.h
+++ b/gfx/vr/ipc/VRManagerParent.h
@@ -95,12 +95,29 @@ private:
nsRefPtrHashtable<nsUint32HashKey, impl::VRControllerPuppet> mVRControllerTests;
uint32_t mDisplayTestID;
uint32_t mControllerTestID;
bool mHaveEventListener;
bool mHaveControllerListener;
bool mIsContentChild;
};
+class VRManagerPromise final
+{
+ friend class VRManager;
+
+public:
+ explicit VRManagerPromise(RefPtr<VRManagerParent> aParent, uint32_t aPromiseID)
+ : mParent(aParent), mPromiseID(aPromiseID)
+ {}
+ ~VRManagerPromise() {
+ mParent = nullptr;
+ }
+
+private:
+ RefPtr<VRManagerParent> mParent;
+ uint32_t mPromiseID;
+};
+
} // namespace mozilla
} // namespace gfx
#endif // MOZILLA_GFX_VR_VRMANAGERPARENT_H