Revert of Refactoring gamepad polling to support dynamically added sources

content/browser/gamepad/gamepad_platform_data_fetcher_win.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 "content/browser/gamepad/gamepad_platform_data_fetcher_win.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include "base/strings/stringprintf.h"
@@ skipping 38 matching lines @@
     case kDeviceSubTypeDrumKit: return L"DRUM_KIT";
     case kDeviceSubTypeGuitarBass: return L"GUITAR_BASS";
     case kDeviceSubTypeArcadePad: return L"ARCADE_PAD";
     default: return L"<UNKNOWN>";
   }
 }
 
 }  // namespace
 
 GamepadPlatformDataFetcherWin::GamepadPlatformDataFetcherWin()
-    : xinput_available_(false) {
-  for (size_t i = 0; i < XUSER_MAX_COUNT; ++i)
-    xinput_connected_[i] = false;
+    : xinput_dll_(base::FilePath(FILE_PATH_LITERAL("xinput1_3.dll"))),
+      xinput_available_(GetXInputDllFunctions()) {
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+    platform_pad_state_[i].status = DISCONNECTED;
+    pad_state_[i].mapper = NULL;
+    pad_state_[i].axis_mask = 0;
+    pad_state_[i].button_mask = 0;
+  }
+
+  raw_input_fetcher_.reset(new RawInputDataFetcher());
+  raw_input_fetcher_->StartMonitor();
 }
 
 GamepadPlatformDataFetcherWin::~GamepadPlatformDataFetcherWin() {
+  raw_input_fetcher_->StopMonitor();
 }
 
