Refactoring gamepad polling to support dynamically added sources

content/browser/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 "content/browser/gamepad/raw_input_data_fetcher_win.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/trace_event/trace_event.h"
-#include "content/common/gamepad_hardware_buffer.h"
 #include "content/common/gamepad_messages.h"
 
 namespace content {
 
 using namespace blink;
 
 namespace {
 
 float NormalizeAxis(long value, long min, long max) {
   return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f;
@@ skipping 15 matching lines @@
 
 }  // namespace
 
 RawGamepadInfo::RawGamepadInfo() {
 }
 
 RawGamepadInfo::~RawGamepadInfo() {
 }
 
 RawInputDataFetcher::RawInputDataFetcher()
-    : hid_dll_(base::FilePath(FILE_PATH_LITERAL("hid.dll"))),
-      rawinput_available_(GetHidDllFunctions()),
+    : rawinput_available_(false),
       filter_xinput_(true),
-      events_monitored_(false) {
+      events_monitored_(false),
+      last_source_id_(0),
+      last_enumeration_id_(0) {
 }
 
 RawInputDataFetcher::~RawInputDataFetcher() {
   ClearControllers();
   DCHECK(!window_);
   DCHECK(!events_monitored_);
 }
 
 void RawInputDataFetcher::WillDestroyCurrentMessageLoop() {
   StopMonitor();
 }
 
+void RawInputDataFetcher::OnAddedToProvider() {
+  hid_dll_.Reset(base::LoadNativeLibrary(
+      base::FilePath(FILE_PATH_LITERAL("hid.dll")), nullptr));
+  rawinput_available_ = GetHidDllFunctions();
+}
+
 RAWINPUTDEVICE* RawInputDataFetcher::GetRawInputDevices(DWORD flags) {
   size_t usage_count = arraysize(DeviceUsages);
   scoped_ptr<RAWINPUTDEVICE[]> devices(new RAWINPUTDEVICE[usage_count]);
   for (size_t i = 0; i < usage_count; ++i) {
     devices[i].dwFlags = flags;
     devices[i].usUsagePage = 1;
     devices[i].usUsage = DeviceUsages[i];
     devices[i].hwndTarget = (flags & RIDEV_REMOVE) ? 0 : window_->hwnd();
   }
   return devices.release();
 }
 
+void RawInputDataFetcher::PauseHint(bool pause) {
+  if (pause)
+    StopMonitor();
+  else
+    StartMonitor();
+}
+
 void RawInputDataFetcher::StartMonitor() {
   if (!rawinput_available_ || events_monitored_)
     return;
 
   if (!window_) {
     window_.reset(new base::win::MessageWindow());
     if (!window_->Create(base::Bind(&RawInputDataFetcher::HandleMessage,
                                     base::Unretained(this)))) {
       PLOG(ERROR) << "Failed to create the raw input window";
       window_.reset();
@@ skipping 39 matching lines @@
 }
 
 void RawInputDataFetcher::ClearControllers() {
   while (!controllers_.empty()) {
     RawGamepadInfo* gamepad_info = controllers_.begin()->second;
     controllers_.erase(gamepad_info->handle);
     delete gamepad_info;
   }
 }
 
-std::vector<RawGamepadInfo*> RawInputDataFetcher::EnumerateDevices() {
-  std::vector<RawGamepadInfo*> valid_controllers;
+void RawInputDataFetcher::GetGamepadData(bool devices_changed_hint) {
+  if (!rawinput_available_)
+    return;
 
-  ClearControllers();
+  if (devices_changed_hint)
+    EnumerateDevices();
+
+  for (const auto& controller : controllers_) {
+    RawGamepadInfo* gamepad = controller.second;
+    PadState* state = provider()->GetPadState(GAMEPAD_SOURCE_WIN_RAW,
+                                              gamepad->source_id);
+    if (!state)
+      continue;
+
+    WebGamepad& pad = state->data;
+
+    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;
+  }
+}
+
+void RawInputDataFetcher::EnumerateDevices() {
+  last_enumeration_id_++;
 
   UINT count = 0;
   UINT result = GetRawInputDeviceList(NULL, &count, sizeof(RAWINPUTDEVICELIST));
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceList() failed";
-    return valid_controllers;
+    return;
   }
   DCHECK_EQ(0u, result);
 
   scoped_ptr<RAWINPUTDEVICELIST[]> device_list(new RAWINPUTDEVICELIST[count]);
   result = GetRawInputDeviceList(device_list.get(), &count,
       sizeof(RAWINPUTDEVICELIST));
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceList() failed";
-    return valid_controllers;
+    return;
   }
   DCHECK_EQ(count, result);
 
   for (UINT i = 0; i < count; ++i) {
     if (device_list[i].dwType == RIM_TYPEHID) {
       HANDLE device_handle = device_list[i].hDevice;
-      RawGamepadInfo* gamepad_info = ParseGamepadInfo(device_handle);
-      if (gamepad_info) {
-        controllers_[device_handle] = gamepad_info;
-        valid_controllers.push_back(gamepad_info);
+      ControllerMap::iterator controller = controllers_.find(device_handle);
+
+      RawGamepadInfo* gamepad;
+      if (controller != controllers_.end()) {
+        gamepad = controller->second;
+      } else {
+        gamepad = ParseGamepadInfo(device_handle);
+        if (!gamepad)
+          continue;
+
+        PadState* state = provider()->GetPadState(GAMEPAD_SOURCE_WIN_RAW,
+                                                  gamepad->source_id);
+        if (!state)
+          continue;  // No slot available for this gamepad.
+
+        controllers_[device_handle] = gamepad;
+
+        WebGamepad& 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::idLengthCap,
+          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::mappingLengthCap, L"standard");
+        else
+          pad.mapping[0] = 0;
       }
+
+      gamepad->enumeration_id = last_enumeration_id_;
     }
   }
-  return valid_controllers;
-}
 
-RawGamepadInfo* RawInputDataFetcher::GetGamepadInfo(HANDLE handle) {
-  std::map<HANDLE, RawGamepadInfo*>::iterator it = controllers_.find(handle);
-  if (it != controllers_.end())
-    return it->second;
+  // Clear out old controllers that weren't part of this enumeration pass.
+  for (const auto& controller : controllers_) {
+    RawGamepadInfo* gamepad = controller.second;
+    if (gamepad->enumeration_id != last_enumeration_id_) {
+      controllers_.erase(gamepad->handle);
+      delete gamepad;
+    }
+  }
 
-  return NULL;
+  return;
 }
 
 RawGamepadInfo* RawInputDataFetcher::ParseGamepadInfo(HANDLE hDevice) {
   UINT size = 0;
 
-  // Do we already have this device in the map?
-  if (GetGamepadInfo(hDevice))
-    return NULL;
-
   // Query basic device info.
   UINT result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICEINFO,
       NULL, &size);
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
     return NULL;
   }
   DCHECK_EQ(0u, result);
 
   scoped_ptr<uint8_t[]> di_buffer(new uint8_t[size]);
@@ skipping 13 matching lines @@
     if (device_info->hid.usUsage == device_usage) {
       valid_type = true;
       break;
     }
   }
 
   if (!valid_type)
     return NULL;
 
   scoped_ptr<RawGamepadInfo> gamepad_info(new RawGamepadInfo);
+  gamepad_info->source_id = ++last_source_id_;
+  gamepad_info->enumeration_id = last_enumeration_id_;
   gamepad_info->handle = hDevice;
   gamepad_info->report_id = 0;
   gamepad_info->vendor_id = device_info->hid.dwVendorId;
   gamepad_info->product_id = device_info->hid.dwProductId;
   gamepad_info->buttons_length = 0;
   ZeroMemory(gamepad_info->buttons, sizeof(gamepad_info->buttons));
   gamepad_info->axes_length = 0;
   ZeroMemory(gamepad_info->axes, sizeof(gamepad_info->axes));
 
   // Query device identifier
@@ skipping 119 matching lines @@
           gamepad_info->axes_length =
               std::max(gamepad_info->axes_length, next_index + 1);
         }
       }
 
       if (next_index >= WebGamepad::axesLengthCap)
         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();
 }
 
 void RawInputDataFetcher::UpdateGamepad(
     RAWINPUT* input,
     RawGamepadInfo* gamepad_info) {
   NTSTATUS status;
 
   gamepad_info->report_id++;
 
@@ skipping 84 matching lines @@
   result = GetRawInputData(
       input_handle, RID_INPUT, buffer.get(), &size, sizeof(RAWINPUTHEADER));
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputData() failed";
     return 0;
   }
   DCHECK_EQ(size, result);
 
   // Notify the observer about events generated locally.
   if (input->header.dwType == RIM_TYPEHID && input->header.hDevice != NULL) {
-    RawGamepadInfo* gamepad = GetGamepadInfo(input->header.hDevice);
-    if (gamepad)
-      UpdateGamepad(input, gamepad);
+    ControllerMap::iterator it = controllers_.find(input->header.hDevice);
+    if (it != controllers_.end())
+      UpdateGamepad(input, it->second);
   }
 
   return DefRawInputProc(&input, 1, sizeof(RAWINPUTHEADER));
 }
 
 bool RawInputDataFetcher::HandleMessage(UINT message,
                                         WPARAM wparam,
                                         LPARAM lparam,
                                         LRESULT* result) {
   switch (message) {
@@ skipping 43 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 content