Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1542 insertions, 0 deletions

diff --git a/gfx/vr/VRManager.cpp b/gfx/vr/VRManager.cpp
new file mode 100644
index 0000000000..72bc02b674
--- /dev/null
+++ b/gfx/vr/VRManager.cpp
@@ -0,0 +1,1542 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "VRManager.h"
+
+#include "GeckoProfiler.h"
+#include "VRManagerParent.h"
+#include "VRShMem.h"
+#include "VRThread.h"
+#include "gfxVR.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/dom/VRDisplay.h"
+#include "mozilla/dom/GamepadEventTypes.h"
+#include "mozilla/layers/TextureHost.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Unused.h"
+#include "nsIObserverService.h"
+
+#include "gfxVR.h"
+#include <cstring>
+
+#include "ipc/VRLayerParent.h"
+#if !defined(MOZ_WIDGET_ANDROID)
+#  include "VRServiceHost.h"
+#endif
+
+#ifdef XP_WIN
+#  include "CompositorD3D11.h"
+#  include "TextureD3D11.h"
+#  include <d3d11.h>
+#  include "gfxWindowsPlatform.h"
+#  include "mozilla/gfx/DeviceManagerDx.h"
+#elif defined(XP_MACOSX)
+#  include "mozilla/gfx/MacIOSurface.h"
+#  include <errno.h>
+#elif defined(MOZ_WIDGET_ANDROID)
+#  include <string.h>
+#  include <pthread.h>
+#  include "GeckoVRManager.h"
+#  include "mozilla/java/GeckoSurfaceTextureWrappers.h"
+#  include "mozilla/layers/CompositorThread.h"
+#endif  // defined(MOZ_WIDGET_ANDROID)
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+using namespace mozilla::gl;
+
+using mozilla::dom::GamepadHandle;
+
+namespace mozilla::gfx {
+
+/**
+ * When VR content is active, we run the tasks at 1ms
+ * intervals, enabling multiple events to be processed
+ * per frame, such as haptic feedback pulses.
+ */
+const uint32_t kVRActiveTaskInterval = 1;  // milliseconds
+
+/**
+ * When VR content is inactive, we run the tasks at 100ms
+ * intervals, enabling VR display enumeration and
+ * presentation startup to be relatively responsive
+ * while not consuming unnecessary resources.
+ */
+const uint32_t kVRIdleTaskInterval = 100;  // milliseconds
+
+/**
+ * Max frame duration before the watchdog submits a new one.
+ * Probably we can get rid of this when we enforce that SubmitFrame can only be
+ * called in a VRDisplay loop.
+ */
+const double kVRMaxFrameSubmitDuration = 4000.0f;  // milliseconds
+
+static StaticRefPtr<VRManager> sVRManagerSingleton;
+
+static bool ValidVRManagerProcess() {
+  return XRE_IsParentProcess() || XRE_IsGPUProcess();
+}
+
+/* static */
+VRManager* VRManager::Get() {
+  MOZ_ASSERT(sVRManagerSingleton != nullptr);
+  MOZ_ASSERT(ValidVRManagerProcess());
+
+  return sVRManagerSingleton;
+}
+
+/* static */
+VRManager* VRManager::MaybeGet() {
+  MOZ_ASSERT(ValidVRManagerProcess());
+
+  return sVRManagerSingleton;
+}
+
+Atomic<uint32_t> VRManager::sDisplayBase(0);
+
+/* static */
+uint32_t VRManager::AllocateDisplayID() { return ++sDisplayBase; }
+
+/*static*/
+void VRManager::ManagerInit() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!ValidVRManagerProcess()) {
+    return;
+  }
+
+  // Enable gamepad extensions while VR is enabled.
+  // Preference only can be set at the Parent process.
+  if (StaticPrefs::dom_vr_enabled() && XRE_IsParentProcess()) {
+    Preferences::SetBool("dom.gamepad.extensions.enabled", true);
+  }
+
+  if (sVRManagerSingleton == nullptr) {
+    sVRManagerSingleton = new VRManager();
+    ClearOnShutdown(&sVRManagerSingleton);
+  }
+}
+
+VRManager::VRManager()
+    : mState(VRManagerState::Disabled),
+      mAccumulator100ms(0.0f),
+      mRuntimeDetectionRequested(false),
+      mRuntimeDetectionCompleted(false),
+      mEnumerationRequested(false),
+      mEnumerationCompleted(false),
+      mVRDisplaysRequested(false),
+      mVRDisplaysRequestedNonFocus(false),
+      mVRControllersRequested(false),
+      mFrameStarted(false),
+      mTaskInterval(0),
+      mCurrentSubmitTaskMonitor("CurrentSubmitTaskMonitor"),
+      mCurrentSubmitTask(nullptr),
+      mLastSubmittedFrameId(0),
+      mLastStartedFrame(0),
+      mRuntimeSupportFlags(VRDisplayCapabilityFlags::Cap_None),
+      mAppPaused(false),
+      mShmem(nullptr),
+      mHapticPulseRemaining{},
+      mDisplayInfo{},
+      mLastUpdateDisplayInfo{},
+      mBrowserState{},
+      mLastSensorState{} {
+  MOZ_ASSERT(sVRManagerSingleton == nullptr);
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(ValidVRManagerProcess());
+
+#if !defined(MOZ_WIDGET_ANDROID)
+  // XRE_IsGPUProcess() is helping us to check some platforms like
+  // Win 7 try which are not using GPU process but VR process is enabled.
+  mVRProcessEnabled =
+      StaticPrefs::dom_vr_process_enabled_AtStartup() && XRE_IsGPUProcess();
+  VRServiceHost::Init(mVRProcessEnabled);
+  mServiceHost = VRServiceHost::Get();
+  // We must shutdown before VRServiceHost, which is cleared
+  // 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)
+
+  nsCOMPtr<nsIObserverService> service = services::GetObserverService();
+  if (service) {
+    service->AddObserver(this, "application-background", false);
+    service->AddObserver(this, "application-foreground", false);
+  }
+}
+
+void VRManager::OpenShmem() {
+  if (mShmem == nullptr) {
+    mShmem = new VRShMem(nullptr, true /*aRequiresMutex*/);
+
+#if !defined(MOZ_WIDGET_ANDROID)
+    mShmem->CreateShMem(mVRProcessEnabled /*aCreateOnSharedMemory*/);
+    // 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;
+    }
+#else
+    mShmem->CreateShMemForAndroid();
+#endif
+  } else {
+    mShmem->ClearShMem();
+  }
+
+  // Reset local information for new connection
+  mDisplayInfo.Clear();
+  mLastUpdateDisplayInfo.Clear();
+  mFrameStarted = false;
+  mBrowserState.Clear();
+  mLastSensorState.Clear();
+  mEnumerationCompleted = false;
+  mDisplayInfo.mGroupMask = kVRGroupContent;
+}
+
+void VRManager::CloseShmem() {
+  if (mShmem != nullptr) {
+    mShmem->CloseShMem();
+    delete mShmem;
+    mShmem = nullptr;
+  }
+}
+
+VRManager::~VRManager() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mState == VRManagerState::Disabled);
+
+  nsCOMPtr<nsIObserverService> service = services::GetObserverService();
+  if (service) {
+    service->RemoveObserver(this, "application-background");
+    service->RemoveObserver(this, "application-foreground");
+  }
+
+#if !defined(MOZ_WIDGET_ANDROID)
+  mServiceHost->Shutdown();
+#endif
+  CloseShmem();
+}
+
+void VRManager::AddLayer(VRLayerParent* aLayer) {
+  mLayers.AppendElement(aLayer);
+  mDisplayInfo.mPresentingGroups |= aLayer->GetGroup();
+  if (mLayers.Length() == 1) {
+    StartPresentation();
+  }
+
+  // Ensure that the content process receives the change immediately
+  if (mState != VRManagerState::Enumeration &&
+      mState != VRManagerState::RuntimeDetection) {
+    DispatchVRDisplayInfoUpdate();
+  }
+}
+
+void VRManager::RemoveLayer(VRLayerParent* aLayer) {
+  mLayers.RemoveElement(aLayer);
+  if (mLayers.Length() == 0) {
+    StopPresentation();
+  }
+  mDisplayInfo.mPresentingGroups = 0;
+  for (auto layer : mLayers) {
+    mDisplayInfo.mPresentingGroups |= layer->GetGroup();
+  }
+
+  // Ensure that the content process receives the change immediately
+  if (mState != VRManagerState::Enumeration &&
+      mState != VRManagerState::RuntimeDetection) {
+    DispatchVRDisplayInfoUpdate();
+  }
+}
+
+void VRManager::AddVRManagerParent(VRManagerParent* aVRManagerParent) {
+  mVRManagerParents.PutEntry(aVRManagerParent);
+}
+
+void VRManager::RemoveVRManagerParent(VRManagerParent* aVRManagerParent) {
+  mVRManagerParents.RemoveEntry(aVRManagerParent);
+  if (mVRManagerParents.IsEmpty()) {
+    Destroy();
+  }
+}
+
+void VRManager::UpdateRequestedDevices() {
+  bool bHaveEventListener = false;
+  bool bHaveEventListenerNonFocus = false;
+  bool bHaveControllerListener = false;
+
+  for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
+    VRManagerParent* vmp = iter.Get()->GetKey();
+    bHaveEventListener |= vmp->HaveEventListener() && vmp->GetVRActiveStatus();
+    bHaveEventListenerNonFocus |=
+        vmp->HaveEventListener() && !vmp->GetVRActiveStatus();
+    bHaveControllerListener |= vmp->HaveControllerListener();
+  }
+
+  mVRDisplaysRequested = bHaveEventListener;
+  mVRDisplaysRequestedNonFocus = bHaveEventListenerNonFocus;
+  // We only currently allow controllers to be used when
+  // also activating a VR display
+  mVRControllersRequested = mVRDisplaysRequested && bHaveControllerListener;
+}
+
+/**
+ * VRManager::NotifyVsync must be called on every 2d vsync (usually at 60hz).
+ * This must be called even when no WebVR site is active.
+ * If we don't have a 2d display attached to the system, we can call this
+ * at the VR display's native refresh rate.
+ **/
+void VRManager::NotifyVsync(const TimeStamp& aVsyncTimestamp) {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  /**
+   * If the display isn't presenting, refresh the sensors and trigger
+   * VRDisplay.requestAnimationFrame at the normal 2d display refresh rate.
+   */
+  if (mDisplayInfo.mPresentingGroups == 0) {
+    StartFrame();
+  }
+}
+
+void VRManager::StartTasks() {
+  if (!mTaskTimer) {
+    mTaskInterval = GetOptimalTaskInterval();
+    mTaskTimer = NS_NewTimer();
+    mTaskTimer->SetTarget(CompositorThread());
+    mTaskTimer->InitWithNamedFuncCallback(
+        TaskTimerCallback, this, mTaskInterval,
+        nsITimer::TYPE_REPEATING_PRECISE_CAN_SKIP,
+        "VRManager::TaskTimerCallback");
+  }
+}
+
+void VRManager::StopTasks() {
+  if (mTaskTimer) {
+    mTaskTimer->Cancel();
+    mTaskTimer = nullptr;
+  }
+}
+
+/*static*/
+void VRManager::TaskTimerCallback(nsITimer* aTimer, void* aClosure) {
+  /**
+   * It is safe to use the pointer passed in aClosure to reference the
+   * VRManager object as the timer is canceled in VRManager::Destroy.
+   * VRManager::Destroy set mState to VRManagerState::Disabled, which
+   * is asserted in the VRManager destructor, guaranteeing that this
+   * functions runs if and only if the VRManager object is valid.
+   */
+  VRManager* self = static_cast<VRManager*>(aClosure);
+  self->RunTasks();
+
+  if (self->mAppPaused) {
+    // When the apps goes the background (e.g. Android) we should stop the
+    // tasks.
+    self->StopTasks();
+    self->mState = VRManagerState::Idle;
+  }
+}
+
+void VRManager::RunTasks() {
+  // Will be called once every 1ms when a VR presentation
+  // is active or once per vsync when a VR presentation is
+  // not active.
+
+  if (mState == VRManagerState::Disabled) {
+    // We may have been destroyed but still have messages
+    // in the queue from mTaskTimer.  Bail out to avoid
+    // running them.
+    return;
+  }
+
+  TimeStamp now = TimeStamp::Now();
+  double lastTickMs = mAccumulator100ms;
+  double deltaTime = 0.0f;
+  if (!mLastTickTime.IsNull()) {
+    deltaTime = (now - mLastTickTime).ToMilliseconds();
+  }
+  mAccumulator100ms += deltaTime;
+  mLastTickTime = now;
+
+  if (deltaTime > 0.0f && floor(mAccumulator100ms) != floor(lastTickMs)) {
+    // Even if more than 1 ms has passed, we will only
+    // execute Run1msTasks() once.
+    Run1msTasks(deltaTime);
+  }
+
+  if (floor(mAccumulator100ms * 0.1f) != floor(lastTickMs * 0.1f)) {
+    // Even if more than 10 ms has passed, we will only
+    // execute Run10msTasks() once.
+    Run10msTasks();
+  }
+
+  if (mAccumulator100ms >= 100.0f) {
+    // Even if more than 100 ms has passed, we will only
+    // execute Run100msTasks() once.
+    Run100msTasks();
+    mAccumulator100ms = fmod(mAccumulator100ms, 100.0f);
+  }
+
+  uint32_t optimalTaskInterval = GetOptimalTaskInterval();
+  if (mTaskTimer && optimalTaskInterval != mTaskInterval) {
+    mTaskTimer->SetDelay(optimalTaskInterval);
+    mTaskInterval = optimalTaskInterval;
+  }
+}
+
+uint32_t VRManager::GetOptimalTaskInterval() {
+  /**
+   * When either VR content is detected or VR hardware
+   * has already been activated, we schedule tasks more
+   * frequently.
+   */
+  bool wantGranularTasks = mVRDisplaysRequested || mVRControllersRequested ||
+                           mDisplayInfo.mDisplayID != 0;
+  if (wantGranularTasks) {
+    return kVRActiveTaskInterval;
+  }
+
+  return kVRIdleTaskInterval;
+}
+
+/**
+ * Run1msTasks() is guaranteed not to be
+ * called more than once within 1ms.
+ * When VR is not active, this will be
+ * called once per VSync if it wasn't
+ * called within the last 1ms.
+ */
+void VRManager::Run1msTasks(double aDeltaTime) { UpdateHaptics(aDeltaTime); }
+
+/**
+ * Run10msTasks() is guaranteed not to be
+ * called more than once within 10ms.
+ * When VR is not active, this will be
+ * called once per VSync if it wasn't
+ * called within the last 10ms.
+ */
+void VRManager::Run10msTasks() {
+  UpdateRequestedDevices();
+  CheckWatchDog();
+  ExpireNavigationTransition();
+  PullState();
+  PushState();
+}
+
+/**
+ * Run100msTasks() is guaranteed not to be
+ * called more than once within 100ms.
+ * When VR is not active, this will be
+ * called once per VSync if it wasn't
+ * called within the last 100ms.
+ */
+void VRManager::Run100msTasks() {
+  // We must continually refresh the VR display enumeration to check
+  // for events that we must fire such as Window.onvrdisplayconnect
+  // Note that enumeration itself may activate display hardware, such
+  // as Oculus, so we only do this when we know we are displaying content
+  // that is looking for VR displays.
+#if !defined(MOZ_WIDGET_ANDROID)
+  mServiceHost->Refresh();
+  CheckForPuppetCompletion();
+#endif
+  ProcessManagerState();
+}
+
+void VRManager::CheckForInactiveTimeout() {
+  // Shut down the VR devices when not in use
+  if (mVRDisplaysRequested || mVRDisplaysRequestedNonFocus ||
+      mVRControllersRequested || mEnumerationRequested ||
+      mRuntimeDetectionRequested || mState == VRManagerState::Enumeration ||
+      mState == VRManagerState::RuntimeDetection) {
+    // We are using a VR device, keep it alive
+    mLastActiveTime = TimeStamp::Now();
+  } else if (mLastActiveTime.IsNull()) {
+    Shutdown();
+  } else {
+    TimeDuration duration = TimeStamp::Now() - mLastActiveTime;
+    if (duration.ToMilliseconds() > StaticPrefs::dom_vr_inactive_timeout()) {
+      Shutdown();
+      // We must not throttle the next enumeration request
+      // after an idle timeout, as it may result in the
+      // user needing to refresh the browser to detect
+      // VR hardware when leaving and returning to a VR
+      // site.
+      mLastDisplayEnumerationTime = TimeStamp();
+    }
+  }
+}
+
+void VRManager::CheckForShutdown() {
+  // Check for remote end shutdown
+  if (mDisplayInfo.mDisplayState.shutdown) {
+    Shutdown();
+  }
+}
+
+#if !defined(MOZ_WIDGET_ANDROID)
+void VRManager::CheckForPuppetCompletion() {
+  // Notify content process about completion of puppet test resets
+  if (mState != VRManagerState::Active) {
+    for (auto iter = mManagerParentsWaitingForPuppetReset.Iter(); !iter.Done();
+         iter.Next()) {
+      Unused << iter.Get()->GetKey()->SendNotifyPuppetResetComplete();
+    }
+    mManagerParentsWaitingForPuppetReset.Clear();
+  }
+  // Notify content process about completion of puppet test scripts
+  if (mManagerParentRunningPuppet) {
+    mServiceHost->CheckForPuppetCompletion();
+  }
+}
+
+void VRManager::NotifyPuppetComplete() {
+  // Notify content process about completion of puppet test scripts
+  if (mManagerParentRunningPuppet) {
+    Unused << mManagerParentRunningPuppet
+                  ->SendNotifyPuppetCommandBufferCompleted(true);
+    mManagerParentRunningPuppet = nullptr;
+  }
+}
+
+#endif  // !defined(MOZ_WIDGET_ANDROID)
+
+void VRManager::StartFrame() {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  AUTO_PROFILER_TRACING_MARKER("VR", "GetSensorState", OTHER);
+
+  /**
+   * Do not start more VR frames until the last submitted frame is already
+   * processed, or the last has stalled for more than
+   * kVRMaxFrameSubmitDuration milliseconds.
+   */
+  TimeStamp now = TimeStamp::Now();
+  const TimeStamp lastFrameStart =
+      mLastFrameStart[mDisplayInfo.mFrameId % kVRMaxLatencyFrames];
+  const bool isPresenting = mLastUpdateDisplayInfo.GetPresentingGroups() != 0;
+  double duration =
+      lastFrameStart.IsNull() ? 0.0 : (now - lastFrameStart).ToMilliseconds();
+  if (isPresenting && mLastStartedFrame > 0 &&
+      mDisplayInfo.mDisplayState.lastSubmittedFrameId < mLastStartedFrame &&
+      duration < kVRMaxFrameSubmitDuration) {
+    return;
+  }
+
+  mDisplayInfo.mFrameId++;
+  size_t bufferIndex = mDisplayInfo.mFrameId % kVRMaxLatencyFrames;
+  mDisplayInfo.mLastSensorState[bufferIndex] = mLastSensorState;
+  mLastFrameStart[bufferIndex] = now;
+  mFrameStarted = true;
+  mLastStartedFrame = mDisplayInfo.mFrameId;
+
+  DispatchVRDisplayInfoUpdate();
+}
+
+void VRManager::DetectRuntimes() {
+  if (mState == VRManagerState::RuntimeDetection) {
+    // Runtime detection has already been started.
+    // This additional request will also receive the
+    // result from the first request.
+    return;
+  }
+
+  // Detect XR runtimes to determine if they are
+  // capable of supporting VR or AR sessions, while
+  // avoiding activating any XR devices or persistent
+  // background software.
+  if (mRuntimeDetectionCompleted) {
+    // We have already detected runtimes, so we can
+    // immediately respond with the same results.
+    // This will require the user to restart the browser
+    // after installing or removing an XR device
+    // runtime.
+    DispatchRuntimeCapabilitiesUpdate();
+    return;
+  }
+  mRuntimeDetectionRequested = true;
+  ProcessManagerState();
+}
+
+void VRManager::EnumerateDevices() {
+  if (mState == VRManagerState::Enumeration ||
+      (mRuntimeDetectionCompleted &&
+       (mVRDisplaysRequested || mEnumerationRequested))) {
+    // Enumeration has already been started.
+    // This additional request will also receive the
+    // result from the first request.
+    return;
+  }
+  // Activate XR runtimes and enumerate XR devices.
+  mEnumerationRequested = true;
+  ProcessManagerState();
+}
+
+void VRManager::ProcessManagerState() {
+  switch (mState) {
+    case VRManagerState::Disabled:
+      ProcessManagerState_Disabled();
+      break;
+    case VRManagerState::Idle:
+      ProcessManagerState_Idle();
+      break;
+    case VRManagerState::RuntimeDetection:
+      ProcessManagerState_DetectRuntimes();
+      break;
+    case VRManagerState::Enumeration:
+      ProcessManagerState_Enumeration();
+      break;
+    case VRManagerState::Active:
+      ProcessManagerState_Active();
+      break;
+    case VRManagerState::Stopping:
+      ProcessManagerState_Stopping();
+      break;
+  }
+  CheckForInactiveTimeout();
+  CheckForShutdown();
+}
+
+void VRManager::ProcessManagerState_Disabled() {
+  MOZ_ASSERT(mState == VRManagerState::Disabled);
+
+  if (!StaticPrefs::dom_vr_enabled()) {
+    return;
+  }
+
+  if (mRuntimeDetectionRequested || mEnumerationRequested ||
+      mVRDisplaysRequested) {
+    StartTasks();
+    mState = VRManagerState::Idle;
+  }
+}
+
+void VRManager::ProcessManagerState_Stopping() {
+  MOZ_ASSERT(mState == VRManagerState::Stopping);
+  PullState();
+  /**
+   * In the case of Desktop, the VRService shuts itself down.
+   * Before it's finished stopping, it sets a flag in the ShMem
+   * to let VRManager know that it's done.  VRManager watches for
+   * this flag and transitions out of the VRManagerState::Stopping
+   * state to VRManagerState::Idle.
+   */
+#if defined(MOZ_WIDGET_ANDROID)
+  // On Android, the VR service never actually shuts
+  // down or requests VRManager to stop.
+  Shutdown();
+#endif  // defined(MOZ_WIDGET_ANDROID)
+}
+
+void VRManager::ProcessManagerState_Idle_StartEnumeration() {
+  MOZ_ASSERT(mState == VRManagerState::Idle);
+
+  if (!mEarliestRestartTime.IsNull() &&
+      mEarliestRestartTime > TimeStamp::Now()) {
+    // When the VR Service shuts down it informs us of how long we
+    // must wait until we can re-start it.
+    // We must wait until mEarliestRestartTime before attempting
+    // to enumerate again.
+    return;
+  }
+
+  /**
+   * Throttle the rate of enumeration to the interval set in
+   * VRDisplayEnumerateInterval
+   */
+  if (!mLastDisplayEnumerationTime.IsNull()) {
+    TimeDuration duration = TimeStamp::Now() - mLastDisplayEnumerationTime;
+    if (duration.ToMilliseconds() <
+        StaticPrefs::dom_vr_display_enumerate_interval()) {
+      return;
+    }
+  }
+
+  /**
+   * If we get this far, don't try again until
+   * the VRDisplayEnumerateInterval elapses
+   */
+  mLastDisplayEnumerationTime = TimeStamp::Now();
+
+  OpenShmem();
+
+  mEnumerationRequested = false;
+  // We must block until enumeration has completed in order
+  // to signal that the WebVR promise should be resolved at the
+  // right time.
+#if defined(MOZ_WIDGET_ANDROID)
+  // In Android, we need to make sure calling
+  // GeckoVRManager::SetExternalContext() from an external VR service
+  // before doing enumeration.
+  if (!mShmem->GetExternalShmem()) {
+    mShmem->CreateShMemForAndroid();
+  }
+  if (mShmem->GetExternalShmem()) {
+    mState = VRManagerState::Enumeration;
+  } else {
+    // Not connected to shmem, so no devices to enumerate.
+    mDisplayInfo.Clear();
+    DispatchVRDisplayInfoUpdate();
+  }
+#else
+
+  PushState();
+
+  /**
+   * We must start the VR Service thread
+   * and VR Process before enumeration.
+   * We don't want to start this until we will
+   * actualy enumerate, to avoid continuously
+   * re-launching the thread/process when
+   * no hardware is found or a VR software update
+   * is in progress
+   */
+  mServiceHost->StartService();
+  mState = VRManagerState::Enumeration;
+#endif  // MOZ_WIDGET_ANDROID
+}
+
+void VRManager::ProcessManagerState_Idle_StartRuntimeDetection() {
+  MOZ_ASSERT(mState == VRManagerState::Idle);
+
+  OpenShmem();
+  mBrowserState.detectRuntimesOnly = true;
+  mRuntimeDetectionRequested = false;
+
+  // We must block until enumeration has completed in order
+  // to signal that the WebVR promise should be resolved at the
+  // right time.
+#if defined(MOZ_WIDGET_ANDROID)
+  // In Android, we need to make sure calling
+  // GeckoVRManager::SetExternalContext() from an external VR service
+  // before doing enumeration.
+  if (!mShmem->GetExternalShmem()) {
+    mShmem->CreateShMemForAndroid();
+  }
+  if (mShmem->GetExternalShmem()) {
+    mState = VRManagerState::RuntimeDetection;
+  } else {
+    // Not connected to shmem, so no runtimes to detect.
+    mRuntimeSupportFlags = VRDisplayCapabilityFlags::Cap_None;
+    mRuntimeDetectionCompleted = true;
+    DispatchRuntimeCapabilitiesUpdate();
+  }
+#else
+
+  PushState();
+
+  /**
+   * We must start the VR Service thread
+   * and VR Process before enumeration.
+   * We don't want to start this until we will
+   * actualy enumerate, to avoid continuously
+   * re-launching the thread/process when
+   * no hardware is found or a VR software update
+   * is in progress
+   */
+  mServiceHost->StartService();
+  mState = VRManagerState::RuntimeDetection;
+#endif  // MOZ_WIDGET_ANDROID
+}
+
+void VRManager::ProcessManagerState_Idle() {
+  MOZ_ASSERT(mState == VRManagerState::Idle);
+
+  if (!mRuntimeDetectionCompleted) {
+    // Check if we should start detecting runtimes
+    // We must alwasy detect runtimes before doing anything
+    // else with the VR process.
+    // This will happen only once per browser startup.
+    if (mRuntimeDetectionRequested || mEnumerationRequested) {
+      ProcessManagerState_Idle_StartRuntimeDetection();
+    }
+    return;
+  }
+
+  // Check if we should start activating enumerating XR hardware
+  if (mRuntimeDetectionCompleted &&
+      (mVRDisplaysRequested || mEnumerationRequested)) {
+    ProcessManagerState_Idle_StartEnumeration();
+  }
+}
+
+void VRManager::ProcessManagerState_DetectRuntimes() {
+  MOZ_ASSERT(mState == VRManagerState::RuntimeDetection);
+  MOZ_ASSERT(mShmem != nullptr);
+
+  PullState();
+  if (mEnumerationCompleted) {
+    /**
+     * When mBrowserState.detectRuntimesOnly is set, the
+     * VRService and VR process will shut themselves down
+     * automatically after detecting runtimes.
+     * mEnumerationCompleted is also used in this case,
+     * but to mean "enumeration of runtimes" not
+     * "enumeration of VR devices".
+     *
+     * We set mState to `VRManagerState::Stopping`
+     * to make sure that we don't try to do anything
+     * else with the active VRService until it has stopped.
+     * We must start another one when an XR session will be
+     * requested.
+     *
+     * This logic is optimized for the WebXR design, but still
+     * works for WebVR so it can continue to function until
+     * deprecated and removed.
+     */
+    mState = VRManagerState::Stopping;
+    mRuntimeSupportFlags = mDisplayInfo.mDisplayState.capabilityFlags &
+                           (VRDisplayCapabilityFlags::Cap_ImmersiveVR |
+                            VRDisplayCapabilityFlags::Cap_ImmersiveAR |
+                            VRDisplayCapabilityFlags::Cap_Inline);
+    mRuntimeDetectionCompleted = true;
+    DispatchRuntimeCapabilitiesUpdate();
+  }
+}
+
+void VRManager::ProcessManagerState_Enumeration() {
+  MOZ_ASSERT(mState == VRManagerState::Enumeration);
+  MOZ_ASSERT(mShmem != nullptr);
+
+  PullState();
+  if (mEnumerationCompleted) {
+    if (mDisplayInfo.mDisplayState.isConnected) {
+      mDisplayInfo.mDisplayID = VRManager::AllocateDisplayID();
+      mState = VRManagerState::Active;
+    } else {
+      mDisplayInfo.Clear();
+      mState = VRManagerState::Stopping;
+    }
+    DispatchVRDisplayInfoUpdate();
+  }
+}
+
+void VRManager::ProcessManagerState_Active() {
+  MOZ_ASSERT(mState == VRManagerState::Active);
+
+  if (mDisplayInfo != mLastUpdateDisplayInfo) {
+    // While the display is active, send continuous updates
+    DispatchVRDisplayInfoUpdate();
+  }
+}
+
+void VRManager::DispatchVRDisplayInfoUpdate() {
+  for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
+    Unused << iter.Get()->GetKey()->SendUpdateDisplayInfo(mDisplayInfo);
+  }
+  mLastUpdateDisplayInfo = mDisplayInfo;
+}
+
+void VRManager::DispatchRuntimeCapabilitiesUpdate() {
+  VRDisplayCapabilityFlags flags = mRuntimeSupportFlags;
+  if (StaticPrefs::dom_vr_always_support_vr()) {
+    flags |= VRDisplayCapabilityFlags::Cap_ImmersiveVR;
+  }
+
+  if (StaticPrefs::dom_vr_always_support_ar()) {
+    flags |= VRDisplayCapabilityFlags::Cap_ImmersiveAR;
+  }
+
+  for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
+    Unused << iter.Get()->GetKey()->SendUpdateRuntimeCapabilities(flags);
+  }
+}
+
+void VRManager::StopAllHaptics() {
+  for (size_t i = 0; i < mozilla::ArrayLength(mBrowserState.hapticState); i++) {
+    ClearHapticSlot(i);
+  }
+  PushState();
+}
+
+void VRManager::VibrateHaptic(GamepadHandle aGamepadHandle,
+                              uint32_t aHapticIndex, double aIntensity,
+                              double aDuration,
+                              const VRManagerPromise& aPromise)
+
+{
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  // VRDisplayClient::FireGamepadEvents() assigns a controller ID with
+  // ranges based on displayID.  We must translate this to the indexes
+  // understood by VRDisplayExternal.
+  uint32_t controllerBaseIndex =
+      kVRControllerMaxCount * mDisplayInfo.mDisplayID;
+  uint32_t controllerIndex = aGamepadHandle.GetValue() - controllerBaseIndex;
+
+  TimeStamp now = TimeStamp::Now();
+  size_t bestSlotIndex = 0;
+  // Default to an empty slot, or the slot holding the oldest haptic pulse
+  for (size_t i = 0; i < mozilla::ArrayLength(mBrowserState.hapticState); i++) {
+    const VRHapticState& state = mBrowserState.hapticState[i];
+    if (state.inputFrameID == 0) {
+      // Unused slot, use it
+      bestSlotIndex = i;
+      break;
+    }
+    if (mHapticPulseRemaining[i] < mHapticPulseRemaining[bestSlotIndex]) {
+      // If no empty slots are available, fall back to overriding
+      // the pulse which is ending soonest.
+      bestSlotIndex = i;
+    }
+  }
+  // Override the last pulse on the same actuator if present.
+  for (size_t i = 0; i < mozilla::ArrayLength(mBrowserState.hapticState); i++) {
+    const VRHapticState& state = mBrowserState.hapticState[i];
+    if (state.inputFrameID == 0) {
+      // This is an empty slot -- no match
+      continue;
+    }
+    if (state.controllerIndex == controllerIndex &&
+        state.hapticIndex == aHapticIndex) {
+      // Found pulse on same actuator -- let's override it.
+      bestSlotIndex = i;
+    }
+  }
+  ClearHapticSlot(bestSlotIndex);
+
+  // Populate the selected slot with new haptic state
+  size_t bufferIndex = mDisplayInfo.mFrameId % kVRMaxLatencyFrames;
+  VRHapticState& bestSlot = mBrowserState.hapticState[bestSlotIndex];
+  bestSlot.inputFrameID =
+      mDisplayInfo.mLastSensorState[bufferIndex].inputFrameID;
+  bestSlot.controllerIndex = controllerIndex;
+  bestSlot.hapticIndex = aHapticIndex;
+  bestSlot.pulseStart = (float)(now - mLastFrameStart[bufferIndex]).ToSeconds();
+  bestSlot.pulseDuration =
+      (float)aDuration * 0.001f;  // Convert from ms to seconds
+  bestSlot.pulseIntensity = (float)aIntensity;
+
+  mHapticPulseRemaining[bestSlotIndex] = aDuration;
+  MOZ_ASSERT(bestSlotIndex <= mHapticPromises.Length());
+  if (bestSlotIndex == mHapticPromises.Length()) {
+    mHapticPromises.AppendElement(
+        UniquePtr<VRManagerPromise>(new VRManagerPromise(aPromise)));
+  } else {
+    mHapticPromises[bestSlotIndex] =
+        UniquePtr<VRManagerPromise>(new VRManagerPromise(aPromise));
+  }
+  PushState();
+}
+
+void VRManager::StopVibrateHaptic(GamepadHandle aGamepadHandle) {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  // VRDisplayClient::FireGamepadEvents() assigns a controller ID with
+  // ranges based on displayID.  We must translate this to the indexes
+  // understood by VRDisplayExternal.
+  uint32_t controllerBaseIndex =
+      kVRControllerMaxCount * mDisplayInfo.mDisplayID;
+  uint32_t controllerIndex = aGamepadHandle.GetValue() - controllerBaseIndex;
+
+  for (size_t i = 0; i < mozilla::ArrayLength(mBrowserState.hapticState); i++) {
+    VRHapticState& state = mBrowserState.hapticState[i];
+    if (state.controllerIndex == controllerIndex) {
+      memset(&state, 0, sizeof(VRHapticState));
+    }
+  }
+  PushState();
+}
+
+void VRManager::NotifyVibrateHapticCompleted(const VRManagerPromise& aPromise) {
+  aPromise.mParent->SendReplyGamepadVibrateHaptic(aPromise.mPromiseID);
+}
+
+void VRManager::StartVRNavigation(const uint32_t& aDisplayID) {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  /**
+   * We only support a single VRSession with a single VR display at a
+   * time; however, due to the asynchronous nature of the API, it's possible
+   * that the previously used VR display was a different one than the one now
+   * allocated. We catch these cases to avoid automatically activating the new
+   * VR displays. This situation is expected to be very rare and possibly never
+   * seen. Perhaps further simplification could be made in the content process
+   * code which passes around displayID's that may no longer be needed.
+   **/
+  if (mDisplayInfo.GetDisplayID() != aDisplayID) {
+    return;
+  }
+  mBrowserState.navigationTransitionActive = true;
+  mVRNavigationTransitionEnd = TimeStamp();
+  PushState();
+}
+
+void VRManager::StopVRNavigation(const uint32_t& aDisplayID,
+                                 const TimeDuration& aTimeout) {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  if (mDisplayInfo.GetDisplayID() != aDisplayID) {
+    return;
+  }
+  if (aTimeout.ToMilliseconds() <= 0) {
+    mBrowserState.navigationTransitionActive = false;
+    mVRNavigationTransitionEnd = TimeStamp();
+    PushState();
+  }
+  mVRNavigationTransitionEnd = TimeStamp::Now() + aTimeout;
+}
+
+#if !defined(MOZ_WIDGET_ANDROID)
+
+bool VRManager::RunPuppet(const nsTArray<uint64_t>& aBuffer,
+                          VRManagerParent* aManagerParent) {
+  if (!StaticPrefs::dom_vr_puppet_enabled()) {
+    // Sanity check to ensure that a compromised content process
+    // can't use this to escalate permissions.
+    return false;
+  }
+  if (mManagerParentRunningPuppet != nullptr) {
+    // Only one parent may run a puppet at a time
+    return false;
+  }
+  mManagerParentRunningPuppet = aManagerParent;
+  mServiceHost->PuppetSubmit(aBuffer);
+  return true;
+}
+
+void VRManager::ResetPuppet(VRManagerParent* aManagerParent) {
+  mManagerParentsWaitingForPuppetReset.PutEntry(aManagerParent);
+  if (mManagerParentRunningPuppet != nullptr) {
+    Unused << mManagerParentRunningPuppet
+                  ->SendNotifyPuppetCommandBufferCompleted(false);
+    mManagerParentRunningPuppet = nullptr;
+  }
+  mServiceHost->PuppetReset();
+  // In the event that we are shut down, the task timer won't be running
+  // to trigger CheckForPuppetCompletion.
+  // In this case, CheckForPuppetCompletion() would immediately resolve
+  // the promises for mManagerParentsWaitingForPuppetReset.
+  // We can simply call it once here to handle that case.
+  CheckForPuppetCompletion();
+}
+
+#endif  // !defined(MOZ_WIDGET_ANDROID)
+
+void VRManager::PullState(
+    const std::function<bool()>& aWaitCondition /* = nullptr */) {
+  if (mShmem != nullptr) {
+    mShmem->PullSystemState(mDisplayInfo.mDisplayState, mLastSensorState,
+                            mDisplayInfo.mControllerState,
+                            mEnumerationCompleted, aWaitCondition);
+  }
+}
+
+void VRManager::PushState(bool aNotifyCond) {
+  if (mShmem != nullptr) {
+    mShmem->PushBrowserState(mBrowserState, aNotifyCond);
+  }
+}
+
+void VRManager::Destroy() {
+  if (mState == VRManagerState::Disabled) {
+    return;
+  }
+  Shutdown();
+  StopTasks();
+  mState = VRManagerState::Disabled;
+}
+
+void VRManager::Shutdown() {
+  if (mState == VRManagerState::Disabled || mState == VRManagerState::Idle) {
+    return;
+  }
+
+  if (mDisplayInfo.mDisplayState.shutdown) {
+    // Shutdown was requested by VR Service, so we must throttle
+    // as requested by the VR Service
+    TimeStamp now = TimeStamp::Now();
+    mEarliestRestartTime =
+        now + TimeDuration::FromMilliseconds(
+                  (double)mDisplayInfo.mDisplayState.minRestartInterval);
+  }
+
+  StopAllHaptics();
+  StopPresentation();
+  CancelCurrentSubmitTask();
+  ShutdownSubmitThread();
+
+  mDisplayInfo.Clear();
+  mEnumerationCompleted = false;
+
+  if (mState == VRManagerState::RuntimeDetection) {
+    /**
+     * We have failed to detect runtimes before shutting down.
+     * Ensure that promises are resolved
+     *
+     * This call to DispatchRuntimeCapabilitiesUpdate will only
+     * happen when we have failed to detect runtimes. In that case,
+     * mRuntimeSupportFlags will be 0 and send the correct message
+     * to the content process.
+     *
+     * When we are successful, we store the result in mRuntimeSupportFlags
+     * and never try again unless the browser is restarted. mRuntimeSupportFlags
+     * is never reset back to 0 in that case but we will never re-enter the
+     * VRManagerState::RuntimeDetection state and hit this code path again.
+     */
+    DispatchRuntimeCapabilitiesUpdate();
+  }
+
+  if (mState == VRManagerState::Enumeration) {
+    // We have failed to enumerate VR devices before shutting down.
+    // Ensure that promises are resolved
+    DispatchVRDisplayInfoUpdate();
+  }
+
+#if !defined(MOZ_WIDGET_ANDROID)
+  mServiceHost->StopService();
+#endif
+  mState = VRManagerState::Idle;
+
+  // We will close Shmem in the DTOR to avoid
+  // mSubmitThread is still running but its shmem
+  // has been released.
+}
+
+void VRManager::ShutdownVRManagerParents() {
+  // Close removes the CanvasParent from the set so take a copy first.
+  VRManagerParentSet vrManagerParents;
+  for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
+    vrManagerParents.PutEntry(iter.Get()->GetKey());
+  }
+
+  for (auto iter = vrManagerParents.Iter(); !iter.Done(); iter.Next()) {
+    iter.Get()->GetKey()->Close();
+    iter.Remove();
+  }
+
+  MOZ_DIAGNOSTIC_ASSERT(mVRManagerParents.IsEmpty(),
+                        "Closing should have cleared all entries.");
+}
+
+void VRManager::CheckWatchDog() {
+  /**
+   * We will trigger a new frame immediately after a successful frame
+   * texture submission.  If content fails to call VRDisplay.submitFrame
+   * after dom.vr.display.rafMaxDuration milliseconds has elapsed since the
+   * last VRDisplay.requestAnimationFrame, we act as a "watchdog" and
+   * kick-off a new VRDisplay.requestAnimationFrame to avoid a render loop
+   * stall and to give content a chance to recover.
+   *
+   * If the lower level VR platform API's are rejecting submitted frames,
+   * such as when the Oculus "Health and Safety Warning" is displayed,
+   * we will not kick off the next frame immediately after
+   * VRDisplay.submitFrame as it would result in an unthrottled render loop
+   * that would free run at potentially extreme frame rates.  To ensure that
+   * content has a chance to resume its presentation when the frames are
+   * accepted once again, we rely on this "watchdog" to act as a VR refresh
+   * driver cycling at a rate defined by dom.vr.display.rafMaxDuration.
+   *
+   * This number must be larger than the slowest expected frame time during
+   * normal VR presentation, but small enough not to break content that
+   * makes assumptions of reasonably minimal VSync rate.
+   *
+   * The slowest expected refresh rate for a VR display currently is an
+   * Oculus CV1 when ASW (Asynchronous Space Warp) is enabled, at 45hz.
+   * A dom.vr.display.rafMaxDuration value of 50 milliseconds results in a
+   * 20hz rate, which avoids inadvertent triggering of the watchdog during
+   * Oculus ASW even if every second frame is dropped.
+   */
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  bool bShouldStartFrame = false;
+
+  // If content fails to call VRDisplay.submitFrame, we must eventually
+  // time-out and trigger a new frame.
+  TimeStamp lastFrameStart =
+      mLastFrameStart[mDisplayInfo.mFrameId % kVRMaxLatencyFrames];
+  if (lastFrameStart.IsNull()) {
+    bShouldStartFrame = true;
+  } else {
+    TimeDuration duration = TimeStamp::Now() - lastFrameStart;
+    if (duration.ToMilliseconds() >
+        StaticPrefs::dom_vr_display_rafMaxDuration()) {
+      bShouldStartFrame = true;
+    }
+  }
+
+  if (bShouldStartFrame) {
+    StartFrame();
+  }
+}
+
+void VRManager::ExpireNavigationTransition() {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  if (!mVRNavigationTransitionEnd.IsNull() &&
+      TimeStamp::Now() > mVRNavigationTransitionEnd) {
+    mBrowserState.navigationTransitionActive = false;
+  }
+}
+
+void VRManager::UpdateHaptics(double aDeltaTime) {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  bool bNeedPush = false;
+  // Check for any haptic pulses that have ended and clear them
+  for (size_t i = 0; i < mozilla::ArrayLength(mBrowserState.hapticState); i++) {
+    const VRHapticState& state = mBrowserState.hapticState[i];
+    if (state.inputFrameID == 0) {
+      // Nothing in this slot
+      continue;
+    }
+    mHapticPulseRemaining[i] -= aDeltaTime;
+    if (mHapticPulseRemaining[i] <= 0.0f) {
+      // The pulse has finished
+      ClearHapticSlot(i);
+      bNeedPush = true;
+    }
+  }
+  if (bNeedPush) {
+    PushState();
+  }
+}
+
+void VRManager::ClearHapticSlot(size_t aSlot) {
+  MOZ_ASSERT(aSlot < mozilla::ArrayLength(mBrowserState.hapticState));
+  memset(&mBrowserState.hapticState[aSlot], 0, sizeof(VRHapticState));
+  mHapticPulseRemaining[aSlot] = 0.0f;
+  if (aSlot < mHapticPromises.Length() && mHapticPromises[aSlot]) {
+    NotifyVibrateHapticCompleted(*(mHapticPromises[aSlot]));
+    mHapticPromises[aSlot] = nullptr;
+  }
+}
+
+void VRManager::ShutdownSubmitThread() {
+  if (mSubmitThread) {
+    mSubmitThread->Shutdown();
+    mSubmitThread = nullptr;
+  }
+}
+
+void VRManager::StartPresentation() {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  if (mBrowserState.presentationActive) {
+    return;
+  }
+  mTelemetry.Clear();
+  mTelemetry.mPresentationStart = TimeStamp::Now();
+
+  // Indicate that we are ready to start immersive mode
+  mBrowserState.presentationActive = true;
+  mBrowserState.layerState[0].type = VRLayerType::LayerType_Stereo_Immersive;
+  PushState();
+
+  mDisplayInfo.mDisplayState.lastSubmittedFrameId = 0;
+  if (mDisplayInfo.mDisplayState.reportsDroppedFrames) {
+    mTelemetry.mLastDroppedFrameCount =
+        mDisplayInfo.mDisplayState.droppedFrameCount;
+  }
+
+  mLastSubmittedFrameId = 0;
+  mLastStartedFrame = 0;
+}
+
+void VRManager::StopPresentation() {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  if (!mBrowserState.presentationActive) {
+    return;
+  }
+
+  // Indicate that we have stopped immersive mode
+  mBrowserState.presentationActive = false;
+  memset(mBrowserState.layerState, 0,
+         sizeof(VRLayerState) * mozilla::ArrayLength(mBrowserState.layerState));
+
+  PushState(true);
+
+  Telemetry::HistogramID timeSpentID = Telemetry::HistogramCount;
+  Telemetry::HistogramID droppedFramesID = Telemetry::HistogramCount;
+  int viewIn = 0;
+
+  if (mDisplayInfo.mDisplayState.eightCC ==
+      GFX_VR_EIGHTCC('O', 'c', 'u', 'l', 'u', 's', ' ', 'D')) {
+    // Oculus Desktop API
+    timeSpentID = Telemetry::WEBVR_TIME_SPENT_VIEWING_IN_OCULUS;
+    droppedFramesID = Telemetry::WEBVR_DROPPED_FRAMES_IN_OCULUS;
+    viewIn = 1;
+  } else if (mDisplayInfo.mDisplayState.eightCC ==
+             GFX_VR_EIGHTCC('O', 'p', 'e', 'n', 'V', 'R', ' ', ' ')) {
+    // OpenVR API
+    timeSpentID = Telemetry::WEBVR_TIME_SPENT_VIEWING_IN_OPENVR;
+    droppedFramesID = Telemetry::WEBVR_DROPPED_FRAMES_IN_OPENVR;
+    viewIn = 2;
+  }
+
+  if (viewIn) {
+    const TimeDuration duration =
+        TimeStamp::Now() - mTelemetry.mPresentationStart;
+    Telemetry::Accumulate(Telemetry::WEBVR_USERS_VIEW_IN, viewIn);
+    Telemetry::Accumulate(timeSpentID, duration.ToMilliseconds());
+    const uint32_t droppedFramesPerSec =
+        (uint32_t)((double)(mDisplayInfo.mDisplayState.droppedFrameCount -
+                            mTelemetry.mLastDroppedFrameCount) /
+                   duration.ToSeconds());
+    Telemetry::Accumulate(droppedFramesID, droppedFramesPerSec);
+  }
+}
+
+bool VRManager::IsPresenting() {
+  if (mShmem) {
+    return mDisplayInfo.mPresentingGroups != 0;
+  }
+  return false;
+}
+
+void VRManager::SetGroupMask(uint32_t aGroupMask) {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  mDisplayInfo.mGroupMask = aGroupMask;
+}
+
+void VRManager::SubmitFrame(VRLayerParent* aLayer,
+                            const layers::SurfaceDescriptor& aTexture,
+                            uint64_t aFrameId, const gfx::Rect& aLeftEyeRect,
+                            const gfx::Rect& aRightEyeRect) {
+  if (mState != VRManagerState::Active) {
+    return;
+  }
+  MonitorAutoLock lock(mCurrentSubmitTaskMonitor);
+  if ((mDisplayInfo.mGroupMask & aLayer->GetGroup()) == 0) {
+    // Suppress layers hidden by the group mask
+    return;
+  }
+
+  // Ensure that we only accept the first SubmitFrame call per RAF cycle.
+  if (!mFrameStarted || aFrameId != mDisplayInfo.mFrameId) {
+    return;
+  }
+
+  /**
+   * Do not queue more submit frames until the last submitted frame is
+   * already processed and the new WebGL texture is ready.
+   */
+  if (mLastSubmittedFrameId > 0 &&
+      mLastSubmittedFrameId !=
+          mDisplayInfo.mDisplayState.lastSubmittedFrameId) {
+    mLastStartedFrame = 0;
+    return;
+  }
+
+  mLastSubmittedFrameId = aFrameId;
+
+  mFrameStarted = false;
+
+  RefPtr<CancelableRunnable> task = NewCancelableRunnableMethod<
+      StoreCopyPassByConstLRef<layers::SurfaceDescriptor>, uint64_t,
+      StoreCopyPassByConstLRef<gfx::Rect>, StoreCopyPassByConstLRef<gfx::Rect>>(
+      "gfx::VRManager::SubmitFrameInternal", this,
+      &VRManager::SubmitFrameInternal, aTexture, aFrameId, aLeftEyeRect,
+      aRightEyeRect);
+
+  if (!mCurrentSubmitTask) {
+    mCurrentSubmitTask = task;
+#if !defined(MOZ_WIDGET_ANDROID)
+    if (!mSubmitThread) {
+      mSubmitThread = new VRThread("VR_SubmitFrame"_ns);
+    }
+    mSubmitThread->Start();
+    mSubmitThread->PostTask(task.forget());
+#else
+    CompositorThread()->Dispatch(task.forget());
+#endif  // defined(MOZ_WIDGET_ANDROID)
+  }
+}
+
+bool VRManager::SubmitFrame(const layers::SurfaceDescriptor& aTexture,
+                            uint64_t aFrameId, const gfx::Rect& aLeftEyeRect,
+                            const gfx::Rect& aRightEyeRect) {
+  if (mState != VRManagerState::Active) {
+    return false;
+  }
+#if defined(XP_WIN) || defined(XP_MACOSX) || defined(MOZ_WIDGET_ANDROID)
+  MOZ_ASSERT(mBrowserState.layerState[0].type ==
+             VRLayerType::LayerType_Stereo_Immersive);
+  VRLayer_Stereo_Immersive& layer =
+      mBrowserState.layerState[0].layer_stereo_immersive;
+
+  switch (aTexture.type()) {
+#  if defined(XP_WIN)
+    case SurfaceDescriptor::TSurfaceDescriptorD3D10: {
+      const SurfaceDescriptorD3D10& surf =
+          aTexture.get_SurfaceDescriptorD3D10();
+      layer.textureType =
+          VRLayerTextureType::LayerTextureType_D3D10SurfaceDescriptor;
+      layer.textureHandle = (void*)surf.handle();
+      layer.textureSize.width = surf.size().width;
+      layer.textureSize.height = surf.size().height;
+    } break;
+#  elif defined(XP_MACOSX)
+    case SurfaceDescriptor::TSurfaceDescriptorMacIOSurface: {
+      // MacIOSurface ptr can't be fetched or used at different threads.
+      // Both of fetching and using this MacIOSurface are at the VRService
+      // thread.
+      const auto& desc = aTexture.get_SurfaceDescriptorMacIOSurface();
+      layer.textureType = VRLayerTextureType::LayerTextureType_MacIOSurface;
+      layer.textureHandle = desc.surfaceId();
+      RefPtr<MacIOSurface> surf =
+          MacIOSurface::LookupSurface(desc.surfaceId(), desc.scaleFactor(),
+                                      !desc.isOpaque(), desc.yUVColorSpace());
+      if (surf) {
+        layer.textureSize.width = surf->GetDevicePixelWidth();
+        layer.textureSize.height = surf->GetDevicePixelHeight();
+      }
+    } break;
+#  elif defined(MOZ_WIDGET_ANDROID)
+    case SurfaceDescriptor::TSurfaceTextureDescriptor: {
+      const SurfaceTextureDescriptor& desc =
+          aTexture.get_SurfaceTextureDescriptor();
+      java::GeckoSurfaceTexture::LocalRef surfaceTexture =
+          java::GeckoSurfaceTexture::Lookup(desc.handle());
+      if (!surfaceTexture) {
+        NS_WARNING("VRManager::SubmitFrame failed to get a SurfaceTexture");
+        return false;
+      }
+      layer.textureType =
+          VRLayerTextureType::LayerTextureType_GeckoSurfaceTexture;
+      layer.textureHandle = desc.handle();
+      layer.textureSize.width = desc.size().width;
+      layer.textureSize.height = desc.size().height;
+    } break;
+#  endif
+    default: {
+      MOZ_ASSERT(false);
+      return false;
+    }
+  }
+
+  layer.frameId = aFrameId;
+  layer.inputFrameId =
+      mDisplayInfo.mLastSensorState[mDisplayInfo.mFrameId % kVRMaxLatencyFrames]
+          .inputFrameID;
+
+  layer.leftEyeRect.x = aLeftEyeRect.x;
+  layer.leftEyeRect.y = aLeftEyeRect.y;
+  layer.leftEyeRect.width = aLeftEyeRect.width;
+  layer.leftEyeRect.height = aLeftEyeRect.height;
+  layer.rightEyeRect.x = aRightEyeRect.x;
+  layer.rightEyeRect.y = aRightEyeRect.y;
+  layer.rightEyeRect.width = aRightEyeRect.width;
+  layer.rightEyeRect.height = aRightEyeRect.height;
+
+  PushState(true);
+
+  PullState([&]() {
+    return (mDisplayInfo.mDisplayState.lastSubmittedFrameId >= aFrameId) ||
+           mDisplayInfo.mDisplayState.suppressFrames ||
+           !mDisplayInfo.mDisplayState.isConnected;
+  });
+
+  if (mDisplayInfo.mDisplayState.suppressFrames ||
+      !mDisplayInfo.mDisplayState.isConnected) {
+    // External implementation wants to supress frames, service has shut
+    // down or hardware has been disconnected.
+    return false;
+  }
+
+  return mDisplayInfo.mDisplayState.lastSubmittedFrameSuccessful;
+#else
+  MOZ_ASSERT(false);  // Not implmented for this platform
+  return false;
+#endif
+}
+
+void VRManager::SubmitFrameInternal(const layers::SurfaceDescriptor& aTexture,
+                                    uint64_t aFrameId,
+                                    const gfx::Rect& aLeftEyeRect,
+                                    const gfx::Rect& aRightEyeRect) {
+#if !defined(MOZ_WIDGET_ANDROID)
+  MOZ_ASSERT(mSubmitThread->GetThread() == NS_GetCurrentThread());
+#endif  // !defined(MOZ_WIDGET_ANDROID)
+  AUTO_PROFILER_TRACING_MARKER("VR", "SubmitFrameAtVRDisplayExternal", OTHER);
+
+  {  // scope lock
+    MonitorAutoLock lock(mCurrentSubmitTaskMonitor);
+
+    if (!SubmitFrame(aTexture, aFrameId, aLeftEyeRect, aRightEyeRect)) {
+      mCurrentSubmitTask = nullptr;
+      return;
+    }
+    mCurrentSubmitTask = nullptr;
+  }
+
+#if defined(XP_WIN) || defined(XP_MACOSX)
+
+  /**
+   * Trigger the next VSync immediately after we are successfully
+   * submitting frames.  As SubmitFrame is responsible for throttling
+   * the render loop, if we don't successfully call it, we shouldn't trigger
+   * StartFrame immediately, as it will run unbounded.
+   * If StartFrame is not called here due to SubmitFrame failing, the
+   * fallback "watchdog" code in VRManager::NotifyVSync() will cause
+   * frames to continue at a lower refresh rate until frame submission
+   * succeeds again.
+   */
+  CompositorThread()->Dispatch(NewRunnableMethod("gfx::VRManager::StartFrame",
+                                                 this, &VRManager::StartFrame));
+#elif defined(MOZ_WIDGET_ANDROID)
+  // We are already in the CompositorThreadHolder event loop on Android.
+  StartFrame();
+#endif
+}
+
+void VRManager::CancelCurrentSubmitTask() {
+  MonitorAutoLock lock(mCurrentSubmitTaskMonitor);
+  if (mCurrentSubmitTask) {
+    mCurrentSubmitTask->Cancel();
+    mCurrentSubmitTask = nullptr;
+  }
+}
+
+//-----------------------------------------------------------------------------
+// VRManager::nsIObserver
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+VRManager::Observe(nsISupports* subject, const char* topic,
+                   const char16_t* data) {
+  if (!strcmp(topic, "application-background")) {
+    // StopTasks() is called later in the timer thread based on this flag to
+    // avoid threading issues.
+    mAppPaused = true;
+  } else if (!strcmp(topic, "application-foreground") && mAppPaused) {
+    mAppPaused = false;
+    // When the apps goes the foreground (e.g. Android) we should restart the
+    // tasks.
+    StartTasks();
+  }
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(VRManager, nsIObserver)
+
+}  // namespace mozilla::gfx