Add Mac implementation of data_fetcher for gamepad.

content/browser/gamepad/data_fetcher_mac.mm

Index: content/browser/gamepad/data_fetcher_mac.mm
diff --git a/content/browser/gamepad/data_fetcher_mac.mm b/content/browser/gamepad/data_fetcher_mac.mm
new file mode 100644
index 0000000000000000000000000000000000000000..4917576984bb149764b4d03aeb2dea979e364073
--- /dev/null
+++ b/content/browser/gamepad/data_fetcher_mac.mm
@@ -0,0 +1,289 @@
+// Copyright (c) 2011 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/data_fetcher_mac.h"
+
+#include "base/mac/foundation_util.h"
+#include "base/memory/scoped_nsobject.h"
+#include "base/string16.h"
+#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
+
+#include <IOKit/hid/IOHIDKeys.h>
+#import <Foundation/NSArray.h>

[Avi (use Gerrit), 2011/12/07 04:12:46]

#import <Foundation/Foundation.h> if not #import <Cocoa/Cocoa.h>

[scottmg, 2011/12/07 04:39:36]

Done.

+#import <Foundation/NSDictionary.h>
+
+namespace content {
+
+namespace {
+
+NSDictionary* DeviceMatching(unsigned usage_page, unsigned usage) {
+  return [NSDictionary dictionaryWithObjectsAndKeys:
+      [NSNumber numberWithInt: usage_page],

[Avi (use Gerrit), 2011/12/07 04:12:46]

no space after : here, and on line 25.

[scottmg, 2011/12/07 04:39:36]

Done.

+          base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsagePageKey)),
+      [NSNumber numberWithInt: 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;
+}
+
+// http://www.usb.org/developers/hidpage
+const uint32_t kGenericDesktopUsagePage = 0x01;
+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;
+const uint32_t kAxisMaximumUsageNumber = 0x35;
+
+} // namespace
+
+GamepadDataFetcherMac::GamepadDataFetcherMac() : enabled_(true) {
+  hid_manager_ref_.reset(IOHIDManagerCreate(kCFAllocatorDefault,
+                                            kIOHIDOptionsTypeNone));
+  if (CFGetTypeID(hid_manager_ref_) != IOHIDManagerGetTypeID()) {
+    enabled_ = false;
+    return;
+  }
+
+  scoped_nsobject<NSArray> criteria([[NSArray alloc] initWithObjects:
+      DeviceMatching(kGenericDesktopUsagePage, kJoystickUsageNumber),
+      DeviceMatching(kGenericDesktopUsagePage, kGameUsageNumber),
+      DeviceMatching(kGenericDesktopUsagePage, kMultiAxisUsageNumber),
+      nil]);
+  IOHIDManagerSetDeviceMatchingMultiple(
+      hid_manager_ref_,
+      base::mac::NSToCFCast(criteria));
+
+  RegisterForNotifications();
+}
+
+void GamepadDataFetcherMac::RegisterForNotifications() {
+  // Register for plug/unplug notifications

[Avi (use Gerrit), 2011/12/07 04:12:46]

full sentences end with periods .

[scottmg, 2011/12/07 04:39:36]

Done.

+  IOHIDManagerRegisterDeviceMatchingCallback(
+      hid_manager_ref_,
+      &DeviceAddCallback,
+      this);
+  IOHIDManagerRegisterDeviceRemovalCallback(
+      hid_manager_ref_,
+      DeviceRemoveCallback,
+      this);
+
+  // Register for value change notifications
+  IOHIDManagerRegisterInputValueCallback(
+      hid_manager_ref_,
+      ValueChangedCallback,
+      this);
+
+  IOHIDManagerScheduleWithRunLoop(
+      hid_manager_ref_,
+      CFRunLoopGetMain(),
+      kCFRunLoopDefaultMode);
+
+  enabled_ = IOHIDManagerOpen(hid_manager_ref_,
+                              kIOHIDOptionsTypeSeizeDevice) == kIOReturnSuccess;
+}
+
+void GamepadDataFetcherMac::UnregisterFromNotifications() {
+  IOHIDManagerUnscheduleFromRunLoop(
+      hid_manager_ref_,
+      CFRunLoopGetCurrent(),
+      kCFRunLoopDefaultMode);
+  IOHIDManagerClose(hid_manager_ref_, kIOHIDOptionsTypeNone);
+}
+
+void GamepadDataFetcherMac::PauseHint(bool pause) {
+  if (pause)
+    UnregisterFromNotifications();
+  else
+    RegisterForNotifications();
+}
+
+GamepadDataFetcherMac::~GamepadDataFetcherMac() {
+  UnregisterFromNotifications();
+}
+
+GamepadDataFetcherMac* GamepadDataFetcherMac::InstanceFromContext(
+    void* context) {
+  return reinterpret_cast<GamepadDataFetcherMac*>(context);
+}
+
+void GamepadDataFetcherMac::DeviceAddCallback(void* context,
+                                              IOReturn result,
+                                              void* sender,
+                                              IOHIDDeviceRef ref) {
+  InstanceFromContext(context)->DeviceAdd(ref);
+}
+
+void GamepadDataFetcherMac::DeviceRemoveCallback(void* context,
+                                                 IOReturn result,
+                                                 void* sender,
+                                                 IOHIDDeviceRef ref) {
+  InstanceFromContext(context)->DeviceRemove(ref);
+}
+
+void GamepadDataFetcherMac::ValueChangedCallback(void* context,
+                                                 IOReturn result,
+                                                 void* sender,
+                                                 IOHIDValueRef ref) {
+  InstanceFromContext(context)->ValueChanged(ref);
+}
+
+void GamepadDataFetcherMac::AddButtonsAndAxes(NSArray* elements,
+                                              unsigned slot) {
+  WebKit::WebGamepad& pad = data_.items[slot];
+  AssociatedData& associated = associated_[slot];
+
+  pad.axesLength = 0;
+  pad.buttonsLength = 0;
+  memset(pad.axes, 0, sizeof(pad.axes));
+  memset(pad.buttons, 0, sizeof(pad.buttons));
+
+  for (id elem in elements) {
+    IOHIDElementRef element = reinterpret_cast<IOHIDElementRef>(elem);
+    uint32_t usagePage = IOHIDElementGetUsagePage(element);
+    uint32_t usage = IOHIDElementGetUsage(element);
+    if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Button &&
+        usagePage == kButtonUsagePage) {
+      uint32_t button_index = usage - 1;
+      if (button_index < WebKit::WebGamepad::buttonsLengthCap) {
+        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 < WebKit::WebGamepad::axesLengthCap) {
+        associated.axis_minimums[axis_index] =
+            IOHIDElementGetLogicalMin(element);
+        associated.axis_maximums[axis_index] =
+            IOHIDElementGetLogicalMax(element);
+        associated.axis_elements[axis_index] = element;
+        pad.axesLength = std::max(pad.axesLength, axis_index + 1);
+      }
+    }
+  }
+}
+
+void GamepadDataFetcherMac::DeviceAdd(IOHIDDeviceRef device) {
+  using WebKit::WebGamepad;
+  using WebKit::WebGamepads;
+  using base::mac::CFToNSCast;

[Avi (use Gerrit), 2011/12/07 04:12:46]

I was not aware that the style guide permitted this until I looked it up. Nice!

[scottmg, 2011/12/07 04:39:36]

Darin schooled me on that last review. :)

