--- a/gfx/vr/gfxVROculus.cpp
+++ b/gfx/vr/gfxVROculus.cpp
@@ -130,17 +130,16 @@ static const ovrButton kOculusTouchLButt
 static const ovrButton kOculusTouchRButton[] = {
   ovrButton_RThumb,
   ovrButton_A,
   ovrButton_B,
 };
 
 static const uint32_t kNumOculusButton = sizeof(kOculusTouchLButton) /
                                          sizeof(ovrButton);
-static const uint32_t kNumOculusAxis = 2;
 static const uint32_t kNumOculusHaptcs = 0;  // TODO: Bug 1305892
 
 static bool
 InitializeOculusCAPI()
 {
   static PRLibrary *ovrlib = nullptr;
 
   if (!ovrlib) {
@@ -836,17 +835,30 @@ VRDisplayOculus::NotifyVSync()
 VRControllerOculus::VRControllerOculus()
   : VRControllerHost(VRDeviceType::Oculus)
 {
   MOZ_COUNT_CTOR_INHERITED(VRControllerOculus, VRControllerHost);
   mControllerInfo.mControllerName.AssignLiteral("Oculus Touch Controller");
   mControllerInfo.mMappingType = GamepadMappingType::_empty;
   mControllerInfo.mHand = GamepadHand::_empty;
   mControllerInfo.mNumButtons = kNumOculusButton;
-  mControllerInfo.mNumAxes = kNumOculusAxis;
+  mControllerInfo.mNumAxes = static_cast<uint32_t>(
+                             OculusControllerAxisType::NumVRControllerAxisType);;
+}
+
+float
+VRControllerOculus::GetAxisMove(uint32_t aAxis)
+{
+  return mAxisMove[aAxis];
+}
+
+void
+VRControllerOculus::SetAxisMove(uint32_t aAxis, float aValue)
+{
+  mAxisMove[aAxis] = aValue;
 }
 
 VRControllerOculus::~VRControllerOculus()
 {
   MOZ_COUNT_DTOR_INHERITED(VRControllerOculus, VRControllerHost);
 }
 
 /*static*/ already_AddRefed<VRSystemManagerOculus>
@@ -942,26 +954,39 @@ VRSystemManagerOculus::HandleInput()
   // mSession is available after VRDisplay is created
   // at GetHMDs().
   if (!mSession) {
     return;
   }
 
   RefPtr<impl::VRControllerOculus> controller;
   ovrInputState inputState;
+  uint32_t axis = 0;
   bool hasInputState = ovr_GetInputState(mSession, ovrControllerType_Touch,
                                          &inputState) == ovrSuccess;
 
   if (!hasInputState) {
     return;
   }
 
   for (uint32_t i = 0; i < mOculusController.Length(); ++i) {
     controller = mOculusController[i];
     HandleButtonPress(controller->GetIndex(), inputState.Buttons);
+
+    axis = static_cast<uint32_t>(OculusControllerAxisType::IndexTrigger);
+    HandleAxisMove(controller->GetIndex(), axis, inputState.IndexTrigger[i]);
+
+    axis = static_cast<uint32_t>(OculusControllerAxisType::HandTrigger);
+    HandleAxisMove(controller->GetIndex(), axis, inputState.HandTrigger[i]);
+
+    axis = static_cast<uint32_t>(OculusControllerAxisType::ThumbstickXAxis);
+    HandleAxisMove(controller->GetIndex(), axis, inputState.Thumbstick[i].x);
+
+    axis = static_cast<uint32_t>(OculusControllerAxisType::ThumbstickYAxis);
+    HandleAxisMove(controller->GetIndex(), axis, -inputState.Thumbstick[i].y);
   }
 }
 
 void
 VRSystemManagerOculus::HandleButtonPress(uint32_t aControllerIdx,
                                          uint64_t aButtonPressed)
 {
   MOZ_ASSERT(sizeof(kOculusTouchLButton) / sizeof(ovrButton) ==
@@ -992,17 +1017,28 @@ VRSystemManagerOculus::HandleButtonPress
 
   controller->SetButtonPressed(aButtonPressed);
 }
 
 void
 VRSystemManagerOculus::HandleAxisMove(uint32_t aControllerIdx, uint32_t aAxis,
                                       float aValue)
 {
-  // TODO: Bug 1305890
+  RefPtr<impl::VRControllerOculus> controller(mOculusController[aControllerIdx]);
+  MOZ_ASSERT(controller);
+  float value = aValue;
+
+  if (abs(aValue) < 0.0000009f) {
+    value = 0.0f; // Clear noise signal
+  }
+
+  if (controller->GetAxisMove(aAxis) != value) {
+    NewAxisMove(aControllerIdx, aAxis, value);
+    controller->SetAxisMove(aAxis, value);
+  }
 }
 
 void
 VRSystemManagerOculus::HandlePoseTracking(uint32_t aControllerIdx,
                                           const GamepadPoseState& aPose,
                                           VRControllerHost* aController)
 {
   // TODO: Bug 1305891

--- a/gfx/vr/gfxVROculus.h
+++ b/gfx/vr/gfxVROculus.h
@@ -22,16 +22,24 @@ namespace mozilla {
 namespace layers {
 class CompositingRenderTargetD3D11;
 struct VertexShaderConstants;
 struct PixelShaderConstants;
 }
 namespace gfx {
 namespace impl {
 
+enum class OculusControllerAxisType : uint16_t {
+  ThumbstickXAxis,
+  ThumbstickYAxis,
+  IndexTrigger,
+  HandTrigger,
+  NumVRControllerAxisType
+};
+
 class VRDisplayOculus : public VRDisplayHost
 {
 public:
   virtual void NotifyVSync() override;
   virtual VRHMDSensorState GetSensorState() override;
   virtual VRHMDSensorState GetImmediateSensorState() override;
   void ZeroSensor() override;
 
@@ -85,19 +93,23 @@ protected:
     float position[2];
   };
 };
 
 class VRControllerOculus : public VRControllerHost
 {
 public:
   explicit VRControllerOculus();
+  float GetAxisMove(uint32_t aAxis);
+  void SetAxisMove(uint32_t aAxis, float aValue);
 
 protected:
   virtual ~VRControllerOculus();
+  float mAxisMove[static_cast<uint32_t>(
+                  OculusControllerAxisType::NumVRControllerAxisType)];
 };
 
 } // namespace impl
 
 class VRSystemManagerOculus : public VRSystemManager
 {
 public:
   static already_AddRefed<VRSystemManagerOculus> Create();