Migrating majority of gamepad from content/browser/ to device/

device/gamepad/xbox_data_fetcher_mac.cc

 // 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 "device/gamepad/xbox_data_fetcher_mac.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/IOKitLib.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USB.h>
@@ skipping 26 matching lines @@
   XBOX_ONE_STATUS_MESSAGE_BUTTONS = 0x20,
 };
 
 enum {
   CONTROL_MESSAGE_SET_RUMBLE = 0,
   CONTROL_MESSAGE_SET_LED = 1,
 };
 
 #pragma pack(push, 1)
 struct Xbox360ButtonData {
-  bool dpad_up    : 1;
-  bool dpad_down  : 1;
-  bool dpad_left  : 1;
+  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 start : 1;
+  bool back : 1;
+  bool stick_left_click : 1;
   bool stick_right_click : 1;
 
-  bool bumper_left  : 1;
+  bool bumper_left : 1;
   bool bumper_right : 1;
-  bool guide        : 1;
-  bool dummy1       : 1;  // Always 0.
+  bool guide : 1;
+  bool dummy1 : 1;  // Always 0.
 
   bool a : 1;
   bool b : 1;
   bool x : 1;
   bool y : 1;
 
   uint8_t trigger_left;
   uint8_t trigger_right;
 
   int16_t stick_left_x;
   int16_t stick_left_y;
   int16_t stick_right_x;
   int16_t stick_right_y;
 
   // Always 0.
   uint32_t dummy2;
   uint16_t dummy3;
 };
 
 struct XboxOneButtonData {
-  bool sync   : 1;
+  bool sync : 1;
   bool dummy1 : 1;  // Always 0.
-  bool start  : 1;
-  bool back   : 1;
+  bool start : 1;
+  bool back : 1;
 
   bool a : 1;
   bool b : 1;
   bool x : 1;
   bool y : 1;
 
-  bool dpad_up    : 1;
-  bool dpad_down  : 1;
-  bool dpad_left  : 1;
+  bool dpad_up : 1;
+  bool dpad_down : 1;
+  bool dpad_left : 1;
   bool dpad_right : 1;
 
-  bool bumper_left       : 1;
-  bool bumper_right      : 1;
-  bool stick_left_click  : 1;
+  bool bumper_left : 1;
+  bool bumper_right : 1;
+  bool stick_left_click : 1;
   bool stick_right_click : 1;
 
   uint16_t trigger_left;
   uint16_t trigger_right;
 
   int16_t stick_left_x;
   int16_t stick_left_y;
   int16_t stick_right_x;
   int16_t stick_right_y;
 };
