Refactored gamepad polling to support dynamic sources

device/gamepad/xbox_data_fetcher_mac.mm

 // 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 "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>
 
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 
+using blink::WebGamepad;
+
+namespace device {
+
 namespace {
+
 const int kVendorMicrosoft = 0x045e;
 const int kProductXbox360Controller = 0x028e;
 const int kProductXboxOneController = 0x02d1;
 
 const int kXbox360ReadEndpoint = 1;
 const int kXbox360ControlEndpoint = 2;
 
 const int kXboxOneReadEndpoint = 2;
 const int kXboxOneControlEndpoint = 1;
 
@@ skipping 184 matching lines @@
   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]);
 }
 
+void CopyNSStringAsUTF16LittleEndian(NSString* src,
+                                     blink::WebUChar* dest,
+                                     size_t dest_len) {
+  NSData* as16 = [src dataUsingEncoding:NSUTF16LittleEndianStringEncoding];
+  memset(dest, 0, dest_len);
+  [as16 getBytes:dest length:dest_len - sizeof(blink::WebUChar)];
+}
+
 }  // 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),
@@ skipping 353 matching lines @@
                            (UInt32)length, WriteComplete, buffer);
   if (kr != KERN_SUCCESS) {
     delete[] buffer;
     IOError();
     return;
   }
 }
 
 //-----------------------------------------------------------------------------
 
-XboxDataFetcher::XboxDataFetcher(Delegate* delegate)
-    : delegate_(delegate), listening_(false), source_(NULL), port_(NULL) {}
+XboxDataFetcher::XboxDataFetcher()
+    : listening_(false), source_(NULL), port_(NULL) {}
 
 XboxDataFetcher::~XboxDataFetcher() {
   while (!controllers_.empty()) {
     RemoveController(*controllers_.begin());
   }
   UnregisterFromNotifications();
 }
 
+GamepadSource XboxDataFetcher::source() {
+  return Factory::static_source();
+}
+
+void XboxDataFetcher::GetGamepadData(bool devices_changed_hint) {
+  // This just loops through all the connected pads and "pings" them to indicate
+  // that they're still active.
+  for (const auto& controller : controllers_) {
+    GetPadState(controller->location_id());
+  }
+}
+
+void XboxDataFetcher::OnAddedToProvider() {
+  RegisterForNotifications();
+}
+
 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))) {
     base::mac::ScopedIOObject<io_service_t> scoped_ref(ref);
     XboxController* controller = new XboxController(fetcher);
     if (controller->OpenDevice(ref)) {
       fetcher->AddController(controller);
     } else {
@@ skipping 107 matching lines @@
     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.";
+  PadState* state = GetPadState(controller->location_id());
+  if (!state) {
+    delete controller;
+    return;  // No available slot for this device
+  }
+
   controllers_.insert(controller);
-  delegate_->XboxDeviceAdd(controller);
+
+  controller->SetLEDPattern((XboxController::LEDPattern)(
+      XboxController::LED_FLASH_TOP_LEFT + controller->location_id()));
+
+  NSString* ident = [NSString
+      stringWithFormat:@"%@ (STANDARD GAMEPAD Vendor: %04x Product: %04x)",
+                       controller->GetControllerType() ==
+                               XboxController::XBOX_360_CONTROLLER
+                           ? @"Xbox 360 Controller"
+                           : @"Xbox One Controller",
+                       controller->GetProductId(), controller->GetVendorId()];
+  CopyNSStringAsUTF16LittleEndian(ident, state->data.id,
+                                  sizeof(state->data.id));
+
+  CopyNSStringAsUTF16LittleEndian(@"standard", state->data.mapping,
+                                  sizeof(state->data.mapping));
+
+  state->data.connected = true;
+  state->data.axesLength = 4;
+  state->data.buttonsLength = 17;
+  state->data.timestamp = 0;
+  state->mapper = 0;
+  state->axis_mask = 0;
+  state->button_mask = 0;
 }
 
 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) {
     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);
+  PadState* state = GetPadState(controller->location_id());
+  if (!state)
+    return;  // No available slot for this device
+
+  WebGamepad& pad = state->data;
+
+  for (size_t i = 0; i < 6; i++) {
+    pad.buttons[i].pressed = data.buttons[i];
+    pad.buttons[i].value = data.buttons[i] ? 1.0f : 0.0f;
+  }
+  pad.buttons[6].pressed = data.triggers[0] > kDefaultButtonPressedThreshold;
+  pad.buttons[6].value = data.triggers[0];
+  pad.buttons[7].pressed = data.triggers[1] > kDefaultButtonPressedThreshold;
+  pad.buttons[7].value = data.triggers[1];
+  for (size_t i = 8; i < 17; i++) {
+    pad.buttons[i].pressed = data.buttons[i - 2];
+    pad.buttons[i].value = data.buttons[i - 2] ? 1.0f : 0.0f;
+  }
+  for (size_t i = 0; i < arraysize(data.axes); i++) {
+    pad.axes[i] = data.axes[i];
+  }
+
+  pad.timestamp = base::TimeTicks::Now().ToInternalValue();
 }
 
 void XboxDataFetcher::XboxControllerError(XboxController* controller) {
   RemoveController(controller);
 }
+
+}  // namespace device