Refactored gamepad polling to support dynamic sources

device/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 "device/gamepad/gamepad_platform_data_fetcher_mac.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include "base/mac/foundation_util.h"
@@ skipping 56 matching lines @@
 const uint32_t kJoystickUsageNumber = 0x04;
 const uint32_t kGameUsageNumber = 0x05;
 const uint32_t kMultiAxisUsageNumber = 0x08;
 const uint32_t kAxisMinimumUsageNumber = 0x30;
 
 }  // namespace
 
 GamepadPlatformDataFetcherMac::GamepadPlatformDataFetcherMac()
     : enabled_(true), paused_(false) {
   memset(associated_, 0, sizeof(associated_));
+}
 
-  xbox_fetcher_.reset(new XboxDataFetcher(this));
-  if (!xbox_fetcher_->RegisterForNotifications())
-    xbox_fetcher_.reset();
+GamepadSource GamepadPlatformDataFetcherMac::source() {
+  return Factory::static_source();
+}
 
+void GamepadPlatformDataFetcherMac::OnAddedToProvider() {
   hid_manager_ref_.reset(
       IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone));
   if (CFGetTypeID(hid_manager_ref_) != IOHIDManagerGetTypeID()) {
     enabled_ = false;
     return;
   }
 
   base::scoped_nsobject<NSArray> criteria(
       [[NSArray alloc] initWithObjects:DeviceMatching(kGenericDesktopUsagePage,
                                                       kJoystickUsageNumber),
@@ skipping 17 matching lines @@
 
   // Register for value change notifications.
   IOHIDManagerRegisterInputValueCallback(hid_manager_ref_, ValueChangedCallback,
                                          this);
 
   IOHIDManagerScheduleWithRunLoop(hid_manager_ref_, CFRunLoopGetMain(),
                                   kCFRunLoopDefaultMode);
 
   enabled_ = IOHIDManagerOpen(hid_manager_ref_, kIOHIDOptionsTypeNone) ==
              kIOReturnSuccess;
-
-  if (xbox_fetcher_)
-    xbox_fetcher_->RegisterForNotifications();
 }
 
 void GamepadPlatformDataFetcherMac::UnregisterFromNotifications() {
   IOHIDManagerUnscheduleFromRunLoop(hid_manager_ref_, CFRunLoopGetCurrent(),
                                     kCFRunLoopDefaultMode);
   IOHIDManagerClose(hid_manager_ref_, kIOHIDOptionsTypeNone);
-  if (xbox_fetcher_)
-    xbox_fetcher_->UnregisterFromNotifications();
 }
 
 void GamepadPlatformDataFetcherMac::PauseHint(bool pause) {
   paused_ = pause;
 }
 
 GamepadPlatformDataFetcherMac::~GamepadPlatformDataFetcherMac() {
   UnregisterFromNotifications();
 }
 
@@ skipping 33 matching lines @@
       if (usage == kJoystickUsageNumber || usage == kGameUsageNumber ||
           usage == kMultiAxisUsageNumber) {
         return true;
       }
     }
   }
   return false;
 }
 
 bool GamepadPlatformDataFetcherMac::AddButtonsAndAxes(NSArray* elements,
+                                                      PadState* state,
                                                       size_t slot) {
-  WebGamepad& pad = pad_state_[slot].data;
+  WebGamepad& pad = state->data;
   AssociatedData& associated = associated_[slot];
-  CHECK(!associated.is_xbox);
 
   pad.axesLength = 0;
   pad.buttonsLength = 0;
   pad.timestamp = 0;
   memset(pad.axes, 0, sizeof(pad.axes));
   memset(pad.buttons, 0, sizeof(pad.buttons));
 
   bool mapped_all_axes = true;
 
   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_Button &&
         usage_page == kButtonUsagePage) {
       uint32_t button_index = usage - 1;
       if (button_index < WebGamepad::buttonsLengthCap) {
-        associated.hid.button_elements[button_index] = element;
+        associated.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_elements[axis_index] = element;
+        associated.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)
+          if (associated.axis_elements[next_index] == NULL)
             break;
         }
         if (next_index < WebGamepad::axesLengthCap) {
-          associated.hid.axis_elements[next_index] = element;
+          associated.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];
+    IOHIDElementRef element = associated.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] =
+      associated.axis_minimums[axis_index] = axis_min;
+      associated.axis_maximums[axis_index] = axis_max;
+      associated.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)
+    if (associated_[slot].device_ref == nullptr)
       return slot;
   }
   return WebGamepads::itemsLengthCap;
 }
 
 size_t GamepadPlatformDataFetcherMac::GetSlotForDevice(IOHIDDeviceRef device) {
   for (size_t slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
     // If we already have this device, and it's already connected, don't do
     // anything now.
-    if (pad_state_[slot].data.connected && !associated_[slot].is_xbox &&
-        associated_[slot].hid.device_ref == device)
+    if (associated_[slot].device_ref == device)
       return WebGamepads::itemsLengthCap;
   }
   return GetEmptySlot();
 }
 