-void GamepadPlatformDataFetcherWin::OnAddedToProvider() {
-  xinput_dll_.Reset(base::LoadNativeLibrary(
-      base::FilePath(FILE_PATH_LITERAL("xinput1_3.dll")), nullptr));
-  xinput_available_ = GetXInputDllFunctions();
+int GamepadPlatformDataFetcherWin::FirstAvailableGamepadId() const {
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+    if (platform_pad_state_[i].status == DISCONNECTED)
+      return i;
+  }
+  return -1;
+}
+
+bool GamepadPlatformDataFetcherWin::HasXInputGamepad(int index) const {
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+    if (platform_pad_state_[i].status == XINPUT_CONNECTED &&
+        platform_pad_state_[i].xinput_index == index)
+      return true;
+  }
+  return false;
+}
+
+bool GamepadPlatformDataFetcherWin::HasRawInputGamepad(
+    const HANDLE handle) const {
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+    if (platform_pad_state_[i].status == RAWINPUT_CONNECTED &&
+        platform_pad_state_[i].raw_input_handle == handle)
+      return true;
+  }
+  return false;
 }
 
 void GamepadPlatformDataFetcherWin::EnumerateDevices() {
   TRACE_EVENT0("GAMEPAD", "EnumerateDevices");
 
-  if (xinput_available_) {
-    for (size_t i = 0; i < XUSER_MAX_COUNT; ++i) {
-      // Check to see if the xinput device is connected
-      XINPUT_CAPABILITIES caps;
-      DWORD res = xinput_get_capabilities_(i, XINPUT_FLAG_GAMEPAD, &caps);
-      xinput_connected_[i] = (res == ERROR_SUCCESS);
-      if (!xinput_connected_[i])
+  // Mark all disconnected pads DISCONNECTED.
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+    if (!pad_state_[i].data.connected)
+      platform_pad_state_[i].status = DISCONNECTED;
+  }
+
+  for (size_t i = 0; i < XUSER_MAX_COUNT; ++i) {
+    if (HasXInputGamepad(i))
+      continue;
+    int pad_index = FirstAvailableGamepadId();
+    if (pad_index == -1)
+      return;  // We can't add any more gamepads.
+    WebGamepad& pad = pad_state_[pad_index].data;
+    if (xinput_available_ && GetXInputPadConnectivity(i, &pad)) {
+      platform_pad_state_[pad_index].status = XINPUT_CONNECTED;
+      platform_pad_state_[pad_index].xinput_index = i;
+      pad_state_[pad_index].mapper = NULL;
+      pad_state_[pad_index].axis_mask = 0;
+      pad_state_[pad_index].button_mask = 0;
+    }
+  }
+
+  if (raw_input_fetcher_->Available()) {
+    std::vector<RawGamepadInfo*> raw_inputs =
+        raw_input_fetcher_->EnumerateDevices();
+    for (size_t i = 0; i < raw_inputs.size(); ++i) {
+      RawGamepadInfo* gamepad = raw_inputs[i];
+      if (gamepad->buttons_length == 0 && gamepad->axes_length == 0)
         continue;
+      if (HasRawInputGamepad(gamepad->handle))
+        continue;
+      int pad_index = FirstAvailableGamepadId();
+      if (pad_index == -1)
+        return;
+      WebGamepad& pad = pad_state_[pad_index].data;
+      pad.connected = true;
+      PadState& state = pad_state_[pad_index];
+      PlatformPadState& platform_state = platform_pad_state_[pad_index];
+      platform_state.status = RAWINPUT_CONNECTED;
+      platform_state.raw_input_handle = gamepad->handle;
 
-      PadState* state = provider()->GetPadState(GAMEPAD_SOURCE_WIN_XINPUT, i);
-      if (!state)
-        continue;  // No slot available for this gamepad.
+      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;
 
-      WebGamepad& pad = state->data;
+      swprintf(pad.id, WebGamepad::idLengthCap,
+        L"%ls (%lsVendor: %04x Product: %04x)",
+        gamepad->id, state.mapper ? L"STANDARD GAMEPAD " : L"",
+        gamepad->vendor_id, gamepad->product_id);
 
-      if (state->active_state == GAMEPAD_NEWLY_ACTIVE) {
-        // This is the first time we've seen this device, so do some one-time
-        // initialization
-        pad.connected = true;
-        swprintf(pad.id,
-                 WebGamepad::idLengthCap,
-                 L"Xbox 360 Controller (XInput STANDARD %ls)",
-                 GamepadSubTypeName(caps.SubType));
+      if (state.mapper)
         swprintf(pad.mapping, WebGamepad::mappingLengthCap, L"standard");
-      }
+      else
+        pad.mapping[0] = 0;
     }
   }
 }
 
-void GamepadPlatformDataFetcherWin::GetGamepadData(bool devices_changed_hint) {
+void GamepadPlatformDataFetcherWin::GetGamepadData(WebGamepads* pads,
+                                                   bool devices_changed_hint) {
   TRACE_EVENT0("GAMEPAD", "GetGamepadData");
 
-  if (!xinput_available_)
+  if (!xinput_available_ &&
+      !raw_input_fetcher_->Available()) {
+    pads->length = 0;
     return;
+  }
 
   // A note on XInput devices:
   // If we got notification that system devices have been updated, then
   // run GetCapabilities to update the connected status and the device
   // identifier. It can be slow to do to both GetCapabilities and
   // GetState on unconnected devices, so we want to avoid a 2-5ms pause
   // here by only doing this when the devices are updated (despite
   // documentation claiming it's OK to call it any time).
   if (devices_changed_hint)
     EnumerateDevices();
 
-  for (size_t i = 0; i < XUSER_MAX_COUNT; ++i) {
-    if (xinput_connected_[i])
-      GetXInputPadData(i);
+  pads->length = 0;
+
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+    // We rely on device_changed and GetCapabilities to tell us that
+    // something's been connected, but we will mark as disconnected if
+    // Get___PadState returns that we've lost the pad.
+    if (!pad_state_[i].data.connected)
+      continue;
+
+    if (platform_pad_state_[i].status == XINPUT_CONNECTED)
+      GetXInputPadData(i, &pad_state_[i].data);
+    else if (platform_pad_state_[i].status == RAWINPUT_CONNECTED)
+      GetRawInputPadData(i, &pad_state_[i].data);
+
+    MapAndSanitizeGamepadData(&pad_state_[i], &pads->items[i]);
+
+    if (pads->items[i].connected)
+      pads->length++;
   }
 }
 
-void GamepadPlatformDataFetcherWin::GetXInputPadData(int i) {
-  PadState* pad_state = provider()->GetPadState(GAMEPAD_SOURCE_WIN_XINPUT, i);
-  if (!pad_state)
-    return;
+void GamepadPlatformDataFetcherWin::PauseHint(bool pause) {
+  if (pause)
+    raw_input_fetcher_->StopMonitor();
+  else
+    raw_input_fetcher_->StartMonitor();
+}
 
-  WebGamepad& pad = pad_state->data;
+bool GamepadPlatformDataFetcherWin::GetXInputPadConnectivity(
+    int i,
+    WebGamepad* pad) const {
+  DCHECK(pad);
+  TRACE_EVENT1("GAMEPAD", "GetXInputPadConnectivity", "id", i);
+  XINPUT_CAPABILITIES caps;
+  DWORD res = xinput_get_capabilities_(i, XINPUT_FLAG_GAMEPAD, &caps);
+  if (res == ERROR_DEVICE_NOT_CONNECTED) {
+    pad->connected = false;
+    return false;
+  } else {
+    pad->connected = true;
+    swprintf(pad->id,
+             WebGamepad::idLengthCap,
+             L"Xbox 360 Controller (XInput STANDARD %ls)",
+             GamepadSubTypeName(caps.SubType));
+    swprintf(pad->mapping, WebGamepad::mappingLengthCap, L"standard");
+    return true;
+  }
+}
 
+void GamepadPlatformDataFetcherWin::GetXInputPadData(
+    int i,
+    WebGamepad* pad) {
   XINPUT_STATE state;
   memset(&state, 0, sizeof(XINPUT_STATE));
   TRACE_EVENT_BEGIN1("GAMEPAD", "XInputGetState", "id", i);
-  DWORD dwResult = xinput_get_state_(i, &state);
+  DWORD dwResult = xinput_get_state_(platform_pad_state_[i].xinput_index,
+                                     &state);
   TRACE_EVENT_END1("GAMEPAD", "XInputGetState", "id", i);
 
   if (dwResult == ERROR_SUCCESS) {
-    pad.timestamp = state.dwPacketNumber;
-    pad.buttonsLength = 0;
+    pad->timestamp = state.dwPacketNumber;
+    pad->buttonsLength = 0;
     WORD val = state.Gamepad.wButtons;
-#define ADD(b) pad.buttons[pad.buttonsLength].pressed = (val & (b)) != 0; \
-  pad.buttons[pad.buttonsLength++].value = ((val & (b)) ? 1.f : 0.f);
+#define ADD(b) pad->buttons[pad->buttonsLength].pressed = (val & (b)) != 0; \
+  pad->buttons[pad->buttonsLength++].value = ((val & (b)) ? 1.f : 0.f);
     ADD(XINPUT_GAMEPAD_A);
     ADD(XINPUT_GAMEPAD_B);
     ADD(XINPUT_GAMEPAD_X);
     ADD(XINPUT_GAMEPAD_Y);
     ADD(XINPUT_GAMEPAD_LEFT_SHOULDER);
     ADD(XINPUT_GAMEPAD_RIGHT_SHOULDER);
 
-    pad.buttons[pad.buttonsLength].pressed =
+    pad->buttons[pad->buttonsLength].pressed =
       state.Gamepad.bLeftTrigger >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
-    pad.buttons[pad.buttonsLength++].value =
+    pad->buttons[pad->buttonsLength++].value =
       state.Gamepad.bLeftTrigger / 255.f;
 
-    pad.buttons[pad.buttonsLength].pressed =
+    pad->buttons[pad->buttonsLength].pressed =
       state.Gamepad.bRightTrigger >= XINPUT_GAMEPAD_TRIGGER_THRESHOLD;
-    pad.buttons[pad.buttonsLength++].value =
+    pad->buttons[pad->buttonsLength++].value =
       state.Gamepad.bRightTrigger / 255.f;
 
     ADD(XINPUT_GAMEPAD_BACK);
     ADD(XINPUT_GAMEPAD_START);
     ADD(XINPUT_GAMEPAD_LEFT_THUMB);
     ADD(XINPUT_GAMEPAD_RIGHT_THUMB);
     ADD(XINPUT_GAMEPAD_DPAD_UP);
     ADD(XINPUT_GAMEPAD_DPAD_DOWN);
     ADD(XINPUT_GAMEPAD_DPAD_LEFT);
     ADD(XINPUT_GAMEPAD_DPAD_RIGHT);
 #undef ADD
-    pad.axesLength = 0;
+    pad->axesLength = 0;
 
     float value = 0.0;
 #define ADD(a, factor) value = factor * NormalizeXInputAxis(a); \
-  pad.axes[pad.axesLength++] = value;
+  pad->axes[pad->axesLength++] = value;
 
     // XInput are +up/+right, -down/-left, we want -up/-left.
     ADD(state.Gamepad.sThumbLX, 1);
     ADD(state.Gamepad.sThumbLY, -1);
     ADD(state.Gamepad.sThumbRX, 1);
     ADD(state.Gamepad.sThumbRY, -1);
 #undef ADD
+  } else {
+    pad->connected = false;
   }
 }
 
+void GamepadPlatformDataFetcherWin::GetRawInputPadData(
+    int index,
+    WebGamepad* pad) {
+  RawGamepadInfo* gamepad = raw_input_fetcher_->GetGamepadInfo(
+      platform_pad_state_[index].raw_input_handle);
+  if (!gamepad) {
+    pad->connected = false;
+    return;
+  }
+
+  pad->timestamp = gamepad->report_id;
+  pad->buttonsLength = gamepad->buttons_length;
+  pad->axesLength =  gamepad->axes_length;
+
+  for (unsigned int i = 0; i < pad->buttonsLength; i++) {
+    pad->buttons[i].pressed = gamepad->buttons[i];
+    pad->buttons[i].value = gamepad->buttons[i] ? 1.0 : 0.0;
+  }
+
+  for (unsigned int i = 0; i < pad->axesLength; i++)
+    pad->axes[i] = gamepad->axes[i].value;
+}
+
 bool GamepadPlatformDataFetcherWin::GetXInputDllFunctions() {
   xinput_get_capabilities_ = NULL;
   xinput_get_state_ = NULL;
   xinput_enable_ = reinterpret_cast<XInputEnableFunc>(
       xinput_dll_.GetFunctionPointer("XInputEnable"));
   if (!xinput_enable_)
     return false;
   xinput_get_capabilities_ = reinterpret_cast<XInputGetCapabilitiesFunc>(
       xinput_dll_.GetFunctionPointer("XInputGetCapabilities"));
   if (!xinput_get_capabilities_)
     return false;
   xinput_get_state_ = reinterpret_cast<XInputGetStateFunc>(
       xinput_dll_.GetFunctionPointer("XInputGetState"));
   if (!xinput_get_state_)
     return false;
   xinput_enable_(true);
   return true;
 }
 
 }  // namespace content