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

device/gamepad/gamepad_platform_data_fetcher_linux.cc

 // 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_linux.h"
 
 #include <fcntl.h>
 #include <linux/joystick.h>
 #include <string.h>
 #include <sys/stat.h>
@@ skipping 34 matching lines @@
       base::StartsWith(node_path, kJoystickRoot, base::CompareCase::SENSITIVE);
   if (!is_gamepad)
     return false;
 
   int tmp_idx = -1;
   const int base_len = sizeof(kJoystickRoot) - 1;
   base::StringPiece str(&node_path[base_len], strlen(node_path) - base_len);
   if (!base::StringToInt(str, &tmp_idx))
     return false;
   if (tmp_idx < 0 ||
-      tmp_idx >= static_cast<int>(blink::WebGamepads::kItemsLengthCap)) {
+      tmp_idx >= static_cast<int>(device::Gamepads::kItemsLengthCap)) {
     return false;
   }
   *index = tmp_idx;
   *path = node_path;
   return true;
 }
 
 }  // namespace
 
 namespace device {
 
-using blink::WebGamepad;
-using blink::WebGamepads;
-
 GamepadPlatformDataFetcherLinux::GamepadPlatformDataFetcherLinux() {
   for (size_t i = 0; i < arraysize(device_fd_); ++i) {
     device_fd_[i] = -1;
   }
 }
 
 GamepadPlatformDataFetcherLinux::~GamepadPlatformDataFetcherLinux() {
-  for (size_t i = 0; i < WebGamepads::kItemsLengthCap; ++i)
+  for (size_t i = 0; i < Gamepads::kItemsLengthCap; ++i)
     CloseFileDescriptorIfValid(device_fd_[i]);
 }
 
 GamepadSource GamepadPlatformDataFetcherLinux::source() {
   return Factory::static_source();
 }
 
 void GamepadPlatformDataFetcherLinux::OnAddedToProvider() {
   std::vector<UdevLinux::UdevMonitorFilter> filters;
   filters.push_back(UdevLinux::UdevMonitorFilter(kInputSubsystem, NULL));
   udev_.reset(new UdevLinux(
       filters, base::Bind(&GamepadPlatformDataFetcherLinux::RefreshDevice,
                           base::Unretained(this))));
 
   EnumerateDevices();
 }
 
 void GamepadPlatformDataFetcherLinux::GetGamepadData(bool) {
   TRACE_EVENT0("GAMEPAD", "GetGamepadData");
 
   // Update our internal state.
-  for (size_t i = 0; i < WebGamepads::kItemsLengthCap; ++i) {
+  for (size_t i = 0; i < Gamepads::kItemsLengthCap; ++i) {
     if (device_fd_[i] >= 0) {
       ReadDeviceData(i);
     }
   }
 }
 
 // Used during enumeration, and monitor notifications.
 void GamepadPlatformDataFetcherLinux::RefreshDevice(udev_device* dev) {
   int index;
   std::string node_path;
@@ skipping 21 matching lines @@
     }
 
     PadState* state = GetPadState(index);
     if (!state) {
       // No slot available for device, don't use.
       CloseFileDescriptorIfValid(device_fd);
       device_fd = -1;
       return;
     }
 
-    WebGamepad& pad = state->data;
+    Gamepad& pad = state->data;
     GamepadStandardMappingFunction& mapper = state->mapper;
 
     const char* vendor_id = udev_device_get_sysattr_value(dev, "id/vendor");
     const char* product_id = udev_device_get_sysattr_value(dev, "id/product");
     mapper = GetGamepadStandardMappingFunction(vendor_id, product_id);
 
     // Driver returns utf-8 strings here, so combine in utf-8 first and
     // convert to WebUChar later once we've picked an id string.
     const char* name = udev_device_get_sysattr_value(dev, "name");
     std::string name_string(name);
@@ skipping 22 matching lines @@
         name_string = base::StringPrintf("%s %s", manufacturer, product);
       }
     }
 
     // Append the vendor and product information then convert the utf-8
     // id string to WebUChar.
     std::string id =
         name_string + base::StringPrintf(" (%sVendor: %s Product: %s)",
                                          mapper ? "STANDARD GAMEPAD " : "",
                                          vendor_id, product_id);
-    base::TruncateUTF8ToByteSize(id, WebGamepad::kIdLengthCap - 1, &id);
+    base::TruncateUTF8ToByteSize(id, Gamepad::kIdLengthCap - 1, &id);
     base::string16 tmp16 = base::UTF8ToUTF16(id);
     memset(pad.id, 0, sizeof(pad.id));
     tmp16.copy(pad.id, arraysize(pad.id) - 1);
 
     if (mapper) {
       std::string mapping = "standard";
-      base::TruncateUTF8ToByteSize(mapping, WebGamepad::kMappingLengthCap - 1,
+      base::TruncateUTF8ToByteSize(mapping, Gamepad::kMappingLengthCap - 1,
                                    &mapping);
       tmp16 = base::UTF8ToUTF16(mapping);
       memset(pad.mapping, 0, sizeof(pad.mapping));
       tmp16.copy(pad.mapping, arraysize(pad.mapping) - 1);
     } else {
       pad.mapping[0] = 0;
     }
 
     pad.connected = true;
   }
@@ skipping 19 matching lines @@
     const char* path = udev_list_entry_get_name(dev_list_entry);
     ScopedUdevDevicePtr dev(
         udev_device_new_from_syspath(udev_->udev_handle(), path));
     if (!dev)
       continue;
     RefreshDevice(dev.get());
   }
 }
 
 void GamepadPlatformDataFetcherLinux::ReadDeviceData(size_t index) {
-  // Linker does not like CHECK_LT(index, WebGamepads::itemsLengthCap). =/
-  if (index >= WebGamepads::kItemsLengthCap) {
+  // Linker does not like CHECK_LT(index, Gamepads::kItemsLengthCap). =/
+  if (index >= Gamepads::kItemsLengthCap) {
     CHECK(false);
     return;
   }
 
   PadState* state = GetPadState(index);
   if (!state)
     return;
 
   int fd = device_fd_[index];
   DCHECK_GE(fd, 0);
 
-  WebGamepad& pad = state->data;
+  Gamepad& pad = state->data;
 
   js_event event;
   while (HANDLE_EINTR(read(fd, &event, sizeof(struct js_event))) > 0) {
     size_t item = event.number;
     if (event.type & JS_EVENT_AXIS) {
-      if (item >= WebGamepad::kAxesLengthCap)
+      if (item >= Gamepad::kAxesLengthCap)
         continue;
 
       pad.axes[item] = event.value / kMaxLinuxAxisValue;
 
       if (item >= pad.axes_length)
         pad.axes_length = item + 1;
     } else if (event.type & JS_EVENT_BUTTON) {
-      if (item >= WebGamepad::kButtonsLengthCap)
+      if (item >= Gamepad::kButtonsLengthCap)
         continue;
 
       pad.buttons[item].pressed = event.value;
       pad.buttons[item].value = event.value ? 1.0 : 0.0;
 
       if (item >= pad.buttons_length)
         pad.buttons_length = item + 1;
     }
     pad.timestamp = event.time;
   }
 }
 
 }  // namespace device