+  unsigned slot;
+
+  if (!enabled_)
+    return;
+
+  // Find an index for this device.
+  for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
+    // If we already have this device, and it's already connected, don't do
+    // anything now.
+    if (associated_[slot].device_ref == device && data_.items[slot].connected)
+      return;
+    if (!data_.items[slot].connected)
+      break;
+  }
+
+  // We can't handle this many connected devices.
+  if (slot == WebGamepads::itemsLengthCap)
+    return;
+
+  NSNumber* vendor_id = CFToNSCast(base::mac::CFCastStrict<CFNumberRef>(

[Avi (use Gerrit), 2011/12/07 04:12:46]

We do "using base::mac::CFToNSCast" to cut clutter but don't do "using
base::mac::CFCastStrict"?

[scottmg, 2011/12/07 04:39:36]

Done.

+      IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVendorIDKey))));
+  NSNumber* product_id = CFToNSCast(base::mac::CFCastStrict<CFNumberRef>(
+      IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductIDKey))));
+  NSString* product = CFToNSCast(base::mac::CFCastStrict<CFStringRef>(
+      IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey))));
+
+  NSString* ident([NSString stringWithFormat:
+      @"%s (Vendor: %04x Product: %04x)",
+      [product UTF8String],

[Avi (use Gerrit), 2011/12/07 04:12:46]

Nope. NSObjects have a formatting code of %@; use that and just pass the object
pointer.

[scottmg, 2011/12/07 04:39:36]

Done. (Magic!)

+      [vendor_id intValue],
+      [product_id intValue]]);
+  NSData* as16 = [ident dataUsingEncoding: NSUTF16StringEncoding];

[Avi (use Gerrit), 2011/12/07 04:12:46]

no space after :

[scottmg, 2011/12/07 04:39:36]

Done.

