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

device/gamepad/raw_input_data_fetcher_win.cc

 // Copyright 2014 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/raw_input_data_fetcher_win.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 
 namespace device {
 
-using namespace blink;
-
 namespace {
 
 float NormalizeAxis(long value, long min, long max) {
   return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f;
 }
 
 unsigned long GetBitmask(unsigned short bits) {
   return (1 << bits) - 1;
 }
 
@@ skipping 126 matching lines @@
 
   if (devices_changed_hint)
     EnumerateDevices();
 
   for (const auto& controller : controllers_) {
     RawGamepadInfo* gamepad = controller.second;
     PadState* state = GetPadState(gamepad->source_id);
     if (!state)
       continue;
 
-    WebGamepad& pad = state->data;
+    Gamepad& pad = state->data;
 
     pad.timestamp = gamepad->report_id;
     pad.buttons_length = gamepad->buttons_length;
     pad.axes_length = gamepad->axes_length;
 
     for (unsigned int i = 0; i < pad.buttons_length; i++) {
       pad.buttons[i].pressed = gamepad->buttons[i];
       pad.buttons[i].value = gamepad->buttons[i] ? 1.0 : 0.0;
     }
 
@@ skipping 35 matching lines @@
         gamepad = ParseGamepadInfo(device_handle);
         if (!gamepad)
           continue;
 
         PadState* state = GetPadState(gamepad->source_id);
         if (!state)
           continue;  // No slot available for this gamepad.
 
         controllers_[device_handle] = gamepad;
 
-        WebGamepad& pad = state->data;
+        Gamepad& pad = state->data;
         pad.connected = true;
 
         std::string vendor = base::StringPrintf("%04x", gamepad->vendor_id);
         std::string product = base::StringPrintf("%04x", gamepad->product_id);
         state->mapper = GetGamepadStandardMappingFunction(vendor, product);
         state->axis_mask = 0;
         state->button_mask = 0;
 
-        swprintf(pad.id, WebGamepad::kIdLengthCap,
+        swprintf(pad.id, Gamepad::kIdLengthCap,
                  L"%ls (%lsVendor: %04x Product: %04x)", gamepad->id,
                  state->mapper ? L"STANDARD GAMEPAD " : L"", gamepad->vendor_id,
                  gamepad->product_id);
 
         if (state->mapper)
-          swprintf(pad.mapping, WebGamepad::kMappingLengthCap, L"standard");
+          swprintf(pad.mapping, Gamepad::kMappingLengthCap, L"standard");
         else
           pad.mapping[0] = 0;
       }
 
       gamepad->enumeration_id = last_enumeration_id_;
     }
   }
 
   // Clear out old controllers that weren't part of this enumeration pass.
   for (const auto& controller : controllers_) {
@@ skipping 84 matching lines @@
   HANDLE hid_handle = CreateFile(
       name_buffer.get(), GENERIC_READ | GENERIC_WRITE,
       FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, NULL);
   if (hid_handle) {
     got_product_string = hidd_get_product_string_(hid_handle, gamepad_info->id,
                                                   sizeof(gamepad_info->id));
     CloseHandle(hid_handle);
   }
 
   if (!got_product_string)
-    swprintf(gamepad_info->id, WebGamepad::kIdLengthCap, L"Unknown Gamepad");
+    swprintf(gamepad_info->id, Gamepad::kIdLengthCap, L"Unknown Gamepad");
 
   // Query device capabilities.
   result = GetRawInputDeviceInfo(hDevice, RIDI_PREPARSEDDATA, NULL, &size);
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
     return NULL;
   }
   DCHECK_EQ(0u, result);
 
   gamepad_info->ppd_buffer.reset(new uint8_t[size]);
@@ skipping 14 matching lines @@
   // Query button information.
   USHORT count = caps.NumberInputButtonCaps;
   if (count > 0) {
     std::unique_ptr<HIDP_BUTTON_CAPS[]> button_caps(
         new HIDP_BUTTON_CAPS[count]);
     status = hidp_get_button_caps_(HidP_Input, button_caps.get(), &count,
                                    gamepad_info->preparsed_data);
     DCHECK_EQ(HIDP_STATUS_SUCCESS, status);
 
     for (uint32_t i = 0; i < count; ++i) {
-      if (button_caps[i].Range.UsageMin <= WebGamepad::kButtonsLengthCap &&
+      if (button_caps[i].Range.UsageMin <= Gamepad::kButtonsLengthCap &&
           button_caps[i].UsagePage == kButtonUsagePage) {
         uint32_t max_index =
-            std::min(WebGamepad::kButtonsLengthCap,
+            std::min(Gamepad::kButtonsLengthCap,
                      static_cast<size_t>(button_caps[i].Range.UsageMax));
         gamepad_info->buttons_length =
             std::max(gamepad_info->buttons_length, max_index);
       }
     }
   }
 
   // Query axis information.
   count = caps.NumberInputValueCaps;
   std::unique_ptr<HIDP_VALUE_CAPS[]> axes_caps(new HIDP_VALUE_CAPS[count]);
   status = hidp_get_value_caps_(HidP_Input, axes_caps.get(), &count,
                                 gamepad_info->preparsed_data);
 
   bool mapped_all_axes = true;
 
   for (UINT i = 0; i < count; i++) {
     uint32_t axis_index = axes_caps[i].Range.UsageMin - kAxisMinimumUsageNumber;
-    if (axis_index < WebGamepad::kAxesLengthCap) {
+    if (axis_index < Gamepad::kAxesLengthCap) {
       gamepad_info->axes[axis_index].caps = axes_caps[i];
       gamepad_info->axes[axis_index].value = 0;
       gamepad_info->axes[axis_index].active = true;
       gamepad_info->axes[axis_index].bitmask = GetBitmask(axes_caps[i].BitSize);
       gamepad_info->axes_length =
           std::max(gamepad_info->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 (UINT i = 0; i < count; i++) {
       uint32_t usage = axes_caps[i].Range.UsageMin - kAxisMinimumUsageNumber;
-      if (usage >= WebGamepad::kAxesLengthCap &&
+      if (usage >= Gamepad::kAxesLengthCap &&
           axes_caps[i].UsagePage <= kGameControlsUsagePage) {
-        for (; next_index < WebGamepad::kAxesLengthCap; ++next_index) {
+        for (; next_index < Gamepad::kAxesLengthCap; ++next_index) {
           if (!gamepad_info->axes[next_index].active)
             break;
         }
-        if (next_index < WebGamepad::kAxesLengthCap) {
+        if (next_index < Gamepad::kAxesLengthCap) {
           gamepad_info->axes[next_index].caps = axes_caps[i];
           gamepad_info->axes[next_index].value = 0;
           gamepad_info->axes[next_index].active = true;
           gamepad_info->axes[next_index].bitmask =
               GetBitmask(axes_caps[i].BitSize);
           gamepad_info->axes_length =
               std::max(gamepad_info->axes_length, next_index + 1);
         }
       }
 
-      if (next_index >= WebGamepad::kAxesLengthCap)
+      if (next_index >= Gamepad::kAxesLengthCap)
         break;
     }
   }
 
   // Sometimes devices show up with no buttons or axes. Don't return these.
   if (gamepad_info->buttons_length == 0 && gamepad_info->axes_length == 0)
     return nullptr;
 
   return gamepad_info.release();
 }
@@ skipping 21 matching lines @@
         hidp_get_usages_ex_(HidP_Input, 0, usages.get(), &buttons_length,
                             gamepad_info->preparsed_data,
                             reinterpret_cast<PCHAR>(input->data.hid.bRawData),
                             input->data.hid.dwSizeHid);
 
     if (status == HIDP_STATUS_SUCCESS) {
       // Set each reported button to true.
       for (uint32_t j = 0; j < buttons_length; j++) {
         int32_t button_index = usages[j].Usage - 1;
         if (usages[j].UsagePage == kButtonUsagePage && button_index >= 0 &&
-            button_index <
-                static_cast<int>(blink::WebGamepad::kButtonsLengthCap)) {
+            button_index < static_cast<int>(Gamepad::kButtonsLengthCap)) {
           gamepad_info->buttons[button_index] = true;
         }
       }
     }
   }
 
   // Query axis state.
   ULONG axis_value = 0;
   LONG scaled_axis_value = 0;
   for (uint32_t i = 0; i < gamepad_info->axes_length; i++) {
@@ skipping 110 matching lines @@
     return false;
   hidd_get_product_string_ = reinterpret_cast<HidDGetStringFunc>(
       hid_dll_.GetFunctionPointer("HidD_GetProductString"));
   if (!hidd_get_product_string_)
     return false;
 
   return true;
 }
 
 }  // namespace device