@@ skipping 45 matching lines @@
 
 float NormalizeTrigger(uint8_t value) {
   return value < kXbox360TriggerDeadzone
              ? 0
              : static_cast<float>(value - kXbox360TriggerDeadzone) /
                    (std::numeric_limits<uint8_t>::max() -
                     kXbox360TriggerDeadzone);
 }
 
 float NormalizeXboxOneTrigger(uint16_t value) {
-  return value < kXboxOneTriggerDeadzone ? 0 :
-      static_cast<float>(value - kXboxOneTriggerDeadzone) /
-          (kXboxOneTriggerMax - kXboxOneTriggerDeadzone);
+  return value < kXboxOneTriggerDeadzone
+             ? 0
+             : static_cast<float>(value - kXboxOneTriggerDeadzone) /
+                   (kXboxOneTriggerMax - kXboxOneTriggerDeadzone);
 }
 
 void NormalizeXbox360ButtonData(const Xbox360ButtonData& data,
-    XboxController::Data* normalized_data) {
+                                XboxController::Data* normalized_data) {
   normalized_data->buttons[0] = data.a;
   normalized_data->buttons[1] = data.b;
   normalized_data->buttons[2] = data.x;
   normalized_data->buttons[3] = data.y;
   normalized_data->buttons[4] = data.bumper_left;
   normalized_data->buttons[5] = data.bumper_right;
   normalized_data->buttons[6] = data.back;
   normalized_data->buttons[7] = data.start;
   normalized_data->buttons[8] = data.stick_left_click;
   normalized_data->buttons[9] = data.stick_right_click;
   normalized_data->buttons[10] = data.dpad_up;
   normalized_data->buttons[11] = data.dpad_down;
   normalized_data->buttons[12] = data.dpad_left;
   normalized_data->buttons[13] = data.dpad_right;
   normalized_data->buttons[14] = data.guide;
   normalized_data->triggers[0] = NormalizeTrigger(data.trigger_left);
   normalized_data->triggers[1] = NormalizeTrigger(data.trigger_right);
-  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]);
+  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]);
 }
 
 void NormalizeXboxOneButtonData(const XboxOneButtonData& data,
-    XboxController::Data* normalized_data) {
+                                XboxController::Data* normalized_data) {
   normalized_data->buttons[0] = data.a;
   normalized_data->buttons[1] = data.b;
   normalized_data->buttons[2] = data.x;
   normalized_data->buttons[3] = data.y;
   normalized_data->buttons[4] = data.bumper_left;
   normalized_data->buttons[5] = data.bumper_right;
   normalized_data->buttons[6] = data.back;
   normalized_data->buttons[7] = data.start;
   normalized_data->buttons[8] = data.stick_left_click;
   normalized_data->buttons[9] = data.stick_right_click;
   normalized_data->buttons[10] = data.dpad_up;
   normalized_data->buttons[11] = data.dpad_down;
   normalized_data->buttons[12] = data.dpad_left;
   normalized_data->buttons[13] = data.dpad_right;
   normalized_data->buttons[14] = data.sync;
   normalized_data->triggers[0] = NormalizeXboxOneTrigger(data.trigger_left);
   normalized_data->triggers[1] = NormalizeXboxOneTrigger(data.trigger_right);
-  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]);
+  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),
       read_buffer_size_(0),
       led_pattern_(LED_NUM_PATTERNS),
       location_id_(0),
       delegate_(delegate),
       controller_type_(UNKNOWN_CONTROLLER),
       read_endpoint_(0),
-      control_endpoint_(0) {
-}
+      control_endpoint_(0) {}
 
 XboxController::~XboxController() {
   if (source_)
     CFRunLoopSourceInvalidate(source_);
   if (interface_ && interface_is_open_)
     (*interface_)->USBInterfaceClose(interface_);
   if (device_ && device_is_open_)
     (*device_)->USBDeviceClose(device_);
 }
 
 bool XboxController::OpenDevice(io_service_t service) {
-  IOCFPlugInInterface **plugin;
+  IOCFPlugInInterface** plugin;
   SInt32 score;  // Unused, but required for IOCreatePlugInInterfaceForService.
-  kern_return_t kr =
-      IOCreatePlugInInterfaceForService(service,
-                                        kIOUSBDeviceUserClientTypeID,
-                                        kIOCFPlugInInterfaceID,
-                                        &plugin,
-                                        &score);
+  kern_return_t kr = IOCreatePlugInInterfaceForService(
+      service, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &plugin,
+      &score);
   if (kr != KERN_SUCCESS)
     return false;
   base::mac::ScopedIOPluginInterface<IOCFPlugInInterface> plugin_ref(plugin);
 
-  HRESULT res =
-      (*plugin)->QueryInterface(plugin,
-                                CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID320),
-                                (LPVOID *)&device_);
+  HRESULT res = (*plugin)->QueryInterface(
+      plugin, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID320),
+      (LPVOID*)&device_);
   if (!SUCCEEDED(res) || !device_)
     return false;
 
   UInt16 vendor_id;
   kr = (*device_)->GetDeviceVendor(device_, &vendor_id);
   if (kr != KERN_SUCCESS || vendor_id != kVendorMicrosoft)
     return false;
 
   UInt16 product_id;
   kr = (*device_)->GetDeviceProduct(device_, &product_id);
