[Device Service] Move Gamepad Blink headers to be part of the Gamepad client library

device/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 "device/gamepad/gamepad_platform_data_fetcher_mac.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.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 device {
 
 namespace {
 
 void CopyNSStringAsUTF16LittleEndian(NSString* src,
-                                     blink::WebUChar* dest,
+                                     UChar* dest,

[dcheng, 2017/04/12 23:33:27]

Nit: do we need to include a header for this type? I'm not actually sure where
this type is coming from.

[juncai, 2017/04/13 23:55:52]

It is from:
//device/gamepad/public/cpp/gamepad.h
https://codereview.chromium.org/2808093006/diff/130001/device/gamepad/public/...
line 67
which is used at:
https://codereview.chromium.org/2808093006/diff/130001/third_party/WebKit/pub...
line 106
and is from:
https://cs.chromium.org/webrtc/src/third_party/WebKit/public/platform/WebComm...
I changed its name to be UChar and move it to the gamepad.h

Added //device/gamepad/public/cpp/gamepad.h to
gamepad_platform_data_fetcher_mac.h

                                      size_t dest_len) {
   NSData* as16 = [src dataUsingEncoding:NSUTF16LittleEndianStringEncoding];
   memset(dest, 0, dest_len);
-  [as16 getBytes:dest length:dest_len - sizeof(blink::WebUChar)];
+  [as16 getBytes:dest length:dest_len - sizeof(UChar)];
 }
 
 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)),