-size_t GamepadPlatformDataFetcherMac::GetSlotForXboxDevice(
-    XboxController* device) {
-  for (size_t slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
-    if (associated_[slot].is_xbox &&
-        associated_[slot].xbox.location_id == device->location_id()) {
-      if (pad_state_[slot].data.connected) {
-        // The device is already connected. No idea why we got a second "device
-        // added" call, but let's not add it twice.
-        DCHECK_EQ(associated_[slot].xbox.device, device);
-        return WebGamepads::itemsLengthCap;
-      } else {
-        // A device with the same location ID was previously connected, so put
-        // it in the same slot.
-        return slot;
-      }
-    }
-  }
-  return GetEmptySlot();
-}
-
 void GamepadPlatformDataFetcherMac::DeviceAdd(IOHIDDeviceRef device) {
   using base::mac::CFToNSCast;
   using base::mac::CFCastStrict;
 
   if (!enabled_)
     return;
 
+  NSNumber* location_id = CFToNSCast(CFCastStrict<CFNumberRef>(
+      IOHIDDeviceGetProperty(device, CFSTR(kIOHIDLocationIDKey))));
+  int location_int = [location_id intValue];
+
   // Find an index for this device.
   size_t slot = GetSlotForDevice(device);
 
   // We can't handle this many connected devices.
   if (slot == WebGamepads::itemsLengthCap)
     return;
 
   // Clear some state that may have been left behind by previous gamepads
   memset(&associated_[slot], 0, sizeof(AssociatedData));
 
+  PadState* state = GetPadState(location_int);
+  if (!state)
+    return;  // No available slot for this device
+
   NSNumber* vendor_id = CFToNSCast(CFCastStrict<CFNumberRef>(
       IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVendorIDKey))));
   NSNumber* product_id = CFToNSCast(CFCastStrict<CFNumberRef>(
       IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductIDKey))));
   NSString* product = CFToNSCast(CFCastStrict<CFStringRef>(
       IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey))));
   int vendor_int = [vendor_id intValue];
   int product_int = [product_id intValue];
 
   char vendor_as_str[5], product_as_str[5];
   snprintf(vendor_as_str, sizeof(vendor_as_str), "%04x", vendor_int);
   snprintf(product_as_str, sizeof(product_as_str), "%04x", product_int);
-  pad_state_[slot].mapper =
+  state->mapper =
       GetGamepadStandardMappingFunction(vendor_as_str, product_as_str);
 
-  NSString* ident = [NSString
-      stringWithFormat:@"%@ (%sVendor: %04x Product: %04x)", product,
-                       pad_state_[slot].mapper ? "STANDARD GAMEPAD " : "",
-                       vendor_int, product_int];
-  CopyNSStringAsUTF16LittleEndian(ident, pad_state_[slot].data.id,
-                                  sizeof(pad_state_[slot].data.id));
+  NSString* ident =
+      [NSString stringWithFormat:@"%@ (%sVendor: %04x Product: %04x)", product,
+                                 state->mapper ? "STANDARD GAMEPAD " : "",
+                                 vendor_int, product_int];
+  CopyNSStringAsUTF16LittleEndian(ident, state->data.id,
+                                  sizeof(state->data.id));
 