@@ skipping 63 matching lines @@
   // 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);
+  IOCFPlugInInterface** plugin_interface;
+  kr = IOCreatePlugInInterfaceForService(
+      usb_interface, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID,
+      &plugin_interface, &score);
   if (kr != KERN_SUCCESS || !plugin_interface)
     return false;
   base::mac::ScopedIOPluginInterface<IOCFPlugInInterface> interface_ref(
       plugin_interface);
 
   // 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.
-  res = (*plugin_interface)->QueryInterface(
-      plugin_interface,
-      CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID300),
-      (LPVOID *)&interface_);
+  res = (*plugin_interface)
+            ->QueryInterface(plugin_interface,
+                             CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID300),
+                             (LPVOID*)&interface_);
 
   if (!SUCCEEDED(res) || !interface_)
     return false;
 
   // Actually open the interface.
   kr = (*interface_)->USBInterfaceOpen(interface_);
   if (kr != KERN_SUCCESS)
     return false;
   interface_is_open_ = true;
 
@@ skipping 11 matching lines @@
   if (kr != KERN_SUCCESS || num_endpoints < 2)
     return false;
 
   for (int i = 1; i <= 2; i++) {
     uint8_t direction;
     uint8_t number;
     uint8_t transfer_type;
     uint16_t max_packet_size;
     uint8_t interval;
 
-    kr = (*interface_)->GetPipeProperties(interface_,
-                                          i,
-                                          &direction,
-                                          &number,
-                                          &transfer_type,
-                                          &max_packet_size,
-                                          &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 == read_endpoint_) {
       if (direction != kUSBIn)
         return false;
       read_buffer_.reset(new uint8_t[max_packet_size]);
       read_buffer_size_ = max_packet_size;
       QueueRead();
     } else if (i == control_endpoint_) {
@@ skipping 17 matching lines @@
 void XboxController::SetLEDPattern(LEDPattern pattern) {
   led_pattern_ = pattern;
   const UInt8 length = 3;
 
   // This buffer will be released in WriteComplete when WritePipeAsync
   // finishes.
   UInt8* buffer = new UInt8[length];
   buffer[0] = static_cast<UInt8>(CONTROL_MESSAGE_SET_LED);
   buffer[1] = length;
   buffer[2] = static_cast<UInt8>(pattern);
-  kern_return_t kr = (*interface_)->WritePipeAsync(interface_,
-                                                   control_endpoint_,
-                                                   buffer,
-                                                   (UInt32)length,
-                                                   WriteComplete,
-                                                   buffer);
+  kern_return_t kr =
+      (*interface_)
+          ->WritePipeAsync(interface_, control_endpoint_, buffer,
+                           (UInt32)length, WriteComplete, buffer);
   if (kr != KERN_SUCCESS) {
     delete[] buffer;
     IOError();
     return;
   }
 }
 
 int XboxController::GetVendorId() const {
   return kVendorMicrosoft;
 }
@@ skipping 104 matching lines @@
       delegate_->XboxControllerGotData(this, normalized_data);
       break;
     }
     default:
       // Unknown packet: ignore!
       break;
   }
 }
 
 void XboxController::QueueRead() {
-  kern_return_t kr = (*interface_)->ReadPipeAsync(interface_,
-                                                  read_endpoint_,
-                                                  read_buffer_.get(),
-                                                  read_buffer_size_,
-                                                  GotData,
-                                                  this);
+  kern_return_t kr =
+      (*interface_)
+          ->ReadPipeAsync(interface_, read_endpoint_, read_buffer_.get(),
+                          read_buffer_size_, GotData, this);
   if (kr != KERN_SUCCESS)
     IOError();
 }
 
 void XboxController::IOError() {
   delegate_->XboxControllerError(this);
 }
 
 void XboxController::WriteXboxOneInit() {
   const UInt8 length = 2;
 
   // This buffer will be released in WriteComplete when WritePipeAsync
   // finishes.
   UInt8* buffer = new UInt8[length];
   buffer[0] = 0x05;
   buffer[1] = 0x20;
-  kern_return_t kr = (*interface_)->WritePipeAsync(interface_,
-                                                   control_endpoint_,
-                                                   buffer,
-                                                   (UInt32)length,
-                                                   WriteComplete,
-                                                   buffer);
+  kern_return_t kr =
+      (*interface_)
+          ->WritePipeAsync(interface_, control_endpoint_, buffer,
+                           (UInt32)length, WriteComplete, buffer);
   if (kr != KERN_SUCCESS) {
     delete[] buffer;
     IOError();
     return;
   }
 }
 
 //-----------------------------------------------------------------------------
 
 XboxDataFetcher::XboxDataFetcher(Delegate* delegate)
