Bug 1381378: Refactor - Isolate gamepad index and GamepadServiceType from GamepadChangeEvent; r?daoshengmu
authorChih-Yi Leu <cleu@mozilla.com>
Mon, 17 Jul 2017 11:44:39 +0800
changeset 1186956 87eeec1ce38706797aaaed4787b585a4810ee47d
parent 1186795 aff336ac161daa3ea350e59a288963edbd58ed39
child 1186957 139e5218a95eb54f77229d678e32e73bd8a9b6aa
push id205441
push usercleu@mozilla.com
push dateMon, 17 Jul 2017 06:31:46 +0000
treeherdertry@139e5218a95e [default view] [failures only]
reviewersdaoshengmu
bugs1381378
milestone56.0a1
Bug 1381378: Refactor - Isolate gamepad index and GamepadServiceType from GamepadChangeEvent; r?daoshengmu MozReview-Commit-ID: IFjvDsl6vlY
dom/gamepad/GamepadManager.cpp
dom/gamepad/GamepadPlatformService.cpp
dom/gamepad/GamepadPlatformService.h
dom/gamepad/GamepadServiceTest.cpp
dom/gamepad/ipc/GamepadEventTypes.ipdlh
dom/gamepad/ipc/GamepadTestChannelParent.cpp
gfx/vr/VRManager.cpp
gfx/vr/VRManager.h
gfx/vr/gfxVR.cpp
--- a/dom/gamepad/GamepadManager.cpp
+++ b/dom/gamepad/GamepadManager.cpp
@@ -498,29 +498,32 @@ GamepadManager::SetWindowHasSeenGamepad(
 
 void
 GamepadManager::Update(const GamepadChangeEvent& aEvent)
 {
   if (!mEnabled || mShuttingDown || nsContentUtils::ShouldResistFingerprinting()) {
     return;
   }
 
-  if (aEvent.type() == GamepadChangeEvent::TGamepadAdded) {
-    const GamepadAdded& a = aEvent.get_GamepadAdded();
-    AddGamepad(a.index(), a.id(),
+  uint32_t index = aEvent.index();
+  GamepadServiceType type = aEvent.service_type();
+  GamepadChangeEventBody body = aEvent.body();
+
+  if (body.type() == GamepadChangeEventBody::TGamepadAdded) {
+    const GamepadAdded& a = body.get_GamepadAdded();
+    AddGamepad(index, a.id(),
                static_cast<GamepadMappingType>(a.mapping()),
                static_cast<GamepadHand>(a.hand()),
-               a.service_type(),
+               type,
                a.num_buttons(), a.num_axes(),
                a.num_haptics());
     return;
   }
-  if (aEvent.type() == GamepadChangeEvent::TGamepadRemoved) {
-    const GamepadRemoved& a = aEvent.get_GamepadRemoved();
-    RemoveGamepad(a.index(), a.service_type());
+  if (body.type() == GamepadChangeEventBody::TGamepadRemoved) {
+    RemoveGamepad(index, type);
     return;
   }
 
   if (!SetGamepadByEvent(aEvent)) {
     return;
   }
 
   // Hold on to listeners in a separate array because firing events
@@ -547,106 +550,81 @@ GamepadManager::MaybeConvertToNonstandar
                                                       nsGlobalWindow* aWindow)
 {
   MOZ_ASSERT(aWindow);
 
   if (!mNonstandardEventsEnabled) {
     return;
   }
 
-  RefPtr<Gamepad> gamepad;
+  RefPtr<Gamepad> gamepad = aWindow->GetGamepad(aEvent.index());
+  const GamepadChangeEventBody& body = aEvent.body();
 
-  switch (aEvent.type()) {
-    case GamepadChangeEvent::TGamepadButtonInformation:
-      {
-        const GamepadButtonInformation& a = aEvent.get_GamepadButtonInformation();
-        gamepad = aWindow->GetGamepad(a.index());
-        if (gamepad) {
+  if (gamepad) {
+    switch (body.type()) {
+      case GamepadChangeEventBody::TGamepadButtonInformation:
+        {
+          const GamepadButtonInformation& a = body.get_GamepadButtonInformation();
           FireButtonEvent(aWindow, gamepad, a.button(), a.value());
         }
-      }
-      break;
-    case GamepadChangeEvent::TGamepadAxisInformation:
-      {
-        const GamepadAxisInformation& a = aEvent.get_GamepadAxisInformation();
-        gamepad = aWindow->GetGamepad(a.index());
-        if (gamepad) {
+        break;
+      case GamepadChangeEventBody::TGamepadAxisInformation:
+        {
+          const GamepadAxisInformation& a = body.get_GamepadAxisInformation();
           FireAxisMoveEvent(aWindow, gamepad, a.axis(), a.value());
         }
-      }
-      break;
-    default:
-      break;
+        break;
+      default:
+        break;
+    }
   }
 }
 
 bool
 GamepadManager::SetGamepadByEvent(const GamepadChangeEvent& aEvent, nsGlobalWindow *aWindow)
 {
-  uint32_t index;
-  RefPtr<Gamepad> gamepad;
   bool ret = false;
   bool firstTime = false;
 
-  switch (aEvent.type()) {
-    case GamepadChangeEvent::TGamepadButtonInformation:
-    {
-      const GamepadButtonInformation& a = aEvent.get_GamepadButtonInformation();
-      index = GetGamepadIndexWithServiceType(a.index(), a.service_type());
-      if (aWindow) {
-        firstTime = MaybeWindowHasSeenGamepad(aWindow, index);
-      }
-      gamepad = aWindow ? aWindow->GetGamepad(index) : GetGamepad(index);
-      if (gamepad) {
+  uint32_t index = GetGamepadIndexWithServiceType(aEvent.index(),
+                                                  aEvent.service_type());
+  if (aWindow) {
+    firstTime = MaybeWindowHasSeenGamepad(aWindow, index);
+  }
+
+  RefPtr<Gamepad> gamepad = aWindow ? aWindow->GetGamepad(index) : GetGamepad(index);
+  const GamepadChangeEventBody& body = aEvent.body();
+
+  if (gamepad) {
+    switch (body.type()) {
+      case GamepadChangeEventBody::TGamepadButtonInformation:
+      {
+        const GamepadButtonInformation& a = body.get_GamepadButtonInformation();
         gamepad->SetButton(a.button(), a.pressed(), a.touched(), a.value());
-        ret = true;
-      }
-    } break;
-    case GamepadChangeEvent::TGamepadAxisInformation:
-    {
-      const GamepadAxisInformation& a = aEvent.get_GamepadAxisInformation();
-      index = GetGamepadIndexWithServiceType(a.index(), a.service_type());
-      if (aWindow) {
-        firstTime = MaybeWindowHasSeenGamepad(aWindow, index);
-      }
-      gamepad = aWindow ? aWindow->GetGamepad(index) : GetGamepad(index);
-      if (gamepad) {
+      } break;
+      case GamepadChangeEventBody::TGamepadAxisInformation:
+      {
+        const GamepadAxisInformation& a = body.get_GamepadAxisInformation();
         gamepad->SetAxis(a.axis(), a.value());
-        ret = true;
-      }
-    } break;
-    case GamepadChangeEvent::TGamepadPoseInformation:
-    {
-      const GamepadPoseInformation& a = aEvent.get_GamepadPoseInformation();
-      index = GetGamepadIndexWithServiceType(a.index(), a.service_type());
-      if (aWindow) {
-        firstTime = MaybeWindowHasSeenGamepad(aWindow, index);
-      }
-      gamepad = aWindow ? aWindow->GetGamepad(index) : GetGamepad(index);
-      if (gamepad) {
+      } break;
+      case GamepadChangeEventBody::TGamepadPoseInformation:
+      {
+        const GamepadPoseInformation& a = body.get_GamepadPoseInformation();
         gamepad->SetPose(a.pose_state());
-         ret = true;
-      }
-    } break;
-    case GamepadChangeEvent::TGamepadHandInformation:
-    {
-      const GamepadHandInformation& a = aEvent.get_GamepadHandInformation();
-      index = GetGamepadIndexWithServiceType(a.index(), a.service_type());
-      if (aWindow) {
-        firstTime = MaybeWindowHasSeenGamepad(aWindow, index);
-      }
-      gamepad = aWindow ? aWindow->GetGamepad(index) : GetGamepad(index);
-      if (gamepad) {
+      } break;
+      case GamepadChangeEventBody::TGamepadHandInformation:
+      {
+        const GamepadHandInformation& a = body.get_GamepadHandInformation();
         gamepad->SetHand(a.hand());
-        ret = true;
-      }
-    } break;
-    default:
-      MOZ_ASSERT(false);
-      break;
+      }  break;
+      default:
+        MOZ_ASSERT(false);
+        break;
+    }
+    ret = true;
   }
 
   if (aWindow && firstTime) {
     FireConnectionEvent(aWindow, gamepad, true);
   }
 
   return ret;
 }
--- a/dom/gamepad/GamepadPlatformService.cpp
+++ b/dom/gamepad/GamepadPlatformService.cpp
@@ -53,24 +53,25 @@ GamepadPlatformService::GetParentService
     }
   }
   RefPtr<GamepadPlatformService> service(gGamepadPlatformServiceSingleton);
   return service.forget();
 }
 
 template<class T>
 void
-GamepadPlatformService::NotifyGamepadChange(const T& aInfo)
+GamepadPlatformService::NotifyGamepadChange(uint32_t aIndex, const T& aInfo)
 {
   // This method is called by monitor populated in
   // platform-dependent backends
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(!NS_IsMainThread());
 
-  GamepadChangeEvent e(aInfo);
+  GamepadChangeEventBody body(aInfo);
+  GamepadChangeEvent e(aIndex, GamepadServiceType::Standard, body);
 
   // mChannelParents may be accessed by background thread in the
   // same time, we use mutex to prevent possible race condtion
   MutexAutoLock autoLock(mMutex);
 
   // Buffer all events if we have no Channel to dispatch, which
   // may happen when performing Mochitest.
   if (mChannelParents.IsEmpty()) {
@@ -91,47 +92,45 @@ GamepadPlatformService::AddGamepad(const
                                    uint32_t aHaptics)
 {
   // This method is called by monitor thread populated in
   // platform-dependent backends
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(!NS_IsMainThread());
 
   uint32_t index = ++mGamepadIndex;
-  GamepadAdded a(NS_ConvertUTF8toUTF16(nsDependentCString(aID)), index,
-                 aMapping, aHand, GamepadServiceType::Standard,
-                 aNumButtons, aNumAxes, aHaptics);
+  GamepadAdded a(NS_ConvertUTF8toUTF16(nsDependentCString(aID)),
+                 aMapping, aHand, aNumButtons, aNumAxes, aHaptics);
 
-  NotifyGamepadChange<GamepadAdded>(a);
+  NotifyGamepadChange<GamepadAdded>(index, a);
   return index;
 }
 
 void
 GamepadPlatformService::RemoveGamepad(uint32_t aIndex)
 {
   // This method is called by monitor thread populated in
   // platform-dependent backends
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(!NS_IsMainThread());
-  GamepadRemoved a(aIndex, GamepadServiceType::Standard);
-  NotifyGamepadChange<GamepadRemoved>(a);
+  GamepadRemoved a;
+  NotifyGamepadChange<GamepadRemoved>(aIndex, a);
 }
 
 void
 GamepadPlatformService::NewButtonEvent(uint32_t aIndex, uint32_t aButton,
                                        bool aPressed, bool aTouched,
                                        double aValue)
 {
   // This method is called by monitor thread populated in
   // platform-dependent backends
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(!NS_IsMainThread());
-  GamepadButtonInformation a(aIndex, GamepadServiceType::Standard,
-                             aButton, aValue, aPressed, aTouched);
-  NotifyGamepadChange<GamepadButtonInformation>(a);
+  GamepadButtonInformation a(aButton, aValue, aPressed, aTouched);
+  NotifyGamepadChange<GamepadButtonInformation>(aIndex, a);
 }
 
 void
 GamepadPlatformService::NewButtonEvent(uint32_t aIndex, uint32_t aButton,
                                        bool aPressed, bool aTouched)
 {
   // This method is called by monitor thread populated in
   // platform-dependent backends
@@ -156,32 +155,30 @@ GamepadPlatformService::NewButtonEvent(u
 void
 GamepadPlatformService::NewAxisMoveEvent(uint32_t aIndex, uint32_t aAxis,
                                          double aValue)
 {
   // This method is called by monitor thread populated in
   // platform-dependent backends
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(!NS_IsMainThread());
-  GamepadAxisInformation a(aIndex, GamepadServiceType::Standard,
-                           aAxis, aValue);
-  NotifyGamepadChange<GamepadAxisInformation>(a);
+  GamepadAxisInformation a(aAxis, aValue);
+  NotifyGamepadChange<GamepadAxisInformation>(aIndex, a);
 }
 
 void
 GamepadPlatformService::NewPoseEvent(uint32_t aIndex,
                                      const GamepadPoseState& aPose)
 {
   // This method is called by monitor thread populated in
   // platform-dependent backends
   MOZ_ASSERT(XRE_IsParentProcess());
   MOZ_ASSERT(!NS_IsMainThread());
-  GamepadPoseInformation a(aIndex, GamepadServiceType::Standard,
-                           aPose);
-  NotifyGamepadChange<GamepadPoseInformation>(a);
+  GamepadPoseInformation a(aPose);
+  NotifyGamepadChange<GamepadPoseInformation>(aIndex, a);
 }
 
 void
 GamepadPlatformService::ResetGamepadIndexes()
 {
   // This method is called by monitor thread populated in
   // platform-dependent backends
   MOZ_ASSERT(XRE_IsParentProcess());
--- a/dom/gamepad/GamepadPlatformService.h
+++ b/dom/gamepad/GamepadPlatformService.h
@@ -76,17 +76,17 @@ class GamepadPlatformService final
 
   bool HasGamepadListeners();
 
   void MaybeShutdown();
 
  private:
   GamepadPlatformService();
   ~GamepadPlatformService();
-  template<class T> void NotifyGamepadChange(const T& aInfo);
+  template<class T> void NotifyGamepadChange(uint32_t index, const T& aInfo);
 
   // Flush all pending events buffered in mPendingEvents, must be called
   // with mMutex held
   void FlushPendingEvents();
   void Cleanup();
 
   // mGamepadIndex can only be accessed by monitor thread
   uint32_t mGamepadIndex;
--- a/dom/gamepad/GamepadServiceTest.cpp
+++ b/dom/gamepad/GamepadServiceTest.cpp
@@ -118,21 +118,21 @@ GamepadServiceTest::AddGamepad(const nsA
                                uint32_t aNumAxes,
                                uint32_t aNumHaptics,
                                ErrorResult& aRv)
 {
   if (mShuttingDown) {
     return nullptr;
   }
 
-  GamepadAdded a(nsString(aID), 0,
+  GamepadAdded a(nsString(aID),
                  aMapping, aHand,
-                 GamepadServiceType::Standard,
                  aNumButtons, aNumAxes, aNumHaptics);
-  GamepadChangeEvent e(a);
+  GamepadChangeEventBody body(a);
+  GamepadChangeEvent e(0, GamepadServiceType::Standard, body);
   nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(mWindow);
 
   RefPtr<Promise> p = Promise::Create(go, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
   uint32_t id = ++mEventNumber;
@@ -148,18 +148,19 @@ GamepadServiceTest::AddGamepad(const nsA
 
 void
 GamepadServiceTest::RemoveGamepad(uint32_t aIndex)
 {
   if (mShuttingDown) {
     return;
   }
 
-  GamepadRemoved a(aIndex, GamepadServiceType::Standard);
-  GamepadChangeEvent e(a);
+  GamepadRemoved a;
+  GamepadChangeEventBody body(a);
+  GamepadChangeEvent e(aIndex, GamepadServiceType::Standard, body);
 
   uint32_t id = ++mEventNumber;
   if (mChild) {
     mChild->SendGamepadTestEvent(id, e);
   } else {
     PendingOperation op(id, e);
     mPendingOperations.AppendElement(op);
   }
@@ -170,19 +171,19 @@ GamepadServiceTest::NewButtonEvent(uint3
                                    uint32_t aButton,
                                    bool aTouched,
                                    bool aPressed)
 {
   if (mShuttingDown) {
     return;
   }
 
-  GamepadButtonInformation a(aIndex, GamepadServiceType::Standard,
-                             aButton, aPressed ? 1.0 : 0, aPressed, aTouched);
-  GamepadChangeEvent e(a);
+  GamepadButtonInformation a(aButton, aPressed ? 1.0 : 0, aPressed, aTouched);
+  GamepadChangeEventBody body(a);
+  GamepadChangeEvent e(aIndex, GamepadServiceType::Standard, body);
 
   uint32_t id = ++mEventNumber;
   if (mChild) {
     mChild->SendGamepadTestEvent(id, e);
   } else {
     PendingOperation op(id, e);
     mPendingOperations.AppendElement(op);
   }
@@ -194,19 +195,19 @@ GamepadServiceTest::NewButtonValueEvent(
                                         bool aPressed,
                                         bool aTouched,
                                         double aValue)
 {
   if (mShuttingDown) {
     return;
   }
 
-  GamepadButtonInformation a(aIndex, GamepadServiceType::Standard,
-                             aButton, aValue, aPressed, aTouched);
-  GamepadChangeEvent e(a);
+  GamepadButtonInformation a(aButton, aValue, aPressed, aTouched);
+  GamepadChangeEventBody body(a);
+  GamepadChangeEvent e(aIndex, GamepadServiceType::Standard, body);
 
   uint32_t id = ++mEventNumber;
   if (mChild) {
     mChild->SendGamepadTestEvent(id, e);
   } else {
     PendingOperation op(id, e);
     mPendingOperations.AppendElement(op);
   }
@@ -216,19 +217,19 @@ void
 GamepadServiceTest::NewAxisMoveEvent(uint32_t aIndex,
                                      uint32_t aAxis,
                                      double aValue)
 {
   if (mShuttingDown) {
     return;
   }
 
-  GamepadAxisInformation a(aIndex, GamepadServiceType::Standard,
-                           aAxis, aValue);
-  GamepadChangeEvent e(a);
+  GamepadAxisInformation a(aAxis, aValue);
+  GamepadChangeEventBody body(a);
+  GamepadChangeEvent e(aIndex, GamepadServiceType::Standard, body);
 
   uint32_t id = ++mEventNumber;
   if (mChild) {
     mChild->SendGamepadTestEvent(id, e);
   } else {
     PendingOperation op(id, e);
     mPendingOperations.AppendElement(op);
   }
@@ -299,19 +300,19 @@ GamepadServiceTest::NewPoseMove(uint32_t
     const Float32Array& value = aLinAcceleration.Value();
     value.ComputeLengthAndData();
     MOZ_ASSERT(value.Length() == 3);
     poseState.linearAcceleration[0] = value.Data()[0];
     poseState.linearAcceleration[1] = value.Data()[1];
     poseState.linearAcceleration[2] = value.Data()[2];
   }
 
-  GamepadPoseInformation a(aIndex, GamepadServiceType::Standard,
-                           poseState);
-  GamepadChangeEvent e(a);
+  GamepadPoseInformation a(poseState);
+  GamepadChangeEventBody body(a);
+  GamepadChangeEvent e(aIndex, GamepadServiceType::Standard, body);
 
   uint32_t id = ++mEventNumber;
   if (mChild) {
     mChild->SendGamepadTestEvent(id, e);
   } else {
     PendingOperation op(id, e);
     mPendingOperations.AppendElement(op);
   }
--- a/dom/gamepad/ipc/GamepadEventTypes.ipdlh
+++ b/dom/gamepad/ipc/GamepadEventTypes.ipdlh
@@ -8,61 +8,54 @@ using mozilla::dom::GamepadMappingType f
 using mozilla::dom::GamepadHand from "mozilla/dom/GamepadMessageUtils.h";
 
 
 namespace mozilla {
 namespace dom {
 
 struct GamepadAdded {
   nsString id;
-  uint32_t index;
   GamepadMappingType mapping;
   GamepadHand hand;
-  GamepadServiceType service_type;
   uint32_t num_buttons;
   uint32_t num_axes;
   uint32_t num_haptics;
 };
 
-struct GamepadRemoved {
-  uint32_t index;
-  GamepadServiceType service_type;
-};
+struct GamepadRemoved {};
 
 struct GamepadAxisInformation {
-  uint32_t index;
-  GamepadServiceType service_type;
   uint32_t axis;
   double value;
 };
 
 struct GamepadButtonInformation {
-  uint32_t index;
-  GamepadServiceType service_type;
   uint32_t button;
   double value;
   bool pressed;
   bool touched;
 };
 
 struct GamepadPoseInformation {
-  uint32_t index;
-  GamepadServiceType service_type;
   GamepadPoseState pose_state;
 };
 
 struct GamepadHandInformation {
-  uint32_t index;
-  GamepadServiceType service_type;
   GamepadHand hand;
 };
 
-union GamepadChangeEvent {
+union GamepadChangeEventBody {
   GamepadAdded;
   GamepadRemoved;
   GamepadAxisInformation;
   GamepadButtonInformation;
   GamepadPoseInformation;
   GamepadHandInformation;
 };
 
+struct GamepadChangeEvent {
+  uint32_t index;
+  GamepadServiceType service_type;
+  GamepadChangeEventBody body;
+};
+
 } // namespace dom
 } // namespace mozilla
\ No newline at end of file
--- a/dom/gamepad/ipc/GamepadTestChannelParent.cpp
+++ b/dom/gamepad/ipc/GamepadTestChannelParent.cpp
@@ -13,50 +13,51 @@ namespace dom {
 mozilla::ipc::IPCResult
 GamepadTestChannelParent::RecvGamepadTestEvent(const uint32_t& aID,
                                                const GamepadChangeEvent& aEvent)
 {
   mozilla::ipc::AssertIsOnBackgroundThread();
   RefPtr<GamepadPlatformService>  service =
     GamepadPlatformService::GetParentService();
   MOZ_ASSERT(service);
-  if (aEvent.type() == GamepadChangeEvent::TGamepadAdded) {
-    const GamepadAdded& a = aEvent.get_GamepadAdded();
+  uint32_t index = aEvent.index();
+  const GamepadChangeEventBody& body = aEvent.body();
+  if (body.type() == GamepadChangeEventBody::TGamepadAdded) {
+    const GamepadAdded& a = body.get_GamepadAdded();
     nsCString gamepadID;
     LossyCopyUTF16toASCII(a.id(), gamepadID);
     uint32_t index = service->AddGamepad(gamepadID.get(),
                                          static_cast<GamepadMappingType>(a.mapping()),
                                          a.hand(),
                                          a.num_buttons(),
                                          a.num_axes(),
                                          a.num_haptics());
     if (!mShuttingdown) {
       Unused << SendReplyGamepadIndex(aID, index);
     }
     return IPC_OK();
   }
-  if (aEvent.type() == GamepadChangeEvent::TGamepadRemoved) {
-    const GamepadRemoved& a = aEvent.get_GamepadRemoved();
-    service->RemoveGamepad(a.index());
+  if (body.type() == GamepadChangeEventBody::TGamepadRemoved) {
+    service->RemoveGamepad(index);
     return IPC_OK();
   }
-  if (aEvent.type() == GamepadChangeEvent::TGamepadButtonInformation) {
-    const GamepadButtonInformation& a = aEvent.get_GamepadButtonInformation();
-    service->NewButtonEvent(a.index(), a.button(), a.pressed(), a.touched(),
+  if (body.type() == GamepadChangeEventBody::TGamepadButtonInformation) {
+    const GamepadButtonInformation& a = body.get_GamepadButtonInformation();
+    service->NewButtonEvent(index, a.button(), a.pressed(), a.touched(),
                             a.value());
     return IPC_OK();
   }
-  if (aEvent.type() == GamepadChangeEvent::TGamepadAxisInformation) {
-    const GamepadAxisInformation& a = aEvent.get_GamepadAxisInformation();
-    service->NewAxisMoveEvent(a.index(), a.axis(), a.value());
+  if (body.type() == GamepadChangeEventBody::TGamepadAxisInformation) {
+    const GamepadAxisInformation& a = body.get_GamepadAxisInformation();
+    service->NewAxisMoveEvent(index, a.axis(), a.value());
     return IPC_OK();
   }
-  if (aEvent.type() == GamepadChangeEvent::TGamepadPoseInformation) {
-    const GamepadPoseInformation& a = aEvent.get_GamepadPoseInformation();
-    service->NewPoseEvent(a.index(), a.pose_state());
+  if (body.type() == GamepadChangeEventBody::TGamepadPoseInformation) {
+    const GamepadPoseInformation& a = body.get_GamepadPoseInformation();
+    service->NewPoseEvent(index, a.pose_state());
     return IPC_OK();
   }
 
   NS_WARNING("Unknown event type.");
   return IPC_FAIL_NO_REASON(this);
 }
 
 mozilla::ipc::IPCResult
--- a/gfx/vr/VRManager.cpp
+++ b/gfx/vr/VRManager.cpp
@@ -440,19 +440,20 @@ VRManager::CreateVRTestSystem()
   if (mgr) {
     mManagers.AppendElement(mgr);
     mVRTestSystemCreated = true;
   }
 }
 
 template<class T>
 void
-VRManager::NotifyGamepadChange(const T& aInfo)
+VRManager::NotifyGamepadChange(uint32_t aIndex, const T& aInfo)
 {
-  dom::GamepadChangeEvent e(aInfo);
+  dom::GamepadChangeEventBody body(aInfo);
+  dom::GamepadChangeEvent e(aIndex, dom::GamepadServiceType::VR, body);
 
   for (auto iter = mVRManagerParents.Iter(); !iter.Done(); iter.Next()) {
     Unused << iter.Get()->GetKey()->SendGamepadUpdate(e);
   }
 }
 
 void
 VRManager::VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
--- a/gfx/vr/VRManager.h
+++ b/gfx/vr/VRManager.h
@@ -34,17 +34,17 @@ public:
   void AddVRManagerParent(VRManagerParent* aVRManagerParent);
   void RemoveVRManagerParent(VRManagerParent* aVRManagerParent);
 
   void NotifyVsync(const TimeStamp& aVsyncTimestamp);
   void NotifyVRVsync(const uint32_t& aDisplayID);
   void RefreshVRDisplays(bool aMustDispatch = false);
   void ScanForControllers();
   void RemoveControllers();
-  template<class T> void NotifyGamepadChange(const T& aInfo);
+  template<class T> void NotifyGamepadChange(uint32_t aIndex, const T& aInfo);
   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);
--- a/gfx/vr/gfxVR.cpp
+++ b/gfx/vr/gfxVR.cpp
@@ -57,73 +57,67 @@ VRFieldOfView::ConstructProjectionMatrix
 
   return mobj;
 }
 
 void
 VRSystemManager::AddGamepad(const VRControllerInfo& controllerInfo)
 {
   dom::GamepadAdded a(NS_ConvertUTF8toUTF16(controllerInfo.GetControllerName()),
-                      mControllerCount,
                       controllerInfo.GetMappingType(),
                       controllerInfo.GetHand(),
-                      dom::GamepadServiceType::VR,
                       controllerInfo.GetNumButtons(),
                       controllerInfo.GetNumAxes(),
                       controllerInfo.GetNumHaptics());
 
   VRManager* vm = VRManager::Get();
-  vm->NotifyGamepadChange<dom::GamepadAdded>(a);
+  vm->NotifyGamepadChange<dom::GamepadAdded>(mControllerCount, a);
 }
 
 void
 VRSystemManager::RemoveGamepad(uint32_t aIndex)
 {
-  dom::GamepadRemoved a(aIndex, dom::GamepadServiceType::VR);
+  dom::GamepadRemoved a;
 
   VRManager* vm = VRManager::Get();
-  vm->NotifyGamepadChange<dom::GamepadRemoved>(a);
+  vm->NotifyGamepadChange<dom::GamepadRemoved>(aIndex, a);
 }
 
 void
 VRSystemManager::NewButtonEvent(uint32_t aIndex, uint32_t aButton,
                                 bool aPressed, bool aTouched, double aValue)
 {
-  dom::GamepadButtonInformation a(aIndex, dom::GamepadServiceType::VR,
-                                  aButton, aValue, aPressed, aTouched);
+  dom::GamepadButtonInformation a(aButton, aValue, aPressed, aTouched);
 
   VRManager* vm = VRManager::Get();
-  vm->NotifyGamepadChange<dom::GamepadButtonInformation>(a);
+  vm->NotifyGamepadChange<dom::GamepadButtonInformation>(aIndex, a);
 }
 
 void
 VRSystemManager::NewAxisMove(uint32_t aIndex, uint32_t aAxis,
                              double aValue)
 {
-  dom::GamepadAxisInformation a(aIndex, dom::GamepadServiceType::VR,
-                                aAxis, aValue);
+  dom::GamepadAxisInformation a(aAxis, aValue);
 
   VRManager* vm = VRManager::Get();
-  vm->NotifyGamepadChange<dom::GamepadAxisInformation>(a);
+  vm->NotifyGamepadChange<dom::GamepadAxisInformation>(aIndex, a);
 }
 
 void
 VRSystemManager::NewPoseState(uint32_t aIndex,
                               const dom::GamepadPoseState& aPose)
 {
-  dom::GamepadPoseInformation a(aIndex, dom::GamepadServiceType::VR,
-                                aPose);
+  dom::GamepadPoseInformation a(aPose);
 
   VRManager* vm = VRManager::Get();
-  vm->NotifyGamepadChange<dom::GamepadPoseInformation>(a);
+  vm->NotifyGamepadChange<dom::GamepadPoseInformation>(aIndex, a);
 }
 
 void
 VRSystemManager::NewHandChangeEvent(uint32_t aIndex,
                                     const dom::GamepadHand aHand)
 {
-  dom::GamepadHandInformation a(aIndex, dom::GamepadServiceType::VR,
-                                aHand);
+  dom::GamepadHandInformation a(aHand);
 
   VRManager* vm = VRManager::Get();
-  vm->NotifyGamepadChange<dom::GamepadHandInformation>(a);
+  vm->NotifyGamepadChange<dom::GamepadHandInformation>(aIndex, a);
 }