Implement support for USB Xbox360 controllers without a driver on Mac.

content/browser/gamepad/xbox_data_fetcher_mac.cc

Index: content/browser/gamepad/xbox_data_fetcher_mac.cc
diff --git a/content/browser/gamepad/xbox_data_fetcher_mac.cc b/content/browser/gamepad/xbox_data_fetcher_mac.cc
new file mode 100644
index 0000000000000000000000000000000000000000..16c8da9bf23fb3a78baecd89443f75fb238e51e9
--- /dev/null
+++ b/content/browser/gamepad/xbox_data_fetcher_mac.cc
@@ -0,0 +1,590 @@
+// Copyright 2013 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/xbox_data_fetcher_mac.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>

[Avi (use Gerrit), 2013/04/22 21:00:51]

alphabetize

[jeremya, 2013/04/23 04:38:25]

Done.

+#include <IOKit/usb/IOUSBLib.h>
+#include <IOKit/usb/USB.h>
+
+#include "base/logging.h"
+#include "base/mac/scoped_cftyperef.h"
+
+namespace {
+const int32 kVendorMicrosoft = 0x045e;
+const int32 kProduct360Controller = 0x028e;
+
+const int kReadEndpoint = 1;
+const int kControlEndpoint = 2;
+
+#pragma pack(push, 1)
+struct ButtonData {
+  bool dpad_up    : 1;
+  bool dpad_down  : 1;
+  bool dpad_left  : 1;
+  bool dpad_right : 1;
+
+  bool start             : 1;
+  bool back              : 1;
+  bool stick_left_click  : 1;
+  bool stick_right_click : 1;
+
+  bool bumper_left  : 1;
+  bool bumper_right : 1;
+  bool guide        : 1;
+  bool dummy1       : 1;  // Always 0.
+
+  bool a : 1;
+  bool b : 1;
+  bool x : 1;
+  bool y : 1;
+
+  uint8 trigger_left;
+  uint8 trigger_right;
+
+  int16 stick_left_x;
+  int16 stick_left_y;
+  int16 stick_right_x;
+  int16 stick_right_y;
+
+  // Always 0.
+  uint32 dummy2;
+  uint16 dummy3;
+};
+#pragma pack(pop)
+
+COMPILE_ASSERT(sizeof(ButtonData) == 0x12, xbox_button_data_wrong_size);
+
+enum {
+  CONTROL_MESSAGE_SET_RUMBLE = 0,
+  CONTROL_MESSAGE_SET_LED = 1,
+};
+
+// From MSDN:
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ee417001(v=vs.85).aspx#dead_zone
+const int16 kLeftThumbDeadzone = 7849;
+const int16 kRightThumbDeadzone = 8689;
+const uint8 kTriggerDeadzone = 30;
+
+void NormalizeAxis(int16 x,
+                   int16 y,
+                   int16 deadzone,
+                   float* x_out,
+                   float* y_out) {
+  float x_val = (float)x;
+  float y_val = (float)y;
+
+  // Determine how far the stick is pushed.
+  float real_magnitude = sqrtf(x_val * x_val + y_val * y_val);
+
+  // Check if the controller is outside a circular dead zone.
+  if (real_magnitude > deadzone) {
+    // Clip the magnitude at its expected maximum value.
+    float magnitude = real_magnitude > 32767 ? 32767 : real_magnitude;
+
+    // Adjust magnitude relative to the end of the dead zone.
+    magnitude -= deadzone;
+
+    // Normalize the magnitude with respect to its expected range giving a
+    // magnitude value of 0.0 to 1.0
+    float ratio = (magnitude / (32767 - deadzone)) / real_magnitude;
+
+    // Y is negated because xbox controllers have an opposite sign from
+    // the 'standard controller' recommendations.
+    *x_out = x_val * ratio;
+    *y_out = -y_val * ratio;
+  } else {
+    // If the controller is in the deadzone zero out the magnitude.
+    *x_out = *y_out = 0.0f;
+  }
+}
+
+static float NormalizeTrigger(uint8 value) {
+  return value < kTriggerDeadzone ? 0 :
+      (float)(value - kTriggerDeadzone) / (kuint8max - kTriggerDeadzone);
+}
+
+void NormalizeButtonData(const ButtonData& data,
+                         XboxController::Data* normalized_data) {
+  normalized_data->buttons[0] = data.a ? 1.f : 0.f;
+  normalized_data->buttons[1] = data.b ? 1.f : 0.f;
+  normalized_data->buttons[2] = data.x ? 1.f : 0.f;
+  normalized_data->buttons[3] = data.y ? 1.f : 0.f;
+  normalized_data->buttons[4] = data.bumper_left ? 1.f : 0.f;
+  normalized_data->buttons[5] = data.bumper_right ? 1.f : 0.f;
+  normalized_data->buttons[6] = NormalizeTrigger(data.trigger_left);
+  normalized_data->buttons[7] = NormalizeTrigger(data.trigger_right);
+  normalized_data->buttons[8] = data.back ? 1.f : 0.f;
+  normalized_data->buttons[9] = data.start ? 1.f : 0.f;
+  normalized_data->buttons[10] = data.stick_left_click ? 1.f : 0.f;
+  normalized_data->buttons[11] = data.stick_right_click ? 1.f : 0.f;
+  normalized_data->buttons[12] = data.dpad_up ? 1.f : 0.f;
+  normalized_data->buttons[13] = data.dpad_down ? 1.f : 0.f;
+  normalized_data->buttons[14] = data.dpad_left ? 1.f : 0.f;
+  normalized_data->buttons[15] = data.dpad_right ? 1.f : 0.f;
+  normalized_data->buttons[16] = data.guide ? 1.f : 0.f;
+  NormalizeAxis(data.stick_left_x,
+                data.stick_left_y,
+                kLeftThumbDeadzone,
+                &normalized_data->axes[0],
+                &normalized_data->axes[1]);
+  NormalizeAxis(data.stick_right_x,
+                data.stick_right_y,
+                kRightThumbDeadzone,
+                &normalized_data->axes[2],
+                &normalized_data->axes[3]);
+}
+}  // namespace
+
+XboxController::XboxController(Delegate* delegate)
+    : device_(NULL),
+      interface_(NULL),
+      device_is_open_(false),
+      interface_is_open_(false),
+      source_(NULL),
+      read_buffer_size_(0),
+      led_pattern_(LED_NUM_PATTERNS),
+      location_id_(0),
+      delegate_(delegate) {
+}
+
+XboxController::~XboxController() {
+  if (source_)
+    CFRunLoopSourceInvalidate(source_);
+  if (interface_) {
+    if (interface_is_open_)
+      (*interface_)->USBInterfaceClose(interface_);
+    (*interface_)->Release(interface_);
+  }
+  if (device_) {
+    if (device_is_open_)
+      (*device_)->USBDeviceClose(device_);
+    (*device_)->Release(device_);
+  }
+}
+
+bool XboxController::OpenDevice(io_service_t service) {
+  kern_return_t kr;
+  HRESULT res;
+
+  IOCFPlugInInterface **plugin;
+  SInt32 score;  // Unused, but required for IOCreatePlugInInterfaceForService.
+  kr = IOCreatePlugInInterfaceForService(service,
+                                         kIOUSBDeviceUserClientTypeID,
+                                         kIOCFPlugInInterfaceID,
+                                         &plugin,
+                                         &score);
+  IOObjectRelease(service);

[Avi (use Gerrit), 2013/04/22 21:00:51]

If you're consuming the service, you may want to note that in the function
comments.

[jeremya, 2013/04/23 04:38:25]

Oops, looks like this was actually being double-released. Removed.

+  service = 0;
+  if (kr != KERN_SUCCESS)
+    return false;
+
+  // Use IOUSBDeviceStruct320 for support on MacOS 10.6.

[Avi (use Gerrit), 2013/04/22 21:00:51]

I don't understand your comment here. "For support on 10.6" as opposed to what?

[jeremya, 2013/04/23 04:38:25]

There are various versions of the IOUSBDeviceStruct struct, this one is 3.2.0
which is the latest one that is supported on 10.6 (it actually supports back to
10.5.4). See
https://github.com/opensource-apple/IOUSBFamily/blob/master/IOUSBFamily/Heade...

I've clarified the comment.

+  res = (*plugin)->QueryInterface(
+      plugin,
+      CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID320),
+      (LPVOID *)&device_);
+  (*plugin)->Release(plugin);
+  plugin = NULL;
+  if (res || !device_)
+    return false;
+
+  // Open the device and configure it.
+  kr = (*device_)->USBDeviceOpen(device_);
+  if (kr != KERN_SUCCESS)
+    return false;
+  device_is_open_ = true;
+
+  // Xbox controllers have one configuration option which has configuration
+  // value 1. Try to set it and fail out if it couldn't be configured.
+  IOUSBConfigurationDescriptorPtr config_desc;
+  kr = (*device_)->GetConfigurationDescriptorPtr(device_, 0, &config_desc);
+  if (kr != KERN_SUCCESS)
+    return false;
+  kr = (*device_)->SetConfiguration(device_, config_desc->bConfigurationValue);
+  if (kr != KERN_SUCCESS)
+    return false;
+
+  // The device has 4 interfaces. They are as follows:
+  // Protocol 1:
+  //  - Endpoint 1 (in) : Controller events, including button presses.
+  //  - Endpoint 2 (out): Rumble pack and LED control
+  // Protocol 2 has a single endpoint to read from a connected ChatPad device.
+  // Protocol 3 is used by a connected headset device.
+  // The device also has an interface on subclass 253, protocol 10 with no
+  // endpoints.  It is unused.
+  //
+  // We don't currently support the ChatPad or headset, so protocol 1 is the
+  // only protocol we care about.
+  //
+  // For more detail, see https://github.com/Grumbel/xboxdrv/blob/master/PROTOCOL
+  IOUSBFindInterfaceRequest request;
+  request.bInterfaceClass = 255;
+  request.bInterfaceSubClass = 93;
+  request.bInterfaceProtocol = 1;
+  request.bAlternateSetting = kIOUSBFindInterfaceDontCare;
+  io_iterator_t iter;
+  kr = (*device_)->CreateInterfaceIterator(device_, &request, &iter);
+  if (kr != KERN_SUCCESS)
+    return false;
+
+  // There should be exactly one usb interface which matches the requested
+  // settings.
+  io_service_t usb_interface = IOIteratorNext(iter);
+  if (!usb_interface)
+    return false;
+
+  // We need to make an InterfaceInterface to communicate with the device
+  // endpoint. This is the same process as earlier: first make a
+  // PluginInterface from the io_service then make the InterfaceInterface from
+  // that.
+  IOCFPlugInInterface **plugin_interface;
+  kr = IOCreatePlugInInterfaceForService(usb_interface,
+                                         kIOUSBInterfaceUserClientTypeID,
+                                         kIOCFPlugInInterfaceID,
+                                         &plugin_interface,
+                                         &score);
+  if (kr != KERN_SUCCESS || !plugin_interface)
+    return false;
+
+  // Release the usb interface, and any subsequent interfaces returned by the
+  // iterator. (There shouldn't be any, but in case a future device does
+  // contain more interfaces, this will serve to avoid memory leaks.)
+  do {
+    IOObjectRelease(usb_interface);
+  } while ((usb_interface = IOIteratorNext(iter)));
+
+  // Actually create the interface.
+  kr = (*plugin_interface)->QueryInterface(
+      plugin_interface,
+      CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID300),
+      (LPVOID *)&interface_);
+
+  (*plugin_interface)->Release(plugin_interface);
+
+  if (kr != KERN_SUCCESS || !interface_)
+    return false;
+
+  // Actually open the interface.
+  kr = (*interface_)->USBInterfaceOpen(interface_);
+  if (kr != KERN_SUCCESS)
+    return false;
+  interface_is_open_ = true;
+
+  kr = (*interface_)->CreateInterfaceAsyncEventSource(interface_, &source_);
+  if (kr != KERN_SUCCESS || !source_)
+    return false;
+  CFRunLoopAddSource(CFRunLoopGetMain(), source_, kCFRunLoopDefaultMode);
+  // The CFRunLoop retains the source.
+  CFRelease(source_);
+
+  // The interface should have two pipes. Pipe 1 with direction kUSBIn and pipe
+  // 2 with direction kUSBOut. Both pipes should have type kUSBInterrupt.
+  uint8 num_endpoints;
+  kr = (*interface_)->GetNumEndpoints(interface_, &num_endpoints);
+  if (kr != KERN_SUCCESS || num_endpoints < 2)
+    return false;
+
+  for (int i = 1; i <= num_endpoints; i++) {
+    uint8 direction;
+    uint8 number;
+    uint8 transfer_type;
+    uint16 max_packet_size;
+    uint8 interval;
+
+    kr = (*interface_)->GetPipeProperties(interface_,
+                                          i,
+                                          &direction,
+                                          &number,
+                                          &transfer_type,
+                                          &max_packet_size,
+                                          &interval);
+    if (kr != KERN_SUCCESS || transfer_type != kUSBInterrupt)
+      return false;
+    if (i == kReadEndpoint) {
+      if (direction != kUSBIn)
+        return false;
+      if (max_packet_size > 32)
+        return false;
+      read_buffer_.reset(new uint8[max_packet_size]);
+      read_buffer_size_ = max_packet_size;
+      QueueRead();
+    } else if (i == kControlEndpoint) {
+      if (direction != kUSBOut)
+        return false;
+    }
+  }
+
+  // If its useful, the deviceId can be used to track controllers through
+  // reconnections.
+  kr = (*device_)->GetLocationID(device_, &location_id_);
+  if (kr != KERN_SUCCESS)
+    return false;
+
+  return true;
+}
+
+void XboxController::SetLEDPattern(LEDPattern pattern) {
+  led_pattern_ = pattern;
+  const UInt8 length = 3;
+  UInt8* buffer = new UInt8[length];
+  buffer[0] = (UInt8)CONTROL_MESSAGE_SET_LED;
+  buffer[1] = length;
+  buffer[2] = (UInt8)pattern;
+  kern_return_t kr = (*interface_)->WritePipeAsync(interface_,
+                                                   kControlEndpoint,
+                                                   buffer,
+                                                   (UInt32)length,
+                                                   WriteComplete,
+                                                   buffer);
+  if (kr != KERN_SUCCESS) {
+    IOError();
+    return;
+  }
+}
+
+void XboxController::WriteComplete(void* context, IOReturn result, void* arg0) {
+  // Ignoring any errors sending data, because they will usually only occur
+  // when the device is disconnected, in which case it really doesn't matter if
+  // the data got to the controller or not.
+  if (result != KERN_SUCCESS)
+    return;
+
+  UInt8* buffer = (UInt8*)context;
+  delete[] buffer;
+}
+
+void XboxController::GotData(void* context, IOReturn result, void* arg0) {
+  uint32 bytesRead = (uint32)arg0;
+  XboxController* controller = static_cast<XboxController*>(context);
+
+  if (result != kIOReturnSuccess) {
+    // This will happen if the device was disconnected. The gamepad has
+    // probably been destroyed by a meteorite.
+    controller->IOError();
+    return;
+  }
+
+  controller->ProcessPacket(bytesRead);
+
+  // Queue up another read.
+  controller->QueueRead();
+}
+
+void XboxController::ProcessPacket(uint32 length) {
+  if (length < 3) return;
+  DCHECK(length <= read_buffer_size_);
+  if (length > read_buffer_size_) {
+    IOError();
+    return;
+  }
+  uint8* buffer = read_buffer_.get();
+
+  if (buffer[1] != length)
+    // Length in packet doesn't match length reported by USB.
+    return;
+
+  uint8 type = buffer[0];
+  buffer += 2;
+  length -= 2;
+  switch (type) {
+    case STATUS_MESSAGE_BUTTONS: {
+      if (length != sizeof(ButtonData))
+        return;
+      ButtonData data;
+      memcpy(&data, buffer, sizeof(data));
+      Data normalized_data;
+      NormalizeButtonData(data, &normalized_data);
+      delegate_->XboxControllerGotData(this, normalized_data);
+      break;
+    }
+    case STATUS_MESSAGE_LED:
+      // The controller sends one of these messages every time the LED pattern
+      // is set, as well as once when it is plugged in.
+      if (led_pattern_ == LED_NUM_PATTERNS && buffer[0] < LED_NUM_PATTERNS)
+        led_pattern_ = (LEDPattern)buffer[0];
+      break;
+    default:
+      // Unknown packet: ignore!
+      break;
+  }
+}
+
+void XboxController::QueueRead() {
+  kern_return_t kr = (*interface_)->ReadPipeAsync(interface_,
+                                                  kReadEndpoint,
+                                                  read_buffer_.get(),
+                                                  read_buffer_size_,
+                                                  GotData,
+                                                  this);
+  if (kr != KERN_SUCCESS)
+    IOError();
+}
+
+void XboxController::IOError() {
+  delegate_->XboxControllerError(this);
+}
+
+//-----------------------------------------------------------------------------
+
+XboxDataFetcher::XboxDataFetcher(Delegate* delegate)
+    : delegate_(delegate),
+      listening_(false),
+      port_(NULL),
+      source_(NULL),
+      device_added_iter_(0),
+      device_removed_iter_(0) {
+}
+
+XboxDataFetcher::~XboxDataFetcher() {
+  while (!controllers_.empty()) {
+    RemoveController(*controllers_.begin());
+  }
+  UnregisterFromNotifications();
+}
+
+void XboxDataFetcher::DeviceAdded(void* context, io_iterator_t iterator) {
+  DCHECK(context);
+  XboxDataFetcher* fetcher = static_cast<XboxDataFetcher*>(context);
+  io_service_t ref;
+  while ((ref = IOIteratorNext(iterator))) {
+    XboxController* controller = new XboxController(fetcher);
+    if (controller->OpenDevice(ref)) {
+      fetcher->AddController(controller);
+    } else {
+      delete controller;
+    }
+    IOObjectRelease(ref);

[Avi (use Gerrit), 2013/04/22 21:00:51]

Huh? I thought OpenDevice consumed the ref...

base/mac/scoped_ioobject.h's ScopedIOObject perhaps?

[jeremya, 2013/04/23 04:38:25]

Right you are :) I added the releasing afterwards, and missed this. I'll take a
look at ScopedIOObject; didn't realise that existed.

+  }
+}
+
+void XboxDataFetcher::DeviceRemoved(void* context, io_iterator_t iterator) {
+  DCHECK(context);
+  XboxDataFetcher* fetcher = static_cast<XboxDataFetcher*>(context);
+  io_service_t ref;
+  while ((ref = IOIteratorNext(iterator))) {
+    base::mac::ScopedCFTypeRef<CFNumberRef> number(
+        (CFNumberRef)IORegistryEntryCreateCFProperty(
+            ref,
+            CFSTR(kUSBDevicePropertyLocationID),
+            kCFAllocatorDefault,
+            kNilOptions));
+    UInt32 location_id = 0;
+    CFNumberGetValue(number, kCFNumberSInt32Type, &location_id);
+    fetcher->RemoveControllerByLocationID(location_id);
+    IOObjectRelease(ref);

[Avi (use Gerrit), 2013/04/22 21:00:51]

ScopedIOObject

[jeremya, 2013/04/23 04:38:25]

Done.

+  }
+}
+
+void XboxDataFetcher::RegisterForNotifications() {
+  if (listening_)
+    return;
+  base::mac::ScopedCFTypeRef<CFNumberRef> vendor_cf(
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
+                     &kVendorMicrosoft));
+  base::mac::ScopedCFTypeRef<CFNumberRef> product_cf(
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
+                     &kProduct360Controller));
+  base::mac::ScopedCFTypeRef<CFMutableDictionaryRef> matching_dict(
+      IOServiceMatching(kIOUSBDeviceClassName));
+  if (!matching_dict)
+    return;
+  CFDictionarySetValue(matching_dict, CFSTR(kUSBVendorID), vendor_cf);
+  CFDictionarySetValue(matching_dict, CFSTR(kUSBProductID), product_cf);
+  port_ = IONotificationPortCreate(kIOMasterPortDefault);
+  if (!port_)
+    return;
+  source_ = IONotificationPortGetRunLoopSource(port_);
+  if (!source_)
+    return;
+  CFRunLoopAddSource(CFRunLoopGetMain(), source_, kCFRunLoopDefaultMode);
+  CFRelease(source_);
+
+  listening_ = true;
+
+  IOReturn ret;
+
+  // IOServiceAddMatchingNotification() releases the dictionary when it's done.
+  // Retain it before each call to IOServiceAddMatchingNotification to keep
+  // things balanced.
+  CFRetain(matching_dict);
+  ret = IOServiceAddMatchingNotification(port_,
+                                         kIOFirstMatchNotification,
+                                         matching_dict,
+                                         DeviceAdded,
+                                         this,
+                                         &device_added_iter_);
+  if (ret != kIOReturnSuccess) {
+    LOG(ERROR) << "Error listening for Xbox controller add events: " << ret;
+    return;
+  }
+  DeviceAdded(this, device_added_iter_);
+
+  CFRetain(matching_dict);
+  ret = IOServiceAddMatchingNotification(port_,
+                                         kIOTerminatedNotification,
+                                         matching_dict,
+                                         DeviceRemoved,
+                                         this,
+                                         &device_removed_iter_);
+  if (ret != kIOReturnSuccess) {
+    LOG(ERROR) << "Error listening for Xbox controller remove events: " << ret;
+    return;
+  }
+  DeviceRemoved(this, device_removed_iter_);
+}
+
+void XboxDataFetcher::UnregisterFromNotifications() {
+  if (!listening_)
+    return;
+  listening_ = false;
+  if (source_)
+    CFRunLoopSourceInvalidate(source_);
+  source_ = NULL;
+  if (port_)
+    IONotificationPortDestroy(port_);
+  port_ = NULL;
+  if (device_added_iter_)
+    IOObjectRelease(device_added_iter_);
+  device_added_iter_ = 0;
+  if (device_removed_iter_)
+    IOObjectRelease(device_removed_iter_);
+  device_removed_iter_ = 0;
+}
+
+void XboxDataFetcher::AddController(XboxController* controller) {
+  controllers_.insert(controller);
+  delegate_->XboxDeviceAdd(controller);
+}
+
+void XboxDataFetcher::RemoveController(XboxController* controller) {
+  controllers_.erase(controller);
+  delegate_->XboxDeviceRemove(controller);
+  delete controller;
+}
+
+void XboxDataFetcher::RemoveControllerByLocationID(uint32 location_id) {
+  XboxController* controller = NULL;
+  for (std::set<XboxController*>::iterator i = controllers_.begin();
+       i != controllers_.end();
+       ++i) {
+    if ((*i)->location_id() == location_id) {
+      controller = *i;
+      break;
+    }
+  }
+  if (controller)
+    RemoveController(controller);
+}
+
+void XboxDataFetcher::XboxControllerGotData(XboxController* controller,
+                                            const XboxController::Data& data) {
+  delegate_->XboxValueChanged(controller, data);
+}
+
+void XboxDataFetcher::XboxControllerError(XboxController* controller) {
+  RemoveController(controller);
+}