Refactored gamepad polling to support dynamic sources

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>
 #include <sys/types.h>
 #include <unistd.h>
 
-#include "base/macros.h"
-#include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "device/udev_linux/scoped_udev.h"
 #include "device/udev_linux/udev_linux.h"
 
 namespace {
@@ skipping 37 matching lines @@
 }
 
 }  // namespace
 
 namespace device {
 
 using blink::WebGamepad;
 using blink::WebGamepads;
 
 GamepadPlatformDataFetcherLinux::GamepadPlatformDataFetcherLinux() {
-  for (size_t i = 0; i < arraysize(pad_state_); ++i) {
+  for (size_t i = 0; i < arraysize(device_fd_); ++i) {
     device_fd_[i] = -1;
-    pad_state_[i].mapper = 0;
-    pad_state_[i].axis_mask = 0;
-    pad_state_[i].button_mask = 0;
   }
+}
 
+GamepadPlatformDataFetcherLinux::~GamepadPlatformDataFetcherLinux() {
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++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();
 }
 
-GamepadPlatformDataFetcherLinux::~GamepadPlatformDataFetcherLinux() {
-  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i)
-    CloseFileDescriptorIfValid(device_fd_[i]);
-}
-
-void GamepadPlatformDataFetcherLinux::GetGamepadData(WebGamepads* pads, bool) {
+void GamepadPlatformDataFetcherLinux::GetGamepadData(bool) {
   TRACE_EVENT0("GAMEPAD", "GetGamepadData");
 
   // Update our internal state.
   for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
     if (device_fd_[i] >= 0) {
       ReadDeviceData(i);
     }
   }
-
-  pads->length = WebGamepads::itemsLengthCap;
-  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
-    MapAndSanitizeGamepadData(&pad_state_[i], &pads->items[i]);
-  }
 }
 
 // Used during enumeration, and monitor notifications.
 void GamepadPlatformDataFetcherLinux::RefreshDevice(udev_device* dev) {
   int index;
   std::string node_path;
   if (IsGamepad(dev, &index, &node_path)) {
     int& device_fd = device_fd_[index];
-    WebGamepad& pad = pad_state_[index].data;
-    GamepadStandardMappingFunction& mapper = pad_state_[index].mapper;
 
     CloseFileDescriptorIfValid(device_fd);
 
     // The device pointed to by dev contains information about the logical
     // joystick device. In order to get the information about the physical
     // hardware, get the parent device that is also in the "input" subsystem.
     // This function should just walk up the tree one level.
     dev = udev_device_get_parent_with_subsystem_devtype(dev, kInputSubsystem,
                                                         NULL);
     if (!dev) {
       // Unable to get device information, don't use this device.
       device_fd = -1;
-      pad.connected = false;
       return;
     }
 
     device_fd = HANDLE_EINTR(open(node_path.c_str(), O_RDONLY | O_NONBLOCK));
     if (device_fd < 0) {
       // Unable to open device, don't use.
-      pad.connected = false;
       return;
     }
 
+    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;
+    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);
 
     // In many cases the information the input subsystem contains isn't
@@ skipping 36 matching lines @@
       std::string mapping = "standard";
       base::TruncateUTF8ToByteSize(mapping, WebGamepad::mappingLengthCap - 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_state_[index].axis_mask = 0;
-    pad_state_[index].button_mask = 0;
-
     pad.connected = true;
   }
 }
 
 void GamepadPlatformDataFetcherLinux::EnumerateDevices() {
   ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev_->udev_handle()));
   if (!enumerate)
     return;
   int ret =
       udev_enumerate_add_match_subsystem(enumerate.get(), kInputSubsystem);
@@ skipping 17 matching lines @@
   }
 }
 
 void GamepadPlatformDataFetcherLinux::ReadDeviceData(size_t index) {
   // Linker does not like CHECK_LT(index, WebGamepads::itemsLengthCap). =/
   if (index >= WebGamepads::itemsLengthCap) {
     CHECK(false);
     return;
   }
 
-  const int& fd = device_fd_[index];
-  WebGamepad& pad = pad_state_[index].data;
+  PadState* state = GetPadState(index);
+  if (!state)
+    return;
+
+  int fd = device_fd_[index];
   DCHECK_GE(fd, 0);
 
+  WebGamepad& 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::axesLengthCap)
         continue;
 
       pad.axes[item] = event.value / kMaxLinuxAxisValue;
 
       if (item >= pad.axesLength)
         pad.axesLength = item + 1;
     } else if (event.type & JS_EVENT_BUTTON) {
       if (item >= WebGamepad::buttonsLengthCap)
         continue;
 
       pad.buttons[item].pressed = event.value;
       pad.buttons[item].value = event.value ? 1.0 : 0.0;
 
       if (item >= pad.buttonsLength)
         pad.buttonsLength = item + 1;
     }
     pad.timestamp = event.time;
   }
 }
 
 }  // namespace device