+
+  const unsigned kOutputLengthBytes = sizeof(data_.items[slot].id);
+  memset(&data_.items[slot].id, 0, kOutputLengthBytes);
+  [as16
+      getBytes: data_.items[slot].id
+      length: kOutputLengthBytes - sizeof(WebKit::WebUChar)];

[Avi (use Gerrit), 2011/12/07 04:12:46]

Bad style. Besides no space after :, put getBytes on the first line, and align
on colons.

[scottmg, 2011/12/07 04:39:36]

Done.

+
+  NSArray* elements = CFToNSCast(IOHIDDeviceCopyMatchingElements(

[Avi (use Gerrit), 2011/12/07 04:12:46]

Nope. CF-style functions that have "Copy" in their name return an object that
needs to be released. Your choices are to capture the raw CFArray returned in a
scoped_cftyperef and do the CFToNSCast in the call to AddButtonsAndAxes, or use
base::mac::CFTypeRefToNSObjectAutorelease. The former is cleaner.

[scottmg, 2011/12/07 04:39:36]

Is scoped_nsobject<NSArray> ok, or are the retain/release different somehow? (I
sat and wondered what the heck the rules were for ownership/copying by couldn't
figure it out from the docs... still missing some high level knowledge here).

[Avi (use Gerrit), 2011/12/07 05:26:06]

Wellllll.... they used to be the same until they weren't.

Back in the good ole days, you could CFRetain/CFRelease ObjC objects and send
-release/-retain to CF objects.

Then garbage collection came along, and it worked with ObjC objects but CF
objects remained ref counted. If you look at the CFTypeRefToNSObjectAutorelease
function, you'll see it's written to handle both cases, specially bridging
between the two lands.

And then ARC came along, and again, ObjC objects got the magic while CF objects
didn't. And with ARC, there's a completely different set of bridging functions
to move objects between the worlds of automatic and manual ref counting.

The way out is to just keep things in containers for their type. If it's a CF
type, hold it in a scoped_cftyperef. If it's an NSObject, hold it in a
scoped_nsobject. Use the casting functions on use and you won't have to deal
with ownership issues that way.

+      device,
+      NULL,
+      kIOHIDOptionsTypeNone));
+  AddButtonsAndAxes(elements, slot);
+
+  associated_[slot].device_ref = device;
+  data_.items[slot].connected = true;
+  data_.length = std::max(slot + 1, data_.length);
+}
+
+void GamepadDataFetcherMac::DeviceRemove(IOHIDDeviceRef device) {
+  using WebKit::WebGamepads;
+  unsigned slot;
+  if (!enabled_)
+    return;
+
+  // Find the index for this device.
+  for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
+    if (associated_[slot].device_ref == device && data_.items[slot].connected)
+      break;
+  }
+  DCHECK(slot < WebGamepads::itemsLengthCap);
+  // Leave associated device_ref so that it will be reconnected in the same
+  // location. Simply mark it as disconnected.
+  data_.items[slot].connected = false;
+}
+
+void GamepadDataFetcherMac::ValueChanged(IOHIDValueRef value) {
+  if (!enabled_)
+    return;
+
+  IOHIDElementRef element = IOHIDValueGetElement(value);
+  IOHIDDeviceRef device = IOHIDElementGetDevice(element);
+
+  // Find device slot
+  unsigned slot;
+  for (slot = 0; slot < data_.length; ++slot) {
+    if (data_.items[slot].connected && associated_[slot].device_ref == device)
+      break;
+  }
+  if (slot == data_.length)
+    return;
+
+  WebKit::WebGamepad& pad = data_.items[slot];
+  AssociatedData& associated = associated_[slot];
+
+  // Find and fill in the associated button event, if any.
+  for (unsigned i = 0; i < pad.buttonsLength; ++i) {
+    if (associated.button_elements[i] == element) {
+      pad.buttons[i] = IOHIDValueGetIntegerValue(value) ? 1.f : 0.f;
+      return;
+    }
+  }
+
+  // Find and fill in the associated axis event, if any.
+  for (unsigned i = 0; i < pad.axesLength; ++i) {
+    if (associated.axis_elements[i] == element) {
+      pad.axes[i] = NormalizeAxis(IOHIDValueGetIntegerValue(value),
+                                  associated.axis_minimums[i],
+                                  associated.axis_maximums[i]);
+      return;
+    }
+  }
+}
+
+void GamepadDataFetcherMac::GetGamepadData(WebKit::WebGamepads* pads, bool) {
+  if (!enabled_) {
+    pads->length = 0;
+    return;
+  }
+  memcpy(pads, &data_, sizeof(WebKit::WebGamepads));
+}
+
+} // namespace content