-  if (pad_state_[slot].mapper) {
-    CopyNSStringAsUTF16LittleEndian(@"standard", pad_state_[slot].data.mapping,
-                                    sizeof(pad_state_[slot].data.mapping));
+  if (state->mapper) {
+    CopyNSStringAsUTF16LittleEndian(@"standard", state->data.mapping,
+                                    sizeof(state->data.mapping));
   } else {
-    pad_state_[slot].data.mapping[0] = 0;
+    state->data.mapping[0] = 0;
   }
 
   base::ScopedCFTypeRef<CFArrayRef> elements(
       IOHIDDeviceCopyMatchingElements(device, NULL, kIOHIDOptionsTypeNone));
 
-  if (!AddButtonsAndAxes(CFToNSCast(elements), slot))
+  if (!AddButtonsAndAxes(CFToNSCast(elements), state, slot))
     return;
 
-  associated_[slot].hid.device_ref = device;
-  pad_state_[slot].data.connected = true;
-  pad_state_[slot].axis_mask = 0;
-  pad_state_[slot].button_mask = 0;
+  associated_[slot].location_id = location_int;
+  associated_[slot].device_ref = device;
+  state->data.connected = true;
 }
 
 void GamepadPlatformDataFetcherMac::DeviceRemove(IOHIDDeviceRef device) {
   if (!enabled_)
     return;
 
   // Find the index for this device.
   size_t slot;
   for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
-    if (pad_state_[slot].data.connected && !associated_[slot].is_xbox &&
-        associated_[slot].hid.device_ref == device)
+    if (associated_[slot].device_ref == device)
       break;
   }
   DCHECK(slot < WebGamepads::itemsLengthCap);
   // Leave associated device_ref so that it will be reconnected in the same
   // location. Simply mark it as disconnected.
-  pad_state_[slot].data.connected = false;
+  associated_[slot].location_id = 0;
+  associated_[slot].device_ref = nullptr;
 }
 
 void GamepadPlatformDataFetcherMac::ValueChanged(IOHIDValueRef value) {
   if (!enabled_ || paused_)
     return;
 
   IOHIDElementRef element = IOHIDValueGetElement(value);
   IOHIDDeviceRef device = IOHIDElementGetDevice(element);
 
   // Find device slot.
   size_t slot;
   for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
-    if (pad_state_[slot].data.connected && !associated_[slot].is_xbox &&
-        associated_[slot].hid.device_ref == device)
+    if (associated_[slot].device_ref == device)
       break;
   }
   if (slot == WebGamepads::itemsLengthCap)
     return;
 
