Add generic mapping for gamepad

ui/events/ozone/evdev/gamepad_event_converter_evdev.cc

 // Copyright 2017 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 "ui/events/ozone/evdev/gamepad_event_converter_evdev.h"
 
 #include <errno.h>
 #include <linux/input.h>
 #include <stddef.h>
 
@@ skipping 89 matching lines @@
                           id,
                           devinfo.device_type(),
                           devinfo.name(),
                           devinfo.vendor_id(),
                           devinfo.product_id()),
       will_send_frame_(false),
       last_hat_left_press_(false),
       last_hat_right_press_(false),
       last_hat_up_press_(false),
       last_hat_down_press_(false),
-      mapper_(GetGamepadMapper(devinfo.vendor_id(), devinfo.product_id())),
+      mapper_(GetGamepadMapper(devinfo)),
       input_device_fd_(std::move(fd)),
       dispatcher_(dispatcher) {
   input_absinfo abs_info;
   GamepadEventType mapped_type;
   uint16_t mapped_code;
   // In order to map gamepad, we have to save the abs_info from device_info
   // and get the gamepad_mapping.
   for (int code = 0; code < ABS_CNT; ++code) {
     abs_info = devinfo.GetAbsInfoByCode(code);
     if (devinfo.HasAbsEvent(code)) {
       // If fuzz was reported as zero, it will be set to flat * 0.25f. It is
       // the same thing done in Android InputReader.cpp. See:
       // frameworks/native/services/inputflinger/InputReader.cpp line 6988 for
       // more details.
       if (abs_info.fuzz == 0) {
         abs_info.fuzz = abs_info.flat * 0.25f;
       }
-      mapper_(EV_ABS, code, &mapped_type, &mapped_code);
+      (*mapper_)(EV_ABS, code, &mapped_type, &mapped_code);
       axes_[code] = Axis(abs_info, mapped_type, mapped_code);
     }
   }
 }
 
 GamepadEventConverterEvdev::~GamepadEventConverterEvdev() {
   DCHECK(!enabled_);
+  delete mapper_;
 }
 
 bool GamepadEventConverterEvdev::HasGamepad() const {
   return true;
 }
 
 void GamepadEventConverterEvdev::OnFileCanReadWithoutBlocking(int fd) {
   TRACE_EVENT1("evdev",
                "GamepadEventConverterEvdev::OnFileCanReadWithoutBlocking", "fd",
                fd);
@@ skipping 37 matching lines @@
   }
 }
 
 void GamepadEventConverterEvdev::ProcessEvdevKey(
     uint16_t code,
     uint16_t value,
     const base::TimeTicks& timestamp) {
   GamepadEventType mapped_type;
   uint16_t mapped_code;
 
-  bool found_map = mapper_(EV_KEY, code, &mapped_type, &mapped_code);
+  bool found_map = (*mapper_)(EV_KEY, code, &mapped_type, &mapped_code);
 
   // If we cannot find a map for this event, it will be discarded.
   if (!found_map) {
     return;
   }
 
   // If it's btn -> btn mapping, we can send the event and return now.
   OnButtonChange(mapped_code, value, timestamp);
 }
 
@@ skipping 104 matching lines @@
 
 void GamepadEventConverterEvdev::OnSync(const base::TimeTicks& timestamp) {
   if (will_send_frame_) {
     GamepadEvent event(input_device_.id, GamepadEventType::FRAME, 0, 0,
                        timestamp);
     dispatcher_->DispatchGamepadEvent(event);
     will_send_frame_ = false;
   }
 }
 }  //  namespace ui