--- a/dom/vr/VRServiceTest.cpp
+++ b/dom/vr/VRServiceTest.cpp
@@ -135,17 +135,16 @@ VRMockDisplay::SetPose(const Nullable<Fl
     mSensorState.linearAcceleration[2] = value.Data()[2];
   }
 }
 
 void
 VRMockDisplay::Update()
 {
   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
-  MOZ_ASSERT(vm);
 
   vm->SendSetSensorStateToMockDisplay(mDeviceID, mSensorState);
   vm->SendSetDisplayInfoToMockDisplay(mDeviceID, mDisplayInfo);
 }
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(VRMockController)
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(VRMockController,
@@ -172,40 +171,37 @@ VRMockController::WrapObject(JSContext* 
 {
   return VRMockControllerBinding::Wrap(aCx, this, aGivenProto);
 }
 
 void
 VRMockController::NewButtonEvent(unsigned long aButton, bool aPressed)
 {
   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
-  MOZ_ASSERT(vm);
   vm->SendNewButtonEventToMockController(mDeviceID, aButton, aPressed);
 }
 
 void
 VRMockController::NewAxisMoveEvent(unsigned long aAxis, double aValue)
 {
   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
-  MOZ_ASSERT(vm);
   vm->SendNewAxisMoveEventToMockController(mDeviceID, aAxis, aValue);
 }
 
 void
 VRMockController::NewPoseMove(const Nullable<Float32Array>& aPosition,
                               const Nullable<Float32Array>& aLinearVelocity,
                               const Nullable<Float32Array>& aLinearAcceleration,
                               const Nullable<Float32Array>& aOrientation,
                               const Nullable<Float32Array>& aAngularVelocity,
                               const Nullable<Float32Array>& aAngularAcceleration)
 {
   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
-  MOZ_ASSERT(vm);
+  GamepadPoseState poseState;
 
-  GamepadPoseState poseState;
   poseState.flags = GamepadCapabilityFlags::Cap_Orientation |
                     GamepadCapabilityFlags::Cap_Position |
                     GamepadCapabilityFlags::Cap_AngularAcceleration |
                     GamepadCapabilityFlags::Cap_LinearAcceleration;
   if (!aOrientation.IsNull()) {
     const Float32Array& value = aOrientation.Value();
     value.ComputeLengthAndData();
     MOZ_ASSERT(value.Length() == 4);
@@ -287,17 +283,20 @@ VRServiceTest::CreateTestService(nsPIDOM
   MOZ_ASSERT(aWindow);
   RefPtr<VRServiceTest> service = new VRServiceTest(aWindow);
   return service.forget();
 }
 
 VRServiceTest::VRServiceTest(nsPIDOMWindowInner* aWindow)
   : mWindow(aWindow),
     mShuttingDown(false)
-{}
+{
+  gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
+  vm->SendCreateVRTestSystem();
+}
 
 VRServiceTest::~VRServiceTest()
 {}
 
 void
 VRServiceTest::Shutdown()
 {
   MOZ_ASSERT(!mShuttingDown);
@@ -315,17 +314,16 @@ VRServiceTest::AttachVRDisplay(const nsA
   nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(mWindow);
 
   RefPtr<Promise> p = Promise::Create(go, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
-  MOZ_ASSERT(vm);
   vm->CreateVRServiceTestDisplay(nsCString(ToNewUTF8String(aID)), p);
 
   return p.forget();
 }
 
 already_AddRefed<Promise>
 VRServiceTest::AttachVRController(const nsAString& aID, ErrorResult& aRv)
 {
@@ -336,16 +334,15 @@ VRServiceTest::AttachVRController(const 
   nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(mWindow);
 
   RefPtr<Promise> p = Promise::Create(go, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   gfx::VRManagerChild* vm = gfx::VRManagerChild::Get();
-  MOZ_ASSERT(vm);
   vm->CreateVRServiceTestController(nsCString(ToNewUTF8String(aID)), p);
 
   return p.forget();
 }
 
 } // namespace dom
 } // namespace mozilla
\ No newline at end of file

--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -320,17 +320,17 @@ private:
 
   DECL_GFX_PREF(Live, "dom.ipc.plugins.asyncdrawing.enabled",  PluginAsyncDrawingEnabled, bool, false);
   DECL_GFX_PREF(Live, "dom.meta-viewport.enabled",             MetaViewportEnabled, bool, false);
   DECL_GFX_PREF(Once, "dom.vr.enabled",                        VREnabled, bool, false);
   DECL_GFX_PREF(Once, "dom.vr.oculus.enabled",                 VROculusEnabled, bool, true);
   DECL_GFX_PREF(Once, "dom.vr.openvr.enabled",                 VROpenVREnabled, bool, false);
   DECL_GFX_PREF(Once, "dom.vr.osvr.enabled",                   VROSVREnabled, bool, false);
   DECL_GFX_PREF(Live, "dom.vr.poseprediction.enabled",         VRPosePredictionEnabled, bool, false);
-  DECL_GFX_PREF(Once, "dom.vr.puppet.enabled",                 VRPuppetEnabled, bool, false);
+  DECL_GFX_PREF(Live, "dom.vr.puppet.enabled",                 VRPuppetEnabled, bool, false);
   DECL_GFX_PREF(Live, "dom.w3c_pointer_events.enabled",        PointerEventsEnabled, bool, false);
   DECL_GFX_PREF(Live, "dom.w3c_touch_events.enabled",          TouchEventsEnabled, int32_t, 0);
 
   DECL_GFX_PREF(Live, "general.smoothScroll",                  SmoothScrollEnabled, bool, true);
   DECL_GFX_PREF(Live, "general.smoothScroll.currentVelocityWeighting",
                 SmoothScrollCurrentVelocityWeighting, float, 0.25);
   DECL_GFX_PREF(Live, "general.smoothScroll.durationToIntervalRatio",
                 SmoothScrollDurationToIntervalRatio, int32_t, 200);

--- a/gfx/vr/VRManager.cpp
+++ b/gfx/vr/VRManager.cpp
@@ -43,16 +43,17 @@ VRManager::ManagerInit()
   if (sVRManagerSingleton == nullptr) {
     sVRManagerSingleton = new VRManager();
     ClearOnShutdown(&sVRManagerSingleton);
   }
 }
 
 VRManager::VRManager()
   : mInitialized(false)
+  , mVRTestSystemCreated(false)
 {
   MOZ_COUNT_CTOR(VRManager);
   MOZ_ASSERT(sVRManagerSingleton == nullptr);
 
   RefPtr<VRSystemManager> mgr;
 
   /**
    * We must add the VRDisplayManager's to mManagers in a careful order to
@@ -84,20 +85,16 @@ VRManager::VRManager()
   }
 
   // OSVR is cross platform compatible
   mgr = VRSystemManagerOSVR::Create();
   if (mgr) {
       mManagers.AppendElement(mgr);
   }
 #endif
-  mgr = VRSystemManagerPuppet::Create();
-  if (mgr) {
-    mManagers.AppendElement(mgr);
-  }
   // Enable gamepad extensions while VR is enabled.
   // Preference only can be set at the Parent process.
   if (XRE_IsParentProcess() && gfxPrefs::VREnabled()) {
     Preferences::SetBool("dom.gamepad.extensions.enabled", true);
   }
 }
 
 VRManager::~VRManager()
@@ -384,16 +381,31 @@ void
 VRManager::RemoveControllers()
 {
   for (uint32_t i = 0; i < mManagers.Length(); ++i) {
     mManagers[i]->RemoveControllers();
   }
   mVRControllers.Clear();
 }
 
+void
+VRManager::CreateVRTestSystem()
+{
+  if (mVRTestSystemCreated) {
+    return;
+  }
+
+  RefPtr<VRSystemManager> mgr = VRSystemManagerPuppet::Create();
+  if (mgr) {
+    mgr->Init();
+    mManagers.AppendElement(mgr);
+    mVRTestSystemCreated = true;
+  }
+}
+
 template<class T>
 void
 VRManager::NotifyGamepadChange(const T& aInfo)
 {
   dom::GamepadChangeEvent e(aInfo);
 
   for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
     Unused << iter.Get()->GetKey()->SendGamepadUpdate(e);

--- a/gfx/vr/VRManager.h
+++ b/gfx/vr/VRManager.h
@@ -43,16 +43,17 @@ public:
   RefPtr<gfx::VRDisplayHost> GetDisplay(const uint32_t& aDisplayID);
   void GetVRDisplayInfo(nsTArray<VRDisplayInfo>& aDisplayInfo);
 
   void SubmitFrame(VRLayerParent* aLayer, layers::PTextureParent* aTexture,
                    const gfx::Rect& aLeftEyeRect,
                    const gfx::Rect& aRightEyeRect);
   RefPtr<gfx::VRControllerHost> GetController(const uint32_t& aControllerID);
   void GetVRControllerInfo(nsTArray<VRControllerInfo>& aControllerInfo);
+  void CreateVRTestSystem();
 
 protected:
   VRManager();
   ~VRManager();
 
 private:
   RefPtr<layers::TextureHost> mLastFrame;
 
@@ -72,14 +73,15 @@ private:
   VRDisplayHostHashMap mVRDisplays;
 
   typedef nsRefPtrHashtable<nsUint32HashKey, gfx::VRControllerHost> VRControllerHostHashMap;
   VRControllerHostHashMap mVRControllers;
 
   Atomic<bool> mInitialized;
 
   TimeStamp mLastRefreshTime;
+  bool mVRTestSystemCreated;
 };
 
 } // namespace gfx
 } // namespace mozilla
 
 #endif // GFX_VR_MANAGER_H

--- a/gfx/vr/gfxVRPuppet.cpp
+++ b/gfx/vr/gfxVRPuppet.cpp
@@ -309,18 +309,16 @@ VRControllerPuppet::SetAxisMove(uint32_t
 
 VRSystemManagerPuppet::VRSystemManagerPuppet()
 {
 }
 
 /*static*/ already_AddRefed<VRSystemManagerPuppet>
 VRSystemManagerPuppet::Create()
 {
-  MOZ_ASSERT(NS_IsMainThread());
-
   if (!gfxPrefs::VREnabled() || !gfxPrefs::VRPuppetEnabled()) {
     return nullptr;
   }
 
   RefPtr<VRSystemManagerPuppet> manager = new VRSystemManagerPuppet();
   return manager.forget();
 }
 

--- a/gfx/vr/ipc/PVRManager.ipdl
+++ b/gfx/vr/ipc/PVRManager.ipdl
@@ -57,16 +57,17 @@ parent:
   sync GetImmediateSensorState(uint32_t aDisplayID) returns(VRHMDSensorState aState);
   sync SetHaveEventListener(bool aHaveEventListener);
 
   async ControllerListenerAdded();
   async ControllerListenerRemoved();
   // GetControllers synchronously returns the VR controllers that have already been
   // enumerated by RefreshVRControllers() but does not enumerate new ones.
   sync GetControllers() returns(VRControllerInfo[] aControllerInfo);
+  async CreateVRTestSystem();
   async CreateVRServiceTestDisplay(nsCString aID, uint32_t aPromiseID);
   async CreateVRServiceTestController(nsCString aID, uint32_t aPromiseID);
   async SetDisplayInfoToMockDisplay(uint32_t aDeviceID, VRDisplayInfo aDisplayInfo);
   async SetSensorStateToMockDisplay(uint32_t aDeviceID, VRHMDSensorState aSensorState);
   async NewButtonEventToMockController(uint32_t aDeviceID, long aButton,
                                        bool aPressed);
   async NewAxisMoveEventToMockController(uint32_t aDeviceID, long aAxis,
                                          double aValue);

--- a/gfx/vr/ipc/VRManagerParent.cpp
+++ b/gfx/vr/ipc/VRManagerParent.cpp
@@ -325,16 +325,24 @@ mozilla::ipc::IPCResult
 VRManagerParent::RecvGetControllers(nsTArray<VRControllerInfo> *aControllers)
 {
   VRManager* vm = VRManager::Get();
   vm->GetVRControllerInfo(*aControllers);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
+VRManagerParent::RecvCreateVRTestSystem()
+{
+  VRManager* vm = VRManager::Get();
+  vm->CreateVRTestSystem();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult
 VRManagerParent::RecvCreateVRServiceTestDisplay(const nsCString& aID, const uint32_t& aPromiseID)
 {
   nsTArray<VRDisplayInfo> displayInfoArray;
   impl::VRDisplayPuppet* displayPuppet = nullptr;
   VRManager* vm = VRManager::Get();
   vm->RefreshVRDisplays();
 
   // Get VRDisplayPuppet from VRManager

--- a/gfx/vr/ipc/VRManagerParent.h
+++ b/gfx/vr/ipc/VRManagerParent.h
@@ -89,16 +89,17 @@ protected:
   virtual mozilla::ipc::IPCResult RecvGetDisplays(nsTArray<VRDisplayInfo> *aDisplays) override;
   virtual mozilla::ipc::IPCResult RecvResetSensor(const uint32_t& aDisplayID) override;
   virtual mozilla::ipc::IPCResult RecvGetSensorState(const uint32_t& aDisplayID, VRHMDSensorState* aState) override;
   virtual mozilla::ipc::IPCResult RecvGetImmediateSensorState(const uint32_t& aDisplayID, VRHMDSensorState* aState) override;
   virtual mozilla::ipc::IPCResult RecvSetHaveEventListener(const bool& aHaveEventListener) override;
   virtual mozilla::ipc::IPCResult RecvControllerListenerAdded() override;
   virtual mozilla::ipc::IPCResult RecvControllerListenerRemoved() override;
   virtual mozilla::ipc::IPCResult RecvGetControllers(nsTArray<VRControllerInfo> *aControllers) override;
+  virtual mozilla::ipc::IPCResult RecvCreateVRTestSystem() override;
   virtual mozilla::ipc::IPCResult RecvCreateVRServiceTestDisplay(const nsCString& aID, const uint32_t& aPromiseID) override;
   virtual mozilla::ipc::IPCResult RecvCreateVRServiceTestController(const nsCString& aID, const uint32_t& aPromiseID) override;
   virtual mozilla::ipc::IPCResult RecvSetDisplayInfoToMockDisplay(const uint32_t& aDeviceID,
                                                                   const VRDisplayInfo& aDisplayInfo) override;
   virtual mozilla::ipc::IPCResult RecvSetSensorStateToMockDisplay(const uint32_t& aDeviceID,
                                                                   const VRHMDSensorState& aSensorState) override;
   virtual mozilla::ipc::IPCResult RecvNewButtonEventToMockController(const uint32_t& aDeviceID, const long& aButton,
                                                                      const bool& aPressed) override;