-  WebGamepad& pad = pad_state_[slot].data;
+  PadState* state = GetPadState(associated_[slot].location_id);
+  if (!state)
+    return;
+
+  WebGamepad& pad = state->data;
   AssociatedData& associated = associated_[slot];
 
   uint32_t value_length = IOHIDValueGetLength(value);
   if (value_length > 4) {
     // Workaround for bizarre issue with PS3 controllers that try to return
     // massive (30+ byte) values and crash IOHIDValueGetIntegerValue
     return;
   }
 
   // Find and fill in the associated button event, if any.
   for (size_t i = 0; i < pad.buttonsLength; ++i) {
-    if (associated.hid.button_elements[i] == element) {
+    if (associated.button_elements[i] == element) {
       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) {
-      CFIndex axis_min = associated.hid.axis_minimums[i];
-      CFIndex axis_max = associated.hid.axis_maximums[i];
+    if (associated.axis_elements[i] == element) {
+      CFIndex axis_min = associated.axis_minimums[i];
+      CFIndex axis_max = associated.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]) {
+        switch (associated.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) {
+void GamepadPlatformDataFetcherMac::GetGamepadData(bool) {
   if (!enabled_)
     return;
 
-  size_t slot = GetSlotForXboxDevice(device);
-
-  // We can't handle this many connected devices.
-  if (slot == WebGamepads::itemsLengthCap)
-    return;
-
-  device->SetLEDPattern(
-      (XboxController::LEDPattern)(XboxController::LED_FLASH_TOP_LEFT + slot));
-
-  NSString* ident = [NSString
-      stringWithFormat:@"%@ (STANDARD GAMEPAD Vendor: %04x Product: %04x)",
-                       device->GetControllerType() ==
-                               XboxController::XBOX_360_CONTROLLER
-                           ? @"Xbox 360 Controller"
-                           : @"Xbox One Controller",
-                       device->GetProductId(), device->GetVendorId()];
-  CopyNSStringAsUTF16LittleEndian(ident, pad_state_[slot].data.id,
-                                  sizeof(pad_state_[slot].data.id));
-
-  CopyNSStringAsUTF16LittleEndian(@"standard", pad_state_[slot].data.mapping,
-                                  sizeof(pad_state_[slot].data.mapping));
-
-  associated_[slot].is_xbox = true;
-  associated_[slot].xbox.device = device;
-  associated_[slot].xbox.location_id = device->location_id();
-  pad_state_[slot].data.connected = true;
-  pad_state_[slot].data.axesLength = 4;
-  pad_state_[slot].data.buttonsLength = 17;
-  pad_state_[slot].data.timestamp = 0;
-  pad_state_[slot].mapper = 0;
-  pad_state_[slot].axis_mask = 0;
-  pad_state_[slot].button_mask = 0;
-}
-
-void GamepadPlatformDataFetcherMac::XboxDeviceRemove(XboxController* device) {
-  if (!enabled_)
-    return;
-
-  // Find the index for this device.
-  size_t slot;
-  for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
-    if (pad_state_[slot].data.connected && associated_[slot].is_xbox &&
-        associated_[slot].xbox.device == device)
-      break;
+  // Loop through and GetPadState to indicate the devices are still connected.
+  for (size_t slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
+    if (associated_[slot].device_ref != nullptr) {
+      GetPadState(associated_[slot].location_id);
+    }
   }
-  DCHECK(slot < WebGamepads::itemsLengthCap);
-  // Leave associated location id so that the controller will be reconnected in
-  // the same slot if it is plugged in again. Simply mark it as disconnected.
-  pad_state_[slot].data.connected = false;
-}
-
-void GamepadPlatformDataFetcherMac::XboxValueChanged(
-    XboxController* device,
-    const XboxController::Data& data) {
-  // Find device slot.
-  size_t slot;
-  for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
-    if (pad_state_[slot].data.connected && associated_[slot].is_xbox &&
-        associated_[slot].xbox.device == device)
-      break;
-  }
-  if (slot == WebGamepads::itemsLengthCap)
-    return;
-
-  WebGamepad& pad = pad_state_[slot].data;
-
-  for (size_t i = 0; i < 6; i++) {
-    pad.buttons[i].pressed = data.buttons[i];
-    pad.buttons[i].value = data.buttons[i] ? 1.0f : 0.0f;
-  }
-  pad.buttons[6].pressed = data.triggers[0] > kDefaultButtonPressedThreshold;
-  pad.buttons[6].value = data.triggers[0];
-  pad.buttons[7].pressed = data.triggers[1] > kDefaultButtonPressedThreshold;
-  pad.buttons[7].value = data.triggers[1];
-  for (size_t i = 8; i < 17; i++) {
-    pad.buttons[i].pressed = data.buttons[i - 2];
-    pad.buttons[i].value = data.buttons[i - 2] ? 1.0f : 0.0f;
-  }
-  for (size_t i = 0; i < arraysize(data.axes); i++) {
-    pad.axes[i] = data.axes[i];
-  }
-
-  pad.timestamp = base::TimeTicks::Now().ToInternalValue();
-}
-
-void GamepadPlatformDataFetcherMac::GetGamepadData(WebGamepads* pads, bool) {
-  if (!enabled_ && !xbox_fetcher_) {
-    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 device