Add gamepad data fetcher for Linux

content/browser/gamepad/platform_data_fetcher_mac.mm

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/data_fetcher_mac.h"
+#include "content/browser/gamepad/platform_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/Foundation.h>
 
@@ skipping 18 matching lines @@
 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) {
+GamepadPlatformDataFetcherMac::GamepadPlatformDataFetcherMac()
+    : 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() {
+void GamepadPlatformDataFetcherMac::RegisterForNotifications() {
   // Register for plug/unplug notifications.
   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() {
+void GamepadPlatformDataFetcherMac::UnregisterFromNotifications() {
   IOHIDManagerUnscheduleFromRunLoop(
       hid_manager_ref_,
       CFRunLoopGetCurrent(),
       kCFRunLoopDefaultMode);
   IOHIDManagerClose(hid_manager_ref_, kIOHIDOptionsTypeNone);
 }
 
-void GamepadDataFetcherMac::PauseHint(bool pause) {
+void GamepadPlatformDataFetcherMac::PauseHint(bool pause) {
   if (pause)
     UnregisterFromNotifications();
   else
     RegisterForNotifications();
 }
 
-GamepadDataFetcherMac::~GamepadDataFetcherMac() {
+GamepadPlatformDataFetcherMac::~GamepadPlatformDataFetcherMac() {
   UnregisterFromNotifications();
 }
 
-GamepadDataFetcherMac* GamepadDataFetcherMac::InstanceFromContext(
+GamepadPlatformDataFetcherMac*
+GamepadPlatformDataFetcherMac::InstanceFromContext(
     void* context) {
-  return reinterpret_cast<GamepadDataFetcherMac*>(context);
+  return reinterpret_cast<GamepadPlatformDataFetcherMac*>(context);
 }
 
-void GamepadDataFetcherMac::DeviceAddCallback(void* context,
+void GamepadPlatformDataFetcherMac::DeviceAddCallback(void* context,
                                               IOReturn result,
                                               void* sender,
                                               IOHIDDeviceRef ref) {
   InstanceFromContext(context)->DeviceAdd(ref);
 }
 
-void GamepadDataFetcherMac::DeviceRemoveCallback(void* context,
+void GamepadPlatformDataFetcherMac::DeviceRemoveCallback(void* context,
                                                  IOReturn result,
                                                  void* sender,
                                                  IOHIDDeviceRef ref) {
   InstanceFromContext(context)->DeviceRemove(ref);
 }
 
-void GamepadDataFetcherMac::ValueChangedCallback(void* context,
+void GamepadPlatformDataFetcherMac::ValueChangedCallback(void* context,
                                                  IOReturn result,
                                                  void* sender,
                                                  IOHIDValueRef ref) {
   InstanceFromContext(context)->ValueChanged(ref);
 }
 
-void GamepadDataFetcherMac::AddButtonsAndAxes(NSArray* elements,
+void GamepadPlatformDataFetcherMac::AddButtonsAndAxes(NSArray* elements,
                                               size_t 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) {
@@ skipping 15 matching lines @@
             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) {
+void GamepadPlatformDataFetcherMac::DeviceAdd(IOHIDDeviceRef device) {
   using WebKit::WebGamepad;
   using WebKit::WebGamepads;
   using base::mac::CFToNSCast;
   using base::mac::CFCastStrict;
   size_t slot;
 
   if (!enabled_)
     return;
 
   // Find an index for this device.
@@ skipping 32 matching lines @@
   base::mac::ScopedCFTypeRef<CFArrayRef> elements(
       IOHIDDeviceCopyMatchingElements(device, NULL, kIOHIDOptionsTypeNone));
   AddButtonsAndAxes(CFToNSCast(elements), slot);
 
   associated_[slot].device_ref = device;
   data_.items[slot].connected = true;
   if (slot >= data_.length)
     data_.length = slot + 1;
 }
 
-void GamepadDataFetcherMac::DeviceRemove(IOHIDDeviceRef device) {
+void GamepadPlatformDataFetcherMac::DeviceRemove(IOHIDDeviceRef device) {
   using WebKit::WebGamepads;
   size_t 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) {
+void GamepadPlatformDataFetcherMac::ValueChanged(IOHIDValueRef value) {
   if (!enabled_)
     return;
 
   IOHIDElementRef element = IOHIDValueGetElement(value);
   IOHIDDeviceRef device = IOHIDElementGetDevice(element);
 
   // Find device slot.
   size_t slot;
   for (slot = 0; slot < data_.length; ++slot) {
     if (data_.items[slot].connected && associated_[slot].device_ref == device)
@@ skipping 17 matching lines @@
   for (size_t 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) {
+void GamepadPlatformDataFetcherMac::GetGamepadData(
+    WebKit::WebGamepads* pads,
+    bool) {
   if (!enabled_) {
     pads->length = 0;
     return;
   }
   memcpy(pads, &data_, sizeof(WebKit::WebGamepads));
 }
 
 }  // namespace content