-    : delegate_(delegate),
-      listening_(false),
-      source_(NULL),
-      port_(NULL) {
-}
+    : delegate_(delegate), listening_(false), source_(NULL), port_(NULL) {}
 
 XboxDataFetcher::~XboxDataFetcher() {
   while (!controllers_.empty()) {
     RemoveController(*controllers_.begin());
   }
   UnregisterFromNotifications();
 }
 
 void XboxDataFetcher::DeviceAdded(void* context, io_iterator_t iterator) {
   DCHECK(context);
@@ skipping 10 matching lines @@
   }
 }
 
 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::ScopedIOObject<io_service_t> scoped_ref(ref);
     base::ScopedCFTypeRef<CFNumberRef> number(
-        base::mac::CFCastStrict<CFNumberRef>(
-            IORegistryEntryCreateCFProperty(ref,
-                                            CFSTR(kUSBDevicePropertyLocationID),
-                                            kCFAllocatorDefault,
-                                            kNilOptions)));
+        base::mac::CFCastStrict<CFNumberRef>(IORegistryEntryCreateCFProperty(
+            ref, CFSTR(kUSBDevicePropertyLocationID), kCFAllocatorDefault,
+            kNilOptions)));
     UInt32 location_id = 0;
     CFNumberGetValue(number, kCFNumberSInt32Type, &location_id);
     fetcher->RemoveControllerByLocationID(location_id);
   }
 }
 
 bool XboxDataFetcher::RegisterForNotifications() {
   if (listening_)
     return true;
   port_ = IONotificationPortCreate(kIOMasterPortDefault);
   if (!port_)
     return false;
   source_ = IONotificationPortGetRunLoopSource(port_);
   if (!source_)
     return false;
   CFRunLoopAddSource(CFRunLoopGetCurrent(), source_, kCFRunLoopDefaultMode);
 
   listening_ = true;
 
   if (!RegisterForDeviceNotifications(
-      kVendorMicrosoft, kProductXboxOneController,
-      &xbox_one_device_added_iter_,
-      &xbox_one_device_removed_iter_))
+          kVendorMicrosoft, kProductXboxOneController,
+          &xbox_one_device_added_iter_, &xbox_one_device_removed_iter_))
     return false;
 
   if (!RegisterForDeviceNotifications(
-      kVendorMicrosoft, kProductXbox360Controller,
-      &xbox_360_device_added_iter_,
-      &xbox_360_device_removed_iter_))
+          kVendorMicrosoft, kProductXbox360Controller,
+          &xbox_360_device_added_iter_, &xbox_360_device_removed_iter_))
     return false;
 
   return true;
 }
 
 bool XboxDataFetcher::RegisterForDeviceNotifications(
     int vendor_id,
     int product_id,
     base::mac::ScopedIOObject<io_iterator_t>* added_iter,
     base::mac::ScopedIOObject<io_iterator_t>* removed_iter) {
-  base::ScopedCFTypeRef<CFNumberRef> vendor_cf(CFNumberCreate(
-      kCFAllocatorDefault, kCFNumberSInt32Type, &vendor_id));
-  base::ScopedCFTypeRef<CFNumberRef> product_cf(CFNumberCreate(
-      kCFAllocatorDefault, kCFNumberSInt32Type, &product_id));
+  base::ScopedCFTypeRef<CFNumberRef> vendor_cf(
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &vendor_id));
+  base::ScopedCFTypeRef<CFNumberRef> product_cf(
+      CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &product_id));
   base::ScopedCFTypeRef<CFMutableDictionaryRef> matching_dict(
       IOServiceMatching(kIOUSBDeviceClassName));
   if (!matching_dict)
     return false;
   CFDictionarySetValue(matching_dict, CFSTR(kUSBVendorID), vendor_cf);
   CFDictionarySetValue(matching_dict, CFSTR(kUSBProductID), product_cf);
 
   // IOServiceAddMatchingNotification() releases the dictionary when it's done.
   // Retain it before each call to IOServiceAddMatchingNotification to keep
   // things balanced.
   CFRetain(matching_dict);
   io_iterator_t device_added_iter;
   IOReturn ret;
