Updating Gamepad API to match latest spec

content/browser/gamepad/gamepad_platform_data_fetcher_mac.mm

 // 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/gamepad_platform_data_fetcher_mac.h"
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 
 #import <Foundation/Foundation.h>
 #include <IOKit/hid/IOHIDKeys.h>
 
 using blink::WebGamepad;
 using blink::WebGamepads;
 
 namespace content {
 
 namespace {
 
+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)];
+}
+
 NSDictionary* DeviceMatching(uint32_t usage_page, uint32_t usage) {
   return [NSDictionary dictionaryWithObjectsAndKeys:
       [NSNumber numberWithUnsignedInt:usage_page],
           base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsagePageKey)),
       [NSNumber numberWithUnsignedInt:usage],
           base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsageKey)),
       nil];
 }
 
 float NormalizeAxis(CFIndex value, CFIndex min, CFIndex max) {
@@ skipping 220 matching lines @@
   snprintf(product_as_str, sizeof(product_as_str), "%04x", product_int);
   associated_[slot].hid.mapper =
       GetGamepadStandardMappingFunction(vendor_as_str, product_as_str);
 
   NSString* ident = [NSString stringWithFormat:
       @"%@ (%sVendor: %04x Product: %04x)",
       product,
       associated_[slot].hid.mapper ? "STANDARD GAMEPAD " : "",
       vendor_int,
       product_int];
-  NSData* as16 = [ident dataUsingEncoding:NSUTF16LittleEndianStringEncoding];
+  CopyNSStringAsUTF16LittleEndian(
+      ident,
+      data_.items[slot].id,
+      sizeof(data_.items[slot].id));
 
-  const size_t kOutputLengthBytes = sizeof(data_.items[slot].id);
-  memset(&data_.items[slot].id, 0, kOutputLengthBytes);
-  [as16 getBytes:data_.items[slot].id
-          length:kOutputLengthBytes - sizeof(blink::WebUChar)];
+  if (associated_[slot].hid.mapper) {
+    CopyNSStringAsUTF16LittleEndian(
+      @"standard",
+      data_.items[slot].mapping,
+      sizeof(data_.items[slot].mapping));
+  } else {
+    data_.items[slot].mapping[0] = 0;
+  }
 
   base::ScopedCFTypeRef<CFArrayRef> elements(
       IOHIDDeviceCopyMatchingElements(device, NULL, kIOHIDOptionsTypeNone));
   AddButtonsAndAxes(CFToNSCast(elements), slot);
 
   associated_[slot].hid.device_ref = device;
   data_.items[slot].connected = true;
   if (slot >= data_.length)
     data_.length = slot + 1;
 }
@@ skipping 33 matching lines @@
   }
   if (slot == data_.length)
     return;
 
   WebGamepad& pad = data_.items[slot];
   AssociatedData& associated = associated_[slot];
 
   // Find and fill in the associated button event, if any.
   for (size_t i = 0; i < pad.buttonsLength; ++i) {
     if (associated.hid.button_elements[i] == element) {
-      pad.buttons[i] = IOHIDValueGetIntegerValue(value) ? 1.f : 0.f;
+      pad.buttons[i].pressed = IOHIDValueGetIntegerValue(value);
+      pad.buttons[i].value = pad.buttons[i].pressed ? 1.f : 0.f;
       pad.timestamp = std::max(pad.timestamp, IOHIDValueGetTimeStamp(value));
       return;
     }
   }
 
   // Find and fill in the associated axis event, if any.
   for (size_t i = 0; i < pad.axesLength; ++i) {
     if (associated.hid.axis_elements[i] == element) {
       pad.axes[i] = NormalizeAxis(IOHIDValueGetIntegerValue(value),
                                   associated.hid.axis_minimums[i],
@@ skipping 17 matching lines @@
   device->SetLEDPattern(
       (XboxController::LEDPattern)(XboxController::LED_FLASH_TOP_LEFT + slot));
 
   NSString* ident =
       [NSString stringWithFormat:
           @"%@ (STANDARD GAMEPAD Vendor: %04x Product: %04x)",
               device->GetControllerType() == XboxController::XBOX_360_CONTROLLER
                   ? @"Xbox 360 Controller"
                   : @"Xbox One Controller",
               device->GetProductId(), device->GetVendorId()];
-  NSData* as16 = [ident dataUsingEncoding:NSUTF16StringEncoding];
-  const size_t kOutputLengthBytes = sizeof(data_.items[slot].id);
-  memset(&data_.items[slot].id, 0, kOutputLengthBytes);
-  [as16 getBytes:data_.items[slot].id
-          length:kOutputLengthBytes - sizeof(blink::WebUChar)];
+  CopyNSStringAsUTF16LittleEndian(
+      ident,
+      data_.items[slot].id,
+      sizeof(data_.items[slot].id));
+
+  CopyNSStringAsUTF16LittleEndian(
+    @"standard",
+    data_.items[slot].mapping,
+    sizeof(data_.items[slot].mapping));
 
   associated_[slot].is_xbox = true;
   associated_[slot].xbox.device = device;
   associated_[slot].xbox.location_id = device->location_id();
   data_.items[slot].connected = true;
   data_.items[slot].axesLength = 4;
   data_.items[slot].buttonsLength = 17;
   data_.items[slot].timestamp = 0;
   if (slot >= data_.length)
     data_.length = slot + 1;
@@ skipping 26 matching lines @@
         associated_[slot].is_xbox &&
         associated_[slot].xbox.device == device)
       break;
   }
   if (slot == data_.length)
     return;
 
   WebGamepad& pad = data_.items[slot];
 
   for (size_t i = 0; i < 6; i++) {
-    pad.buttons[i] = data.buttons[i] ? 1.0f : 0.0f;
+    pad.buttons[i].pressed = data.buttons[i];
+    pad.buttons[i].value = data.buttons[i] ? 1.0f : 0.0f;
   }
-  pad.buttons[6] = data.triggers[0];
-  pad.buttons[7] = data.triggers[1];
+  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] = data.buttons[i - 2] ? 1.0f : 0.0f;
+    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 GamepadPlatformDataFetcherMac::GetGamepadData(WebGamepads* pads, bool) {
   if (!enabled_ && !xbox_fetcher_) {
     pads->length = 0;
     return;
   }
 
   // Copy to the current state to the output buffer, using the mapping
   // function, if there is one available.
   pads->length = WebGamepads::itemsLengthCap;
   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
     if (!associated_[i].is_xbox && associated_[i].hid.mapper)
       associated_[i].hid.mapper(data_.items[i], &pads->items[i]);
     else
       pads->items[i] = data_.items[i];
   }
 }
 
 }  // namespace content