Added support for the Xbox One gamepad on OSX

content/browser/gamepad/xbox_data_fetcher_mac.h

 // 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.
 
 #ifndef CONTENT_BROWSER_GAMEPAD_XBOX_DATA_FETCHER_MAC_H_
 #define CONTENT_BROWSER_GAMEPAD_XBOX_DATA_FETCHER_MAC_H_
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/IOKitLib.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_ioobject.h"
 #include "base/mac/scoped_ioplugininterface.h"
 #include "base/memory/scoped_ptr.h"
 
 class XboxController {
  public:
+  enum ControllerType {
+    UNKNOWN_CONTROLLER,
+    XBOX_360_CONTROLLER,
+    XBOX_ONE_CONTROLLER
+  };
+
   enum LEDPattern {
     LED_OFF = 0,
 
     // 2 quick flashes, then a series of slow flashes (about 1 per second).
     LED_FLASH = 1,
 
     // Flash three times then hold the LED on. This is the standard way to tell
     // the player which player number they are.
     LED_FLASH_TOP_LEFT = 2,
     LED_FLASH_TOP_RIGHT = 3,
@@ skipping 39 matching lines @@
   explicit XboxController(Delegate* delegate_);
   virtual ~XboxController();
 
   bool OpenDevice(io_service_t service);
 
   void SetLEDPattern(LEDPattern pattern);
 
   UInt32 location_id() { return location_id_; }
   int GetVendorId() const;
   int GetProductId() const;
+  ControllerType GetControllerType() const;
 
  private:
   static void WriteComplete(void* context, IOReturn result, void* arg0);
   static void GotData(void* context, IOReturn result, void* arg0);
 
-  void ProcessPacket(size_t length);
+  void ProcessXbox360Packet(size_t length);
+  void ProcessXboxOnePacket(size_t length);
   void QueueRead();
 
   void IOError();
 
+  void WriteXboxOneInit();
+
   // Handle for the USB device. IOUSBDeviceStruct320 is the latest version of
   // the device API that is supported on Mac OS 10.6.
   base::mac::ScopedIOPluginInterface<struct IOUSBDeviceStruct320> device_;
 
   // Handle for the interface on the device which sends button and analog data.
   // The other interfaces (for the ChatPad and headset) are ignored.
   base::mac::ScopedIOPluginInterface<struct IOUSBInterfaceStruct300> interface_;
 
   bool device_is_open_;
   bool interface_is_open_;
@@ skipping 10 matching lines @@
   scoped_ptr<uint8[]> read_buffer_;
 
   // The pattern that the LEDs on the device are currently displaying, or
   // LED_NUM_PATTERNS if unknown.
   LEDPattern led_pattern_;
 
   UInt32 location_id_;
 
   Delegate* delegate_;
 
+  ControllerType controller_type_;
+  int read_endpoint_;
+  int control_endpoint_;
+
   DISALLOW_COPY_AND_ASSIGN(XboxController);
 };
 
 class XboxDataFetcher : public XboxController::Delegate {
  public:
   class Delegate {
    public:
     virtual void XboxDeviceAdd(XboxController* device) = 0;
     virtual void XboxDeviceRemove(XboxController* device) = 0;
     virtual void XboxValueChanged(XboxController* device,
                                   const XboxController::Data& data) = 0;
   };
 
   explicit XboxDataFetcher(Delegate* delegate);
   virtual ~XboxDataFetcher();
 
   bool RegisterForNotifications();
+  bool RegisterForDeviceNotifications(
+    int vendor_id,
+    int product_id,
+    base::mac::ScopedIOObject<io_iterator_t>* added_iter,
+    base::mac::ScopedIOObject<io_iterator_t>* removed_iter);
   void UnregisterFromNotifications();
 
   XboxController* ControllerForLocation(UInt32 location_id);
 
  private:
   static void DeviceAdded(void* context, io_iterator_t iterator);
   static void DeviceRemoved(void* context, io_iterator_t iterator);
   void AddController(XboxController* controller);
   void RemoveController(XboxController* controller);
   void RemoveControllerByLocationID(uint32 id);
   virtual void XboxControllerGotData(XboxController* controller,
                                      const XboxController::Data& data) OVERRIDE;
   virtual void XboxControllerError(XboxController* controller) OVERRIDE;
 
   Delegate* delegate_;
 
   std::set<XboxController*> controllers_;
 
   bool listening_;
 
   // port_ owns source_, so this doesn't need to be a ScopedCFTypeRef, but we
   // do need to maintain a reference to it so we can invalidate it.
   CFRunLoopSourceRef source_;
   IONotificationPortRef port_;
-  base::mac::ScopedIOObject<io_iterator_t> device_added_iter_;
-  base::mac::ScopedIOObject<io_iterator_t> device_removed_iter_;
+  base::mac::ScopedIOObject<io_iterator_t> xbox_360_device_added_iter_;
+  base::mac::ScopedIOObject<io_iterator_t> xbox_360_device_removed_iter_;
+  base::mac::ScopedIOObject<io_iterator_t> xbox_one_device_added_iter_;
+  base::mac::ScopedIOObject<io_iterator_t> xbox_one_device_removed_iter_;
 
   DISALLOW_COPY_AND_ASSIGN(XboxDataFetcher);
 };
 
 #endif  // CONTENT_BROWSER_GAMEPAD_XBOX_DATA_FETCHER_MAC_H_