-  ret = IOServiceAddMatchingNotification(port_,
-                                         kIOFirstMatchNotification,
-                                         matching_dict,
-                                         DeviceAdded,
-                                         this,
+  ret = IOServiceAddMatchingNotification(port_, kIOFirstMatchNotification,
+                                         matching_dict, DeviceAdded, this,
                                          &device_added_iter);
   added_iter->reset(device_added_iter);
   if (ret != kIOReturnSuccess) {
     LOG(ERROR) << "Error listening for Xbox controller add events: " << ret;
     return false;
   }
   DeviceAdded(this, added_iter->get());
 
   CFRetain(matching_dict);
   io_iterator_t device_removed_iter;
-  ret = IOServiceAddMatchingNotification(port_,
-                                         kIOTerminatedNotification,
-                                         matching_dict,
-                                         DeviceRemoved,
-                                         this,
+  ret = IOServiceAddMatchingNotification(port_, kIOTerminatedNotification,
+                                         matching_dict, DeviceRemoved, this,
                                          &device_removed_iter);
   removed_iter->reset(device_removed_iter);
   if (ret != kIOReturnSuccess) {
     LOG(ERROR) << "Error listening for Xbox controller remove events: " << ret;
     return false;
   }
   DeviceRemoved(this, removed_iter->get());
   return true;
 }
 
 void XboxDataFetcher::UnregisterFromNotifications() {
   if (!listening_)
     return;
   listening_ = false;
   if (source_)
     CFRunLoopSourceInvalidate(source_);
   if (port_)
     IONotificationPortDestroy(port_);
   port_ = NULL;
 }
 
 XboxController* XboxDataFetcher::ControllerForLocation(UInt32 location_id) {
   for (std::set<XboxController*>::iterator i = controllers_.begin();
-       i != controllers_.end();
-       ++i) {
+       i != controllers_.end(); ++i) {
     if ((*i)->location_id() == location_id)
       return *i;
   }
   return NULL;
 }
 
 void XboxDataFetcher::AddController(XboxController* controller) {
   DCHECK(!ControllerForLocation(controller->location_id()))
       << "Controller with location ID " << controller->location_id()
       << " already exists in the set of controllers.";
   controllers_.insert(controller);
   delegate_->XboxDeviceAdd(controller);
 }
 
 void XboxDataFetcher::RemoveController(XboxController* controller) {
   delegate_->XboxDeviceRemove(controller);
   controllers_.erase(controller);
   delete controller;
 }
 
 void XboxDataFetcher::RemoveControllerByLocationID(uint32_t location_id) {
   XboxController* controller = NULL;
   for (std::set<XboxController*>::iterator i = controllers_.begin();
-       i != controllers_.end();
-       ++i) {
+       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);
 }