зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1563233 - Update VRManager to consume VRShMem r=kip,daoshengmu
This change replaces and removes code in VRManager that was refactored into the new VRShMem class. Differential Revision: https://phabricator.services.mozilla.com/D36986 --HG-- extra : moz-landing-system : lando
This commit is contained in:
thomasmo
Родитель
3a01a56056
Коммит
f8ab88e23d
|
|
@ -7,6 +7,7 @@
|
|||
#include "VRManager.h"
|
||||
|
||||
#include "VRManagerParent.h"
|
||||
#include "VRShMem.h"
|
||||
#include "VRThread.h"
|
||||
#include "gfxVR.h"
|
||||
#include "mozilla/ClearOnShutdown.h"
|
||||
|
|
@ -19,7 +20,6 @@
|
|||
#include "mozilla/Unused.h"
|
||||
|
||||
#include "gfxVR.h"
|
||||
#include "gfxVRMutex.h"
|
||||
#include <cstring>
|
||||
|
||||
#include "ipc/VRLayerParent.h"
|
||||
|
|
@ -33,14 +33,9 @@
|
|||
# include <d3d11.h>
|
||||
# include "gfxWindowsPlatform.h"
|
||||
# include "mozilla/gfx/DeviceManagerDx.h"
|
||||
static const char* kShmemName = "moz.gecko.vr_ext.0.0.1";
|
||||
#elif defined(XP_MACOSX)
|
||||
# include "mozilla/gfx/MacIOSurface.h"
|
||||
# include <sys/mman.h>
|
||||
# include <sys/stat.h> /* For mode constants */
|
||||
# include <fcntl.h> /* For O_* constants */
|
||||
# include <errno.h>
|
||||
static const char* kShmemName = "/moz.gecko.vr_ext.0.0.1";
|
||||
#elif defined(MOZ_WIDGET_ANDROID)
|
||||
# include <string.h>
|
||||
# include <pthread.h>
|
||||
|
|
@ -53,18 +48,6 @@ using namespace mozilla::gfx;
|
|||
using namespace mozilla::layers;
|
||||
using namespace mozilla::gl;
|
||||
|
||||
#if !defined(MOZ_WIDGET_ANDROID)
|
||||
namespace {
|
||||
void YieldThread() {
|
||||
# if defined(XP_WIN)
|
||||
::Sleep(0);
|
||||
# else
|
||||
::sleep(0);
|
||||
# endif
|
||||
}
|
||||
} // anonymous namespace
|
||||
#endif // !defined(MOZ_WIDGET_ANDROID)
|
||||
|
||||
namespace mozilla {
|
||||
namespace gfx {
|
||||
|
||||
|
|
@ -127,19 +110,13 @@ VRManager::VRManager()
|
|||
mVRDisplaysRequestedNonFocus(false),
|
||||
mVRControllersRequested(false),
|
||||
mFrameStarted(false),
|
||||
mExternalShmem(nullptr),
|
||||
mTaskInterval(0),
|
||||
mCurrentSubmitTaskMonitor("CurrentSubmitTaskMonitor"),
|
||||
mCurrentSubmitTask(nullptr),
|
||||
mLastSubmittedFrameId(0),
|
||||
mLastStartedFrame(0),
|
||||
mEnumerationCompleted(false),
|
||||
#if defined(XP_MACOSX)
|
||||
mShmemFD(0),
|
||||
#elif defined(XP_WIN)
|
||||
mShmemFile(NULL),
|
||||
mMutex(NULL),
|
||||
#endif
|
||||
mShmem(nullptr),
|
||||
mHapticPulseRemaining{},
|
||||
mDisplayInfo{},
|
||||
mLastUpdateDisplayInfo{},
|
||||
|
|
@ -160,160 +137,40 @@ VRManager::VRManager()
|
|||
// on ShutdownPhase::ShutdownFinal, potentially before VRManager.
|
||||
// We hold a reference to VRServiceHost to ensure it stays
|
||||
// alive until we have shut down.
|
||||
#else
|
||||
// For Android, there is no VRProcess available and no VR service is
|
||||
// created, so default to false.
|
||||
mVRProcessEnabled = false;
|
||||
#endif // !defined(MOZ_WIDGET_ANDROID)
|
||||
}
|
||||
|
||||
void VRManager::OpenShmem() {
|
||||
if (mExternalShmem) {
|
||||
mExternalShmem->Clear();
|
||||
return;
|
||||
}
|
||||
#if defined(XP_WIN)
|
||||
if (mMutex == NULL) {
|
||||
mMutex = CreateMutex(NULL, // default security descriptor
|
||||
false, // mutex not owned
|
||||
TEXT("mozilla::vr::ShmemMutex")); // object name
|
||||
if (mMutex == NULL) {
|
||||
nsAutoCString msg;
|
||||
msg.AppendPrintf("VRManager CreateMutex error \"%lu\".", GetLastError());
|
||||
NS_WARNING(msg.get());
|
||||
MOZ_ASSERT(false);
|
||||
return;
|
||||
}
|
||||
// At xpcshell extension tests, it creates multiple VRManager
|
||||
// instances in plug-contrainer.exe. It causes GetLastError() return
|
||||
// `ERROR_ALREADY_EXISTS`. However, even though `ERROR_ALREADY_EXISTS`, it
|
||||
// still returns the same mutex handle.
|
||||
//
|
||||
// https://docs.microsoft.com/en-us/windows/desktop/api/synchapi/nf-synchapi-createmutexa
|
||||
MOZ_ASSERT(GetLastError() == 0 || GetLastError() == ERROR_ALREADY_EXISTS);
|
||||
}
|
||||
#endif // XP_WIN
|
||||
if (mShmem == nullptr) {
|
||||
mShmem = (new VRShMem(nullptr, mVRProcessEnabled, XRE_IsParentProcess()));
|
||||
mShmem->CreateShMem();
|
||||
|
||||
#if !defined(MOZ_WIDGET_ANDROID)
|
||||
// The VR Service accesses all hardware from a separate process
|
||||
// and replaces the other VRManager when enabled.
|
||||
// If the VR process is not enabled, create an in-process VRService.
|
||||
if (!mVRProcessEnabled) {
|
||||
// If the VR process is disabled, attempt to create a
|
||||
// VR service within the current process
|
||||
mExternalShmem = new VRExternalShmem();
|
||||
// VRExternalShmem is asserted to be POD
|
||||
mExternalShmem->Clear();
|
||||
mServiceHost->CreateService(mExternalShmem);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(XP_MACOSX)
|
||||
if (mShmemFD == 0) {
|
||||
mShmemFD =
|
||||
shm_open(kShmemName, O_RDWR, S_IRUSR | S_IWUSR | S_IROTH | S_IWOTH);
|
||||
}
|
||||
if (mShmemFD <= 0) {
|
||||
mShmemFD = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
struct stat sb;
|
||||
fstat(mShmemFD, &sb);
|
||||
off_t length = sb.st_size;
|
||||
if (length < (off_t)sizeof(VRExternalShmem)) {
|
||||
// TODO - Implement logging (Bug 1558912)
|
||||
CloseShmem();
|
||||
return;
|
||||
}
|
||||
|
||||
mExternalShmem = (VRExternalShmem*)mmap(NULL, length, PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, mShmemFD, 0);
|
||||
if (mExternalShmem == MAP_FAILED) {
|
||||
// TODO - Implement logging (Bug 1558912)
|
||||
mExternalShmem = NULL;
|
||||
CloseShmem();
|
||||
return;
|
||||
}
|
||||
|
||||
#elif defined(XP_WIN)
|
||||
if (mShmemFile == NULL) {
|
||||
mShmemFile = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
|
||||
0, sizeof(VRExternalShmem), kShmemName);
|
||||
MOZ_ASSERT(GetLastError() == 0 || GetLastError() == ERROR_ALREADY_EXISTS);
|
||||
MOZ_ASSERT(mShmemFile);
|
||||
if (mShmemFile == NULL) {
|
||||
// TODO - Implement logging (Bug 1558912)
|
||||
CloseShmem();
|
||||
// The VR Service accesses all hardware from a separate process
|
||||
// and replaces the other VRManager when enabled.
|
||||
// If the VR process is not enabled, create an in-process VRService.
|
||||
if (!mVRProcessEnabled) {
|
||||
// If the VR process is disabled, attempt to create a
|
||||
// VR service within the current process
|
||||
mServiceHost->CreateService(mShmem->GetExternalShmem());
|
||||
return;
|
||||
}
|
||||
}
|
||||
LARGE_INTEGER length;
|
||||
length.QuadPart = sizeof(VRExternalShmem);
|
||||
mExternalShmem = (VRExternalShmem*)MapViewOfFile(
|
||||
mShmemFile, // handle to map object
|
||||
FILE_MAP_ALL_ACCESS, // read/write permission
|
||||
0, 0, length.QuadPart);
|
||||
|
||||
if (mExternalShmem == NULL) {
|
||||
// TODO - Implement logging (Bug 1558912)
|
||||
CloseShmem();
|
||||
return;
|
||||
}
|
||||
#elif defined(MOZ_WIDGET_ANDROID)
|
||||
mExternalShmem =
|
||||
(VRExternalShmem*)mozilla::GeckoVRManager::GetExternalContext();
|
||||
if (!mExternalShmem) {
|
||||
return;
|
||||
}
|
||||
int32_t version = -1;
|
||||
int32_t size = 0;
|
||||
if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->systemMutex)) ==
|
||||
0) {
|
||||
version = mExternalShmem->version;
|
||||
size = mExternalShmem->size;
|
||||
pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->systemMutex));
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
if (version != kVRExternalVersion) {
|
||||
mExternalShmem = nullptr;
|
||||
return;
|
||||
}
|
||||
if (size != sizeof(VRExternalShmem)) {
|
||||
mExternalShmem = nullptr;
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
mShmem->ClearShMem();
|
||||
}
|
||||
}
|
||||
|
||||
void VRManager::CloseShmem() {
|
||||
#if !defined(MOZ_WIDGET_ANDROID)
|
||||
if (!mVRProcessEnabled) {
|
||||
if (mExternalShmem) {
|
||||
delete mExternalShmem;
|
||||
mExternalShmem = nullptr;
|
||||
}
|
||||
return;
|
||||
if (mShmem != nullptr) {
|
||||
mShmem->CloseShMem();
|
||||
delete mShmem;
|
||||
mShmem = nullptr;
|
||||
}
|
||||
#endif
|
||||
#if defined(XP_MACOSX)
|
||||
if (mExternalShmem) {
|
||||
munmap((void*)mExternalShmem, sizeof(VRExternalShmem));
|
||||
mExternalShmem = NULL;
|
||||
}
|
||||
if (mShmemFD) {
|
||||
close(mShmemFD);
|
||||
mShmemFD = 0;
|
||||
}
|
||||
#elif defined(XP_WIN)
|
||||
if (mExternalShmem) {
|
||||
UnmapViewOfFile((void*)mExternalShmem);
|
||||
mExternalShmem = NULL;
|
||||
}
|
||||
if (mShmemFile) {
|
||||
CloseHandle(mShmemFile);
|
||||
mShmemFile = NULL;
|
||||
}
|
||||
#elif defined(MOZ_WIDGET_ANDROID)
|
||||
mExternalShmem = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
VRManager::~VRManager() {
|
||||
|
|
@ -323,12 +180,7 @@ VRManager::~VRManager() {
|
|||
mServiceHost->Shutdown();
|
||||
#endif
|
||||
CloseShmem();
|
||||
#if defined(XP_WIN)
|
||||
if (mMutex) {
|
||||
CloseHandle(mMutex);
|
||||
mMutex = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
MOZ_COUNT_DTOR(VRManager);
|
||||
}
|
||||
|
||||
|
|
@ -683,7 +535,7 @@ void VRManager::EnumerateVRDisplays() {
|
|||
#if !defined(MOZ_WIDGET_ANDROID)
|
||||
mServiceHost->StartService();
|
||||
#endif
|
||||
if (mExternalShmem) {
|
||||
if (mShmem) {
|
||||
mDisplayInfo.Clear();
|
||||
mLastUpdateDisplayInfo.Clear();
|
||||
mFrameStarted = false;
|
||||
|
|
@ -698,7 +550,7 @@ void VRManager::EnumerateVRDisplays() {
|
|||
} // if (mState == VRManagerState::Idle)
|
||||
|
||||
if (mState == VRManagerState::Enumeration) {
|
||||
MOZ_ASSERT(mExternalShmem != nullptr);
|
||||
MOZ_ASSERT(mShmem != nullptr);
|
||||
|
||||
PullState();
|
||||
if (mEnumerationCompleted) {
|
||||
|
|
@ -932,120 +784,19 @@ void VRManager::ResetPuppet(VRManagerParent* aManagerParent) {
|
|||
|
||||
#endif // !defined(MOZ_WIDGET_ANDROID)
|
||||
|
||||
#if defined(MOZ_WIDGET_ANDROID)
|
||||
void VRManager::PullState(
|
||||
const std::function<bool()>& aWaitCondition /* = nullptr */) {
|
||||
if (!mExternalShmem) {
|
||||
return;
|
||||
if (mShmem != nullptr) {
|
||||
mShmem->PullSystemState(mDisplayInfo.mDisplayState, mLastSensorState,
|
||||
mDisplayInfo.mControllerState,
|
||||
mEnumerationCompleted, aWaitCondition);
|
||||
}
|
||||
bool done = false;
|
||||
while (!done) {
|
||||
if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->systemMutex)) ==
|
||||
0) {
|
||||
while (true) {
|
||||
memcpy(&mDisplayInfo.mDisplayState,
|
||||
(void*)&(mExternalShmem->state.displayState),
|
||||
sizeof(VRDisplayState));
|
||||
memcpy(&mLastSensorState, (void*)&(mExternalShmem->state.sensorState),
|
||||
sizeof(VRHMDSensorState));
|
||||
memcpy(mDisplayInfo.mControllerState,
|
||||
(void*)&(mExternalShmem->state.controllerState),
|
||||
sizeof(VRControllerState) * kVRControllerMaxCount);
|
||||
mEnumerationCompleted = mExternalShmem->state.enumerationCompleted;
|
||||
if (!aWaitCondition || aWaitCondition()) {
|
||||
done = true;
|
||||
break;
|
||||
}
|
||||
// Block current thead using the condition variable until data
|
||||
// changes
|
||||
pthread_cond_wait((pthread_cond_t*)&mExternalShmem->systemCond,
|
||||
(pthread_mutex_t*)&mExternalShmem->systemMutex);
|
||||
} // while (true)
|
||||
pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->systemMutex));
|
||||
} else if (!aWaitCondition) {
|
||||
// pthread_mutex_lock failed and we are not waiting for a condition to
|
||||
// exit from PullState call.
|
||||
return;
|
||||
}
|
||||
} // while (!done) {
|
||||
}
|
||||
#else
|
||||
|
||||
void VRManager::PullState(
|
||||
const std::function<bool()>& aWaitCondition /* = nullptr */) {
|
||||
MOZ_ASSERT(mExternalShmem);
|
||||
if (!mExternalShmem) {
|
||||
return;
|
||||
}
|
||||
while (true) {
|
||||
{ // Scope for WaitForMutex
|
||||
# if defined(XP_WIN)
|
||||
bool status = true;
|
||||
WaitForMutex lock(mMutex);
|
||||
status = lock.GetStatus();
|
||||
if (status) {
|
||||
# endif // defined(XP_WIN)
|
||||
VRExternalShmem tmp;
|
||||
memcpy(&tmp, (void*)mExternalShmem, sizeof(VRExternalShmem));
|
||||
bool isCleanCopy =
|
||||
tmp.generationA == tmp.generationB && tmp.generationA != 0;
|
||||
if (isCleanCopy) {
|
||||
memcpy(&mDisplayInfo.mDisplayState, &tmp.state.displayState,
|
||||
sizeof(VRDisplayState));
|
||||
memcpy(&mLastSensorState, &tmp.state.sensorState,
|
||||
sizeof(VRHMDSensorState));
|
||||
memcpy(mDisplayInfo.mControllerState,
|
||||
(void*)&(mExternalShmem->state.controllerState),
|
||||
sizeof(VRControllerState) * kVRControllerMaxCount);
|
||||
mEnumerationCompleted = mExternalShmem->state.enumerationCompleted;
|
||||
// Check for wait condition
|
||||
if (!aWaitCondition || aWaitCondition()) {
|
||||
return;
|
||||
}
|
||||
} // if (isCleanCopy)
|
||||
// Yield the thread while polling
|
||||
YieldThread();
|
||||
# if defined(XP_WIN)
|
||||
} else if (!aWaitCondition) {
|
||||
// WaitForMutex failed and we are not waiting for a condition to
|
||||
// exit from PullState call.
|
||||
return;
|
||||
}
|
||||
# endif // defined(XP_WIN)
|
||||
} // End: Scope for WaitForMutex
|
||||
// Yield the thread while polling
|
||||
YieldThread();
|
||||
} // while (!true)
|
||||
}
|
||||
#endif // defined(MOZ_WIDGET_ANDROID)
|
||||
|
||||
void VRManager::PushState(bool aNotifyCond) {
|
||||
if (!mExternalShmem) {
|
||||
return;
|
||||
if (mShmem != nullptr) {
|
||||
mShmem->PushBrowserState(mBrowserState, aNotifyCond);
|
||||
}
|
||||
#if defined(MOZ_WIDGET_ANDROID)
|
||||
if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->geckoMutex)) ==
|
||||
0) {
|
||||
memcpy((void*)&(mExternalShmem->geckoState), (void*)&mBrowserState,
|
||||
sizeof(VRBrowserState));
|
||||
if (aNotifyCond) {
|
||||
pthread_cond_signal((pthread_cond_t*)&(mExternalShmem->geckoCond));
|
||||
}
|
||||
pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->geckoMutex));
|
||||
}
|
||||
#else
|
||||
bool status = true;
|
||||
# if defined(XP_WIN)
|
||||
WaitForMutex lock(mMutex);
|
||||
status = lock.GetStatus();
|
||||
# endif // defined(XP_WIN)
|
||||
if (status) {
|
||||
mExternalShmem->geckoGenerationA++;
|
||||
memcpy((void*)&(mExternalShmem->geckoState), (void*)&mBrowserState,
|
||||
sizeof(VRBrowserState));
|
||||
mExternalShmem->geckoGenerationB++;
|
||||
}
|
||||
#endif // defined(MOZ_WIDGET_ANDROID)
|
||||
}
|
||||
|
||||
void VRManager::Destroy() {
|
||||
|
|
@ -1268,7 +1019,7 @@ void VRManager::StopPresentation() {
|
|||
}
|
||||
|
||||
bool VRManager::IsPresenting() {
|
||||
if (mExternalShmem) {
|
||||
if (mShmem) {
|
||||
return mDisplayInfo.mPresentingGroups != 0;
|
||||
}
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ class VRLayerParent;
|
|||
class VRManagerParent;
|
||||
class VRServiceHost;
|
||||
class VRThread;
|
||||
class VRShMem;
|
||||
|
||||
enum class VRManagerState : uint32_t {
|
||||
Disabled, // All VRManager activity is stopped
|
||||
|
|
@ -131,7 +132,6 @@ class VRManager {
|
|||
bool mVRDisplaysRequestedNonFocus;
|
||||
bool mVRControllersRequested;
|
||||
bool mFrameStarted;
|
||||
volatile VRExternalShmem* mExternalShmem;
|
||||
uint32_t mTaskInterval;
|
||||
RefPtr<nsITimer> mTaskTimer;
|
||||
mozilla::Monitor mCurrentSubmitTaskMonitor;
|
||||
|
|
@ -139,14 +139,13 @@ class VRManager {
|
|||
uint64_t mLastSubmittedFrameId;
|
||||
uint64_t mLastStartedFrame;
|
||||
bool mEnumerationCompleted;
|
||||
#if defined(XP_MACOSX)
|
||||
int mShmemFD;
|
||||
#elif defined(XP_WIN)
|
||||
base::ProcessHandle mShmemFile;
|
||||
HANDLE mMutex;
|
||||
#endif
|
||||
#if !defined(MOZ_WIDGET_ANDROID)
|
||||
|
||||
// Note: mShmem doesn't support RefPtr; thus, do not share this private
|
||||
// pointer so that its lifetime can still be controlled by VRManager
|
||||
VRShMem* mShmem;
|
||||
bool mVRProcessEnabled;
|
||||
|
||||
#if !defined(MOZ_WIDGET_ANDROID)
|
||||
RefPtr<VRServiceHost> mServiceHost;
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ using namespace mozilla::gfx;
|
|||
// release builds running on same machine? (Bug 1563232)
|
||||
#ifdef XP_WIN
|
||||
static const char* kShmemName = "moz.gecko.vr_ext.0.0.1";
|
||||
static LPCTSTR kMutexName = TEXT("mozilla::vr::ShmemMutex");
|
||||
#elif defined(XP_MACOSX)
|
||||
static const char* kShmemName = "/moz.gecko.vr_ext.0.0.1";
|
||||
#endif // XP_WIN
|
||||
|
|
@ -48,10 +49,10 @@ void YieldThread() {
|
|||
} // anonymous namespace
|
||||
#endif // !defined(MOZ_WIDGET_ANDROID)
|
||||
|
||||
VRShMem::VRShMem(volatile VRExternalShmem* aShmem, bool aSameProcess,
|
||||
VRShMem::VRShMem(volatile VRExternalShmem* aShmem, bool aVRProcessEnabled,
|
||||
bool aIsParentProcess)
|
||||
: mExternalShmem(aShmem),
|
||||
mSameProcess(aSameProcess)
|
||||
mVRProcessEnabled(aVRProcessEnabled)
|
||||
#if defined(XP_WIN)
|
||||
,
|
||||
mIsParentProcess(aIsParentProcess)
|
||||
|
|
@ -65,32 +66,44 @@ VRShMem::VRShMem(volatile VRExternalShmem* aShmem, bool aSameProcess,
|
|||
mMutex(nullptr)
|
||||
#endif
|
||||
{
|
||||
// To confirm:
|
||||
// - aShmem is null for VRManager, or for service in multi-proc
|
||||
// - aShmem is !null for VRService in-proc
|
||||
// make this into an assert
|
||||
if (!(aShmem == nullptr || aSameProcess)) {
|
||||
//::DebugBreak();
|
||||
}
|
||||
// Regarding input parameters,
|
||||
// - aShmem is null for VRManager or for VRService in multi-proc
|
||||
// - aShmem is !null for VRService in-proc (i.e., no VR proc)
|
||||
MOZ_ASSERT(aShmem == nullptr || !aVRProcessEnabled);
|
||||
}
|
||||
|
||||
// copied from VRService Ctor
|
||||
// When we have the VR process, we map the memory
|
||||
// of mAPIShmem from GPU process and pass it to the CTOR.
|
||||
// If we don't have the VR process, we will instantiate
|
||||
// mAPIShmem in VRService.
|
||||
// Note: This function should only be called for in-proc scenarios, where the
|
||||
// shared memory is only shared within the same proc (rather than across
|
||||
// processes). Also, this local heap memory's lifetime is tied to the class.
|
||||
// Callers to this must ensure that its reference doesn't outlive the owning
|
||||
// VRShMem instance.
|
||||
volatile VRExternalShmem* VRShMem::GetExternalShmem() const {
|
||||
MOZ_ASSERT(!mVRProcessEnabled);
|
||||
#if defined(XP_MACOSX)
|
||||
MOZ_ASSERT(mShmemFD == 0);
|
||||
#elif defined(XP_WIN)
|
||||
MOZ_ASSERT(mShmemFile == nullptr);
|
||||
#endif
|
||||
return mExternalShmem;
|
||||
}
|
||||
|
||||
bool VRShMem::IsDisplayStateShutdown() const {
|
||||
// adapted from VRService::Refresh
|
||||
// Does this need the mutex for getting .shutdown?
|
||||
return mExternalShmem != nullptr &&
|
||||
mExternalShmem->state.displayState.shutdown;
|
||||
}
|
||||
|
||||
// Callers/Processes to CreateShMem should followup with CloseShMem
|
||||
// [copied from VRManager::OpenShmem]
|
||||
void VRShMem::CreateShMem() {
|
||||
if (mExternalShmem) {
|
||||
return;
|
||||
}
|
||||
#if defined(XP_WIN)
|
||||
if (mMutex == nullptr) {
|
||||
mMutex = CreateMutex(nullptr, // default security descriptor
|
||||
false, // mutex not owned
|
||||
TEXT("mozilla::vr::ShmemMutex")); // object name
|
||||
mMutex = CreateMutex(nullptr, // default security descriptor
|
||||
false, // mutex not owned
|
||||
kMutexName); // object name
|
||||
if (mMutex == nullptr) {
|
||||
# ifdef MOZILLA_INTERNAL_API
|
||||
nsAutoCString msg;
|
||||
|
|
@ -113,17 +126,11 @@ void VRShMem::CreateShMem() {
|
|||
// The VR Service accesses all hardware from a separate process
|
||||
// and replaces the other VRManager when enabled.
|
||||
// If the VR process is not enabled, create an in-process VRService.
|
||||
if (mSameProcess) {
|
||||
if (!mVRProcessEnabled) {
|
||||
// If the VR process is disabled, attempt to create a
|
||||
// VR service within the current process
|
||||
mExternalShmem = new VRExternalShmem();
|
||||
# ifdef MOZILLA_INTERNAL_API
|
||||
// TODO: Create external variant to Clear (Bug 1563233)
|
||||
// VRExternalShmem is asserted to be POD
|
||||
mExternalShmem->Clear();
|
||||
# endif
|
||||
// TODO: move this call to the caller (Bug 1563233)
|
||||
// mServiceHost->CreateService(mExternalShmem);
|
||||
ClearShMem();
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -208,11 +215,21 @@ void VRShMem::CreateShMem() {
|
|||
#endif
|
||||
}
|
||||
|
||||
void VRShMem::ClearShMem() {
|
||||
if (mExternalShmem != nullptr) {
|
||||
#ifdef MOZILLA_INTERNAL_API
|
||||
// VRExternalShmem is asserted to be POD
|
||||
mExternalShmem->Clear();
|
||||
#else
|
||||
memset((void*)mExternalShmem, 0, sizeof(VRExternalShmem));
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
// The cleanup corresponding to CreateShMem
|
||||
// [copied from VRManager::CloseShmem, dtor]
|
||||
void VRShMem::CloseShMem() {
|
||||
#if !defined(MOZ_WIDGET_ANDROID)
|
||||
if (mSameProcess) {
|
||||
if (!mVRProcessEnabled) {
|
||||
if (mExternalShmem) {
|
||||
delete mExternalShmem;
|
||||
mExternalShmem = nullptr;
|
||||
|
|
@ -241,25 +258,51 @@ void VRShMem::CloseShMem() {
|
|||
#elif defined(MOZ_WIDGET_ANDROID)
|
||||
mExternalShmem = NULL;
|
||||
#endif
|
||||
|
||||
#if defined(XP_WIN)
|
||||
// from ~VRManager. DOes this need to be separated into a separate function?
|
||||
if (mMutex) {
|
||||
CloseHandle(mMutex);
|
||||
mMutex = nullptr;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Called to use an existing shmem instance created by another process
|
||||
// Callers to JoinShMem should call LeaveShMem for cleanup
|
||||
// [copied from VRService::InitShmem, VRService::Start]
|
||||
bool VRShMem::JoinShMem() {
|
||||
// was if (!mVRProcessEnabled) {
|
||||
if (mSameProcess) {
|
||||
#if defined(XP_WIN)
|
||||
// Adding `!XRE_IsParentProcess()` to avoid Win 7 32-bit WebVR tests
|
||||
// to OpenMutex when there is no GPU process to create
|
||||
// VRSystemManagerExternal and its mutex.
|
||||
if (!mMutex && !mIsParentProcess) {
|
||||
mMutex = OpenMutex(MUTEX_ALL_ACCESS, // request full access
|
||||
false, // handle not inheritable
|
||||
kMutexName); // object name
|
||||
|
||||
if (mMutex == nullptr) {
|
||||
# ifdef MOZILLA_INTERNAL_API
|
||||
nsAutoCString msg;
|
||||
msg.AppendPrintf("VRService OpenMutex error \"%lu\".", GetLastError());
|
||||
NS_WARNING(msg.get());
|
||||
# endif
|
||||
MOZ_ASSERT(false);
|
||||
}
|
||||
MOZ_ASSERT(GetLastError() == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!mVRProcessEnabled) {
|
||||
return true;
|
||||
}
|
||||
|
||||
#if defined(XP_WIN)
|
||||
const char* kShmemName = "moz.gecko.vr_ext.0.0.1";
|
||||
base::ProcessHandle targetHandle = 0;
|
||||
|
||||
// Opening a file-mapping object by name
|
||||
targetHandle = OpenFileMappingA(FILE_MAP_ALL_ACCESS, // read/write access
|
||||
FALSE, // do not inherit the name
|
||||
kShmemName); // name of mapping object
|
||||
base::ProcessHandle targetHandle =
|
||||
OpenFileMappingA(FILE_MAP_ALL_ACCESS, // read/write access
|
||||
FALSE, // do not inherit the name
|
||||
kShmemName); // name of mapping object
|
||||
|
||||
MOZ_ASSERT(GetLastError() == 0);
|
||||
|
||||
|
|
@ -282,35 +325,12 @@ bool VRShMem::JoinShMem() {
|
|||
//
|
||||
// TODO: ** Does this mean that ShMem only works in Windows for now? If so,
|
||||
// let's delete the code from other platforms (Bug 1563234)
|
||||
MOZ_ASSERT(false, "JoinShMem not implemented");
|
||||
#endif
|
||||
|
||||
#if defined(XP_WIN)
|
||||
// Adding `!XRE_IsParentProcess()` to avoid Win 7 32-bit WebVR tests
|
||||
// to OpenMutex when there is no GPU process to create
|
||||
// VRSystemManagerExternal and its mutex.
|
||||
// was if (!mMutex && !XRE_IsParentProcess()) {
|
||||
if (!mMutex && !mIsParentProcess) {
|
||||
mMutex = OpenMutex(MUTEX_ALL_ACCESS, // request full access
|
||||
false, // handle not inheritable
|
||||
TEXT("mozilla::vr::ShmemMutex")); // object name
|
||||
|
||||
if (mMutex == nullptr) {
|
||||
# ifdef MOZILLA_INTERNAL_API
|
||||
nsAutoCString msg;
|
||||
msg.AppendPrintf("VRService OpenMutex error \"%lu\".", GetLastError());
|
||||
NS_WARNING(msg.get());
|
||||
# endif
|
||||
MOZ_ASSERT(false);
|
||||
}
|
||||
MOZ_ASSERT(GetLastError() == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// The cleanup corresponding to JoinShMem
|
||||
// [copied from VRService::Stop]
|
||||
void VRShMem::LeaveShMem() {
|
||||
#if defined(XP_WIN)
|
||||
if (mShmemFile) {
|
||||
|
|
@ -319,8 +339,7 @@ void VRShMem::LeaveShMem() {
|
|||
}
|
||||
#endif
|
||||
|
||||
// was if (mVRProcessEnabled && mAPIShmem) {
|
||||
if (mExternalShmem != nullptr && !mSameProcess) {
|
||||
if (mExternalShmem != nullptr && mVRProcessEnabled) {
|
||||
#if defined(XP_WIN)
|
||||
UnmapViewOfFile((void*)mExternalShmem);
|
||||
#endif
|
||||
|
|
@ -334,7 +353,6 @@ void VRShMem::LeaveShMem() {
|
|||
#endif
|
||||
}
|
||||
|
||||
// [copied from from VRManager::PushState]
|
||||
void VRShMem::PushBrowserState(VRBrowserState& aBrowserState,
|
||||
bool aNotifyCond) {
|
||||
if (!mExternalShmem) {
|
||||
|
|
@ -365,7 +383,6 @@ void VRShMem::PushBrowserState(VRBrowserState& aBrowserState,
|
|||
#endif // defined(MOZ_WIDGET_ANDROID)
|
||||
}
|
||||
|
||||
// [copied from VRService::PullState]
|
||||
void VRShMem::PullBrowserState(mozilla::gfx::VRBrowserState& aState) {
|
||||
if (!mExternalShmem) {
|
||||
return;
|
||||
|
|
@ -389,10 +406,10 @@ void VRShMem::PullBrowserState(mozilla::gfx::VRBrowserState& aState) {
|
|||
pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->geckoMutex));
|
||||
}
|
||||
*/
|
||||
MOZ_ASSERT(false, "PullBrowserState not implemented");
|
||||
#else
|
||||
bool status = true;
|
||||
# if defined(XP_WIN)
|
||||
// was if (!XRE_IsParentProcess()) {
|
||||
if (!mIsParentProcess) {
|
||||
// TODO: Is this scoped lock okay? Seems like it should allow some
|
||||
// race condition (Bug 1563234)
|
||||
|
|
@ -418,7 +435,6 @@ void VRShMem::PullBrowserState(mozilla::gfx::VRBrowserState& aState) {
|
|||
#endif // defined(MOZ_WIDGET_ANDROID)
|
||||
}
|
||||
|
||||
// [copied from VRService::PushState]
|
||||
void VRShMem::PushSystemState(const mozilla::gfx::VRSystemState& aState) {
|
||||
if (!mExternalShmem) {
|
||||
return;
|
||||
|
|
@ -431,6 +447,7 @@ void VRShMem::PushSystemState(const mozilla::gfx::VRSystemState& aState) {
|
|||
#if defined(MOZ_WIDGET_ANDROID)
|
||||
// TODO: This code is out-of-date and fails to compile, as
|
||||
// VRService isn't compiled for Android (Bug 1563234)
|
||||
MOZ_ASSERT(false, "JoinShMem not implemented");
|
||||
/*
|
||||
if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->systemMutex)) ==
|
||||
0) {
|
||||
|
|
@ -445,8 +462,9 @@ void VRShMem::PushSystemState(const mozilla::gfx::VRSystemState& aState) {
|
|||
#else
|
||||
bool lockState = true;
|
||||
# if defined(XP_WIN)
|
||||
// was if (!XRE_IsParentProcess()) {
|
||||
if (!mIsParentProcess) {
|
||||
// TODO: Is this scoped lock okay? Seems like it should allow some
|
||||
// race condition (Bug 1563234)
|
||||
WaitForMutex lock(mMutex);
|
||||
lockState = lock.GetStatus();
|
||||
}
|
||||
|
|
@ -459,7 +477,6 @@ void VRShMem::PushSystemState(const mozilla::gfx::VRSystemState& aState) {
|
|||
#endif // defined(MOZ_WIDGET_ANDROID)
|
||||
}
|
||||
|
||||
// [copied from void VRManager::PullState]
|
||||
#if defined(MOZ_WIDGET_ANDROID)
|
||||
void VRShMem::PullSystemState(
|
||||
VRDisplayState& aDisplayState, VRHMDSensorState& aSensorState,
|
||||
|
|
|
|||
|
|
@ -22,11 +22,12 @@ namespace mozilla {
|
|||
namespace gfx {
|
||||
class VRShMem final {
|
||||
public:
|
||||
VRShMem(volatile VRExternalShmem* aShmem, bool aSameProcess,
|
||||
VRShMem(volatile VRExternalShmem* aShmem, bool aVRProcessEnabled,
|
||||
bool aIsParentProcess);
|
||||
~VRShMem() = default;
|
||||
|
||||
void CreateShMem();
|
||||
void ClearShMem();
|
||||
void CloseShMem();
|
||||
|
||||
bool JoinShMem();
|
||||
|
|
@ -42,9 +43,14 @@ class VRShMem final {
|
|||
bool& aEnumerationCompleted,
|
||||
const std::function<bool()>& aWaitCondition = nullptr);
|
||||
|
||||
bool HasExternalShmem() const { return mExternalShmem != nullptr; }
|
||||
volatile VRExternalShmem* GetExternalShmem() const;
|
||||
bool IsDisplayStateShutdown() const;
|
||||
|
||||
private:
|
||||
volatile VRExternalShmem* mExternalShmem = nullptr;
|
||||
bool mSameProcess = false;
|
||||
bool mVRProcessEnabled;
|
||||
|
||||
#if defined(XP_WIN)
|
||||
bool mIsParentProcess = false;
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
#include "VRService.h"
|
||||
#include "../VRShMem.h"
|
||||
#include "mozilla/StaticPrefs.h"
|
||||
#include "../gfxVRMutex.h"
|
||||
#include "base/thread.h" // for Thread
|
||||
|
|
@ -60,21 +61,15 @@ already_AddRefed<VRService> VRService::Create(
|
|||
VRService::VRService(volatile VRExternalShmem* aShmem)
|
||||
: mSystemState{},
|
||||
mBrowserState{},
|
||||
mBrowserGeneration(0),
|
||||
mServiceThread(nullptr),
|
||||
mShutdownRequested(false),
|
||||
mAPIShmem(aShmem),
|
||||
mTargetShmemFile(0),
|
||||
mLastHapticState{},
|
||||
mFrameStartTime{},
|
||||
#if defined(XP_WIN)
|
||||
mMutex(NULL),
|
||||
#endif
|
||||
mVRProcessEnabled(aShmem == nullptr) {
|
||||
mFrameStartTime{} {
|
||||
// When we have the VR process, we map the memory
|
||||
// of mAPIShmem from GPU process and pass it to the CTOR.
|
||||
// If we don't have the VR process, we will instantiate
|
||||
// mAPIShmem in VRService.
|
||||
mShmem = new VRShMem(aShmem, aShmem == nullptr, XRE_IsParentProcess());
|
||||
}
|
||||
|
||||
VRService::~VRService() {
|
||||
|
|
@ -84,35 +79,12 @@ VRService::~VRService() {
|
|||
}
|
||||
|
||||
void VRService::Refresh() {
|
||||
if (!mAPIShmem) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (mAPIShmem->state.displayState.shutdown) {
|
||||
if (mShmem != nullptr && mShmem->IsDisplayStateShutdown()) {
|
||||
Stop();
|
||||
}
|
||||
}
|
||||
|
||||
void VRService::Start() {
|
||||
#if defined(XP_WIN)
|
||||
// Adding `!XRE_IsParentProcess()` to avoid Win 7 32-bit WebVR tests
|
||||
// to OpenMutex when there is no GPU process to create
|
||||
// VRSystemManagerExternal and its mutex.
|
||||
if (!mMutex && !XRE_IsParentProcess()) {
|
||||
mMutex = OpenMutex(MUTEX_ALL_ACCESS, // request full access
|
||||
false, // handle not inheritable
|
||||
TEXT("mozilla::vr::ShmemMutex")); // object name
|
||||
|
||||
if (mMutex == NULL) {
|
||||
nsAutoCString msg;
|
||||
msg.AppendPrintf("VRService OpenMutex error \"%lu\".", GetLastError());
|
||||
NS_WARNING(msg.get());
|
||||
MOZ_ASSERT(false);
|
||||
}
|
||||
MOZ_ASSERT(GetLastError() == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!mServiceThread) {
|
||||
/**
|
||||
* We must ensure that any time the service is re-started, that
|
||||
|
|
@ -155,63 +127,17 @@ void VRService::Stop() {
|
|||
delete mServiceThread;
|
||||
mServiceThread = nullptr;
|
||||
}
|
||||
if (mTargetShmemFile) {
|
||||
#if defined(XP_WIN)
|
||||
CloseHandle(mTargetShmemFile);
|
||||
#endif
|
||||
mTargetShmemFile = 0;
|
||||
|
||||
if (mShmem != nullptr) {
|
||||
mShmem->LeaveShMem();
|
||||
delete mShmem;
|
||||
mShmem = nullptr;
|
||||
}
|
||||
if (mVRProcessEnabled && mAPIShmem) {
|
||||
#if defined(XP_WIN)
|
||||
UnmapViewOfFile((void*)mAPIShmem);
|
||||
#endif
|
||||
mAPIShmem = nullptr;
|
||||
}
|
||||
#if defined(XP_WIN)
|
||||
if (mMutex) {
|
||||
CloseHandle(mMutex);
|
||||
mMutex = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
mSession = nullptr;
|
||||
}
|
||||
|
||||
bool VRService::InitShmem() {
|
||||
if (!mVRProcessEnabled) {
|
||||
return true;
|
||||
}
|
||||
|
||||
#if defined(XP_WIN)
|
||||
const char* kShmemName = "moz.gecko.vr_ext.0.0.1";
|
||||
base::ProcessHandle targetHandle = 0;
|
||||
|
||||
// Opening a file-mapping object by name
|
||||
targetHandle = OpenFileMappingA(FILE_MAP_ALL_ACCESS, // read/write access
|
||||
FALSE, // do not inherit the name
|
||||
kShmemName); // name of mapping object
|
||||
|
||||
MOZ_ASSERT(GetLastError() == 0);
|
||||
|
||||
LARGE_INTEGER length;
|
||||
length.QuadPart = sizeof(VRExternalShmem);
|
||||
mAPIShmem = (VRExternalShmem*)MapViewOfFile(
|
||||
reinterpret_cast<base::ProcessHandle>(
|
||||
targetHandle), // handle to map object
|
||||
FILE_MAP_ALL_ACCESS, // read/write permission
|
||||
0, 0, length.QuadPart);
|
||||
MOZ_ASSERT(GetLastError() == 0);
|
||||
// TODO - Implement logging
|
||||
mTargetShmemFile = targetHandle;
|
||||
if (!mAPIShmem) {
|
||||
MOZ_ASSERT(mAPIShmem);
|
||||
return false;
|
||||
}
|
||||
#else
|
||||
// TODO: Implement shmem for other platforms.
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
bool VRService::InitShmem() { return mShmem->JoinShMem(); }
|
||||
|
||||
bool VRService::IsInServiceThread() {
|
||||
return (mServiceThread != nullptr) &&
|
||||
|
|
@ -447,81 +373,13 @@ void VRService::UpdateHaptics() {
|
|||
}
|
||||
|
||||
void VRService::PushState(const mozilla::gfx::VRSystemState& aState) {
|
||||
if (!mAPIShmem) {
|
||||
return;
|
||||
if (mShmem != nullptr) {
|
||||
mShmem->PushSystemState(aState);
|
||||
}
|
||||
// Copying the VR service state to the shmem is atomic, infallable,
|
||||
// and non-blocking on x86/x64 architectures. Arm requires a mutex
|
||||
// that is locked for the duration of the memcpy to and from shmem on
|
||||
// both sides.
|
||||
|
||||
#if defined(MOZ_WIDGET_ANDROID)
|
||||
if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->systemMutex)) ==
|
||||
0) {
|
||||
// We are casting away the volatile keyword, which is not accepted by
|
||||
// memcpy. It is possible (although very unlikely) that the compiler
|
||||
// may optimize out the memcpy here as memcpy isn't explicitly safe for
|
||||
// volatile memory in the C++ standard.
|
||||
memcpy((void*)&mAPIShmem->state, &aState, sizeof(VRSystemState));
|
||||
pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->systemMutex));
|
||||
}
|
||||
#else
|
||||
bool state = true;
|
||||
# if defined(XP_WIN)
|
||||
if (!XRE_IsParentProcess()) {
|
||||
WaitForMutex lock(mMutex);
|
||||
state = lock.GetStatus();
|
||||
}
|
||||
# endif // defined(XP_WIN)
|
||||
if (state) {
|
||||
mAPIShmem->generationA++;
|
||||
memcpy((void*)&mAPIShmem->state, &aState, sizeof(VRSystemState));
|
||||
mAPIShmem->generationB++;
|
||||
}
|
||||
#endif // defined(MOZ_WIDGET_ANDROID)
|
||||
}
|
||||
|
||||
void VRService::PullState(mozilla::gfx::VRBrowserState& aState) {
|
||||
if (!mAPIShmem) {
|
||||
return;
|
||||
if (mShmem != nullptr) {
|
||||
mShmem->PullBrowserState(aState);
|
||||
}
|
||||
// Copying the browser state from the shmem is non-blocking
|
||||
// on x86/x64 architectures. Arm requires a mutex that is
|
||||
// locked for the duration of the memcpy to and from shmem on
|
||||
// both sides.
|
||||
// On x86/x64 It is fallable -- If a dirty copy is detected by
|
||||
// a mismatch of geckoGenerationA and geckoGenerationB,
|
||||
// the copy is discarded and will not replace the last known
|
||||
// browser state.
|
||||
|
||||
#if defined(MOZ_WIDGET_ANDROID)
|
||||
if (pthread_mutex_lock((pthread_mutex_t*)&(mExternalShmem->geckoMutex)) ==
|
||||
0) {
|
||||
memcpy(&aState, &tmp.geckoState, sizeof(VRBrowserState));
|
||||
pthread_mutex_unlock((pthread_mutex_t*)&(mExternalShmem->geckoMutex));
|
||||
}
|
||||
#else
|
||||
bool status = true;
|
||||
# if defined(XP_WIN)
|
||||
if (!XRE_IsParentProcess()) {
|
||||
WaitForMutex lock(mMutex);
|
||||
status = lock.GetStatus();
|
||||
}
|
||||
# endif // defined(XP_WIN)
|
||||
if (status) {
|
||||
VRExternalShmem tmp;
|
||||
if (mAPIShmem->geckoGenerationA != mBrowserGeneration) {
|
||||
// TODO - (void *) cast removes volatile semantics.
|
||||
// The memcpy is not likely to be optimized out, but is theoretically
|
||||
// possible. Suggest refactoring to either explicitly enforce memory
|
||||
// order or to use locks.
|
||||
memcpy(&tmp, (void*)mAPIShmem, sizeof(VRExternalShmem));
|
||||
if (tmp.geckoGenerationA == tmp.geckoGenerationB &&
|
||||
tmp.geckoGenerationA != 0) {
|
||||
memcpy(&aState, &tmp.geckoState, sizeof(VRBrowserState));
|
||||
mBrowserGeneration = tmp.geckoGenerationA;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif // defined(MOZ_WIDGET_ANDROID)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ namespace mozilla {
|
|||
namespace gfx {
|
||||
|
||||
class VRSession;
|
||||
class VRShMem;
|
||||
|
||||
static const int kVRFrameTimingHistoryDepth = 100;
|
||||
|
||||
|
|
@ -53,20 +54,16 @@ class VRService {
|
|||
* mBrowserState is memcpy'ed from the Shmem atomically
|
||||
*/
|
||||
VRBrowserState mBrowserState;
|
||||
int64_t mBrowserGeneration;
|
||||
|
||||
UniquePtr<VRSession> mSession;
|
||||
base::Thread* mServiceThread;
|
||||
bool mShutdownRequested;
|
||||
|
||||
volatile VRExternalShmem* MOZ_OWNING_REF mAPIShmem;
|
||||
base::ProcessHandle mTargetShmemFile;
|
||||
// Note: mShmem doesn't support RefPtr; thus, do not share this private
|
||||
// pointer so that its lifetime can still be controlled by VRService
|
||||
VRShMem* mShmem;
|
||||
VRHapticState mLastHapticState[kVRHapticsMaxCount];
|
||||
TimeStamp mFrameStartTime[kVRFrameTimingHistoryDepth];
|
||||
#if defined(XP_WIN)
|
||||
HANDLE mMutex;
|
||||
#endif
|
||||
bool mVRProcessEnabled;
|
||||
|
||||
bool IsInServiceThread();
|
||||
void UpdateHaptics();
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ void TestTheManager() {
|
|||
);
|
||||
|
||||
printf("\n01 mgr: create mgr\n");
|
||||
mozilla::gfx::VRShMem shmem(nullptr, false, false);
|
||||
mozilla::gfx::VRShMem shmem(nullptr, true, true);
|
||||
shmem.CreateShMem();
|
||||
|
||||
printf("02 mgr: wait for signal\n");
|
||||
|
|
@ -88,6 +88,9 @@ void TestTheManager() {
|
|||
state.controllerState[1].hand, state.sensorState.inputFrameID);
|
||||
|
||||
shmem.CloseShMem();
|
||||
|
||||
printf("mgr complete");
|
||||
fflush(nullptr);
|
||||
}
|
||||
|
||||
// For testing VRShMem as the Service (i.e., the one who consumes the
|
||||
|
|
@ -100,7 +103,7 @@ void TestTheService() {
|
|||
);
|
||||
|
||||
printf("\n03 svc: create svc\n");
|
||||
mozilla::gfx::VRShMem shmem(nullptr, false, false);
|
||||
mozilla::gfx::VRShMem shmem(nullptr, true, false);
|
||||
shmem.JoinShMem();
|
||||
|
||||
printf("04 svc: send signal\n");
|
||||
|
|
@ -136,4 +139,7 @@ void TestTheService() {
|
|||
::SetEvent(hEvent);
|
||||
|
||||
shmem.LeaveShMem();
|
||||
|
||||
printf("svc complete");
|
||||
fflush(nullptr);
|
||||
}
|
||||
Загрузка…
Ссылка в новой задаче