@@ skipping 128 matching lines @@
         return true;
       }
     }
   }
   return false;
 }
 
 bool GamepadPlatformDataFetcherMac::AddButtonsAndAxes(NSArray* elements,
                                                       PadState* state,
                                                       size_t slot) {
-  WebGamepad& pad = state->data;
+  Gamepad& pad = state->data;
   AssociatedData& associated = associated_[slot];
 
   pad.axes_length = 0;
   pad.buttons_length = 0;
   pad.timestamp = 0;
   memset(pad.axes, 0, sizeof(pad.axes));
   memset(pad.buttons, 0, sizeof(pad.buttons));
 
   bool mapped_all_axes = true;
 
   for (id elem in elements) {
     IOHIDElementRef element = reinterpret_cast<IOHIDElementRef>(elem);
     if (!CheckCollection(element))
       continue;
 
     uint32_t usage_page = IOHIDElementGetUsagePage(element);
     uint32_t usage = IOHIDElementGetUsage(element);
     if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Button &&
         usage_page == kButtonUsagePage) {
       uint32_t button_index = usage - 1;
-      if (button_index < WebGamepad::kButtonsLengthCap) {
+      if (button_index < Gamepad::kButtonsLengthCap) {
         associated.button_elements[button_index] = element;
         pad.buttons_length = std::max(pad.buttons_length, button_index + 1);
       }
     } else if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Misc) {
       uint32_t axis_index = usage - kAxisMinimumUsageNumber;
-      if (axis_index < WebGamepad::kAxesLengthCap) {
+      if (axis_index < Gamepad::kAxesLengthCap) {
         associated.axis_elements[axis_index] = element;
         pad.axes_length = std::max(pad.axes_length, axis_index + 1);
       } else {
         mapped_all_axes = false;
       }
     }
   }
 
   if (!mapped_all_axes) {
     // For axes who's usage puts them outside the standard axesLengthCap range.
     uint32_t next_index = 0;
     for (id elem in elements) {
       IOHIDElementRef element = reinterpret_cast<IOHIDElementRef>(elem);
       if (!CheckCollection(element))
         continue;
 
       uint32_t usage_page = IOHIDElementGetUsagePage(element);
       uint32_t usage = IOHIDElementGetUsage(element);
       if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Misc &&
-          usage - kAxisMinimumUsageNumber >= WebGamepad::kAxesLengthCap &&
+          usage - kAxisMinimumUsageNumber >= Gamepad::kAxesLengthCap &&
           usage_page <= kGameControlsUsagePage) {
-        for (; next_index < WebGamepad::kAxesLengthCap; ++next_index) {
+        for (; next_index < Gamepad::kAxesLengthCap; ++next_index) {
           if (associated.axis_elements[next_index] == NULL)
             break;
         }
-        if (next_index < WebGamepad::kAxesLengthCap) {
+        if (next_index < Gamepad::kAxesLengthCap) {
           associated.axis_elements[next_index] = element;
           pad.axes_length = std::max(pad.axes_length, next_index + 1);
         }
       }
 
-      if (next_index >= WebGamepad::kAxesLengthCap)
+      if (next_index >= Gamepad::kAxesLengthCap)
         break;
     }
   }
 
   for (uint32_t axis_index = 0; axis_index < pad.axes_length; ++axis_index) {
     IOHIDElementRef element = associated.axis_elements[axis_index];
     if (element != NULL) {
       CFIndex axis_min = IOHIDElementGetLogicalMin(element);
       CFIndex axis_max = IOHIDElementGetLogicalMax(element);
 
       // Some HID axes report a logical range of -1 to 0 signed, which must be
       // interpreted as 0 to -1 unsigned for correct normalization behavior.
       if (axis_min == -1 && axis_max == 0) {
         axis_max = -1;
         axis_min = 0;
       }
 
       associated.axis_minimums[axis_index] = axis_min;
       associated.axis_maximums[axis_index] = axis_max;
       associated.axis_report_sizes[axis_index] =
           IOHIDElementGetReportSize(element);
     }
   }
 
   return (pad.axes_length > 0 || pad.buttons_length > 0);
 }
 
 size_t GamepadPlatformDataFetcherMac::GetEmptySlot() {
   // Find a free slot for this device.
-  for (size_t slot = 0; slot < WebGamepads::kItemsLengthCap; ++slot) {
+  for (size_t slot = 0; slot < Gamepads::kItemsLengthCap; ++slot) {
     if (associated_[slot].device_ref == nullptr)
       return slot;
   }
-  return WebGamepads::kItemsLengthCap;
+  return Gamepads::kItemsLengthCap;
 }
 
 size_t GamepadPlatformDataFetcherMac::GetSlotForDevice(IOHIDDeviceRef device) {
-  for (size_t slot = 0; slot < WebGamepads::kItemsLengthCap; ++slot) {
+  for (size_t slot = 0; slot < Gamepads::kItemsLengthCap; ++slot) {
     // If we already have this device, and it's already connected, don't do
     // anything now.
     if (associated_[slot].device_ref == device)
-      return WebGamepads::kItemsLengthCap;
+      return Gamepads::kItemsLengthCap;
   }
   return GetEmptySlot();
 }
 
 void GamepadPlatformDataFetcherMac::DeviceAdd(IOHIDDeviceRef device) {
   using base::mac::CFToNSCast;
   using base::mac::CFCastStrict;
 
   if (!enabled_)
     return;
 
   NSNumber* location_id = CFToNSCast(CFCastStrict<CFNumberRef>(
       IOHIDDeviceGetProperty(device, CFSTR(kIOHIDLocationIDKey))));
   int location_int = [location_id intValue];
 
   // Find an index for this device.
   size_t slot = GetSlotForDevice(device);
 
   // We can't handle this many connected devices.
-  if (slot == WebGamepads::kItemsLengthCap)
+  if (slot == Gamepads::kItemsLengthCap)
     return;
 
   // Clear some state that may have been left behind by previous gamepads
   memset(&associated_[slot], 0, sizeof(AssociatedData));
 
   PadState* state = GetPadState(location_int);
   if (!state)
     return;  // No available slot for this device
 
   NSNumber* vendor_id = CFToNSCast(CFCastStrict<CFNumberRef>(
@@ skipping 35 matching lines @@
   associated_[slot].device_ref = device;
   state->data.connected = true;
 }
 
 void GamepadPlatformDataFetcherMac::DeviceRemove(IOHIDDeviceRef device) {
   if (!enabled_)
     return;
 
   // Find the index for this device.
   size_t slot;
-  for (slot = 0; slot < WebGamepads::kItemsLengthCap; ++slot) {
+  for (slot = 0; slot < Gamepads::kItemsLengthCap; ++slot) {
     if (associated_[slot].device_ref == device)
       break;
   }
-  DCHECK(slot < WebGamepads::kItemsLengthCap);
+  DCHECK(slot < Gamepads::kItemsLengthCap);
   // Leave associated device_ref so that it will be reconnected in the same
   // location. Simply mark it as disconnected.
   associated_[slot].location_id = 0;
   associated_[slot].device_ref = nullptr;
 }
 
 void GamepadPlatformDataFetcherMac::ValueChanged(IOHIDValueRef value) {
   if (!enabled_ || paused_)
     return;
 
   IOHIDElementRef element = IOHIDValueGetElement(value);
   IOHIDDeviceRef device = IOHIDElementGetDevice(element);
 
   // Find device slot.
   size_t slot;
-  for (slot = 0; slot < WebGamepads::kItemsLengthCap; ++slot) {
+  for (slot = 0; slot < Gamepads::kItemsLengthCap; ++slot) {
     if (associated_[slot].device_ref == device)
       break;
   }
-  if (slot == WebGamepads::kItemsLengthCap)
+  if (slot == Gamepads::kItemsLengthCap)
     return;
 
   PadState* state = GetPadState(associated_[slot].location_id);
   if (!state)
     return;
 
-  WebGamepad& pad = state->data;
+  Gamepad& pad = state->data;
   AssociatedData& associated = associated_[slot];
 
   uint32_t value_length = IOHIDValueGetLength(value);
   if (value_length > 4) {
     // Workaround for bizarre issue with PS3 controllers that try to return
     // massive (30+ byte) values and crash IOHIDValueGetIntegerValue
     return;
   }
 
   // Find and fill in the associated button event, if any.
@@ skipping 34 matching lines @@
       return;
     }
   }
 }
 
 void GamepadPlatformDataFetcherMac::GetGamepadData(bool) {
   if (!enabled_)
     return;
 
   // Loop through and GetPadState to indicate the devices are still connected.
-  for (size_t slot = 0; slot < WebGamepads::kItemsLengthCap; ++slot) {
+  for (size_t slot = 0; slot < Gamepads::kItemsLengthCap; ++slot) {
     if (associated_[slot].device_ref != nullptr) {
       GetPadState(associated_[slot].location_id);
     }
   }
 }
 
 }  // namespace device