Refactoring gamepad polling to support dynamically added sources

content/browser/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 "content/browser/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 content {
+
 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 196 matching lines @@
                 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 370 matching lines @@
                                                    buffer);
   if (kr != KERN_SUCCESS) {
     delete[] buffer;
     IOError();
     return;
   }
 }
 
 //-----------------------------------------------------------------------------
 
-XboxDataFetcher::XboxDataFetcher(Delegate* delegate)
-    : delegate_(delegate),
-      listening_(false),
+XboxDataFetcher::XboxDataFetcher()
+    : listening_(false),
       source_(NULL),
       port_(NULL) {
 }
 
 XboxDataFetcher::~XboxDataFetcher() {
   while (!controllers_.empty()) {
     RemoveController(*controllers_.begin());
   }
   UnregisterFromNotifications();
 }
 
+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_) {
+    provider()->GetPadState(GAMEPAD_SOURCE_MAC_XBOX, 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 118 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 = provider()->GetPadState(GAMEPAD_SOURCE_MAC_XBOX,
+                                            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 = provider()->GetPadState(GAMEPAD_SOURCE_MAC_XBOX,
+                                            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 content