Fix broken normalization of some HID axes on OSX

content/browser/gamepad/gamepad_platform_data_fetcher_mac.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/gamepad/gamepad_platform_data_fetcher_mac.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include "base/mac/foundation_util.h"
@@ skipping 27 matching lines @@
           base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsagePageKey)),
       [NSNumber numberWithUnsignedInt:usage],
           base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsageKey)),
       nil];
 }
 
 float NormalizeAxis(CFIndex value, CFIndex min, CFIndex max) {
   return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f;
 }
 
+float NormalizeUInt8Axis(uint8_t value, uint8_t min, uint8_t max) {
+  return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f;
+}
+
+float NormalizeUInt16Axis(uint16_t value, uint16_t min, uint16_t max) {
+  return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f;
+}
+
+float NormalizeUInt32Axis(uint32_t value, uint32_t min, uint32_t max) {
+  return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f;
+}
+
 // http://www.usb.org/developers/hidpage
 const uint32_t kGenericDesktopUsagePage = 0x01;
 const uint32_t kGameControlsUsagePage = 0x05;
 const uint32_t kButtonUsagePage = 0x09;
 const uint32_t kJoystickUsageNumber = 0x04;
 const uint32_t kGameUsageNumber = 0x05;
 const uint32_t kMultiAxisUsageNumber = 0x08;
 const uint32_t kAxisMinimumUsageNumber = 0x30;
 
 }  // namespace
@@ skipping 140 matching lines @@
         usage_page == kButtonUsagePage) {
       uint32_t button_index = usage - 1;
       if (button_index < WebGamepad::buttonsLengthCap) {
         associated.hid.button_elements[button_index] = element;
         pad.buttonsLength = std::max(pad.buttonsLength, button_index + 1);
       }
     }
     else if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Misc) {
       uint32_t axis_index = usage - kAxisMinimumUsageNumber;
       if (axis_index < WebGamepad::axesLengthCap) {
-        associated.hid.axis_minimums[axis_index] =
-            IOHIDElementGetLogicalMin(element);
-        associated.hid.axis_maximums[axis_index] =
-            IOHIDElementGetLogicalMax(element);
         associated.hid.axis_elements[axis_index] = element;
         pad.axesLength = std::max(pad.axesLength, axis_index + 1);
       } else {
         mapped_all_axes = false;
       }
     }
   }
 
   if (!mapped_all_axes) {
     // For axes who's usage puts them outside the standard axesLengthCap range.
     uint32_t next_index = 0;
     for (id elem in elements) {
       IOHIDElementRef element = reinterpret_cast<IOHIDElementRef>(elem);
       if (!CheckCollection(element))
         continue;
 
       uint32_t usage_page = IOHIDElementGetUsagePage(element);
       uint32_t usage = IOHIDElementGetUsage(element);
       if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Misc &&
           usage - kAxisMinimumUsageNumber >= WebGamepad::axesLengthCap &&
           usage_page <= kGameControlsUsagePage) {
         for (; next_index < WebGamepad::axesLengthCap; ++next_index) {
           if (associated.hid.axis_elements[next_index] == NULL)
             break;
         }
         if (next_index < WebGamepad::axesLengthCap) {
-          associated.hid.axis_minimums[next_index] =
-              IOHIDElementGetLogicalMin(element);
-          associated.hid.axis_maximums[next_index] =
-              IOHIDElementGetLogicalMax(element);
           associated.hid.axis_elements[next_index] = element;
           pad.axesLength = std::max(pad.axesLength, next_index + 1);
         }
       }
 
       if (next_index >= WebGamepad::axesLengthCap)
         break;
     }
   }
 
+  for (uint32_t axis_index = 0; axis_index < pad.axesLength; ++axis_index) {
+    IOHIDElementRef element = associated.hid.axis_elements[axis_index];
+    if (element != NULL) {
+      CFIndex axis_min = IOHIDElementGetLogicalMin(element);
+      CFIndex axis_max = IOHIDElementGetLogicalMax(element);
+
+      // Some HID axes report a logical range of -1 to 0 signed, which must be
+      // interpreted as 0 to -1 unsigned for correct normalization behavior.
+      if (axis_min == -1 && axis_max == 0) {
+        axis_max = -1;
+        axis_min = 0;
+      }
+
+      associated.hid.axis_minimums[axis_index] = axis_min;
+      associated.hid.axis_maximums[axis_index] = axis_max;
+      associated.hid.axis_report_sizes[axis_index] =
+          IOHIDElementGetReportSize(element);
+    }
+  }
+
   return (pad.axesLength > 0 || pad.buttonsLength > 0);
 }
 
 size_t GamepadPlatformDataFetcherMac::GetEmptySlot() {
   // Find a free slot for this device.
   for (size_t slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
     if (!pad_state_[slot].data.connected)
       return slot;
   }
   return WebGamepads::itemsLengthCap;
@@ skipping 147 matching lines @@
       pad.buttons[i].pressed = IOHIDValueGetIntegerValue(value);
       pad.buttons[i].value = pad.buttons[i].pressed ? 1.f : 0.f;
       pad.timestamp = std::max(pad.timestamp, IOHIDValueGetTimeStamp(value));
       return;
     }
   }
 
   // Find and fill in the associated axis event, if any.
   for (size_t i = 0; i < pad.axesLength; ++i) {
     if (associated.hid.axis_elements[i] == element) {
-      pad.axes[i] = NormalizeAxis(IOHIDValueGetIntegerValue(value),
-                                  associated.hid.axis_minimums[i],
-                                  associated.hid.axis_maximums[i]);
+      CFIndex axis_min = associated.hid.axis_minimums[i];
+      CFIndex axis_max = associated.hid.axis_maximums[i];
+      CFIndex axis_value = IOHIDValueGetIntegerValue(value);
+
+      if (axis_min > axis_max) {
+        // We'll need to interpret this axis as unsigned during normalization.
+        switch (associated.hid.axis_report_sizes[i]) {
+          case 8:
+            pad.axes[i] = NormalizeUInt8Axis(axis_value, axis_min, axis_max);
+            break;
+          case 16:
+            pad.axes[i] = NormalizeUInt16Axis(axis_value, axis_min, axis_max);
+            break;
+          case 32:
+            pad.axes[i] = NormalizeUInt32Axis(axis_value, axis_min, axis_max);
+            break;
+        }
+      } else {
+        pad.axes[i] = NormalizeAxis(axis_value, axis_min, axis_max);
+      }
+
       pad.timestamp = std::max(pad.timestamp, IOHIDValueGetTimeStamp(value));
       return;
     }
   }
 }
 
 void GamepadPlatformDataFetcherMac::XboxDeviceAdd(XboxController* device) {
   if (!enabled_)
     return;
 
@@ skipping 92 matching lines @@
     pads->length = 0;
     return;
   }
 
   pads->length = WebGamepads::itemsLengthCap;
   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i)
     MapAndSanitizeGamepadData(&pad_state_[i], &pads->items[i]);
 }
 
 }  // namespace content