ozone: Add raw scancode to GamepadEvent.

Currently, Ozone converts evdev scancode to Web Gamepad keycode, and
the keycode is stored in |code| field of GamepadEvent. This CL adds
|raw_code| field to GamepadEvent, which is the original evdev scancode.

This is a part of ARC++ Improved Gamepad Support, which will forward
raw scancode to Android container rather than converting scancode to
keycode in Ozone. For further background, please check the design doc:
go/arc-improved-gamepad

TBR=oshima@chromium.org
TEST=manual
BUG=b:130597086

Change-Id: Id66565631eae9f0e90432b63160b7d82728ec12f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1602232
Commit-Queue: Tetsui Ohkubo <tetsui@chromium.org>
Reviewed-by: Kevin Schoedel <kpschoedel@chromium.org>
Cr-Commit-Position: refs/heads/master@{#659419}

components/exo/gaming_seat_unittest.cc

@@ -66,7 +66,7 @@ class GamingSeatTest : public test::ExoTestBase {
 
   void SendFrameToGamepads(const std::vector<int>& gamepad_device_ids) {
     for (auto& id : gamepad_device_ids) {
-      ui::GamepadEvent event(id, ui::GamepadEventType::FRAME, 0, 0,
+      ui::GamepadEvent event(id, ui::GamepadEventType::FRAME, 0, 0, 0,
                              base::TimeTicks());
       ui::GamepadProviderOzone::GetInstance()->DispatchGamepadEvent(event);
     }

ui/events/ozone/evdev/gamepad_event_converter_evdev.cc

@@ -199,13 +199,17 @@ void GamepadEventConverterEvdev::ProcessEvdevKey(
   }
 
   // If it's btn -> btn mapping, we can send the event and return now.
-  OnButtonChange(mapped_code, value, timestamp);
+  OnButtonChange(mapped_code, code, value, timestamp);
 }
 
 void GamepadEventConverterEvdev::ProcessEvdevAbs(
     uint16_t code,
     int value,
     const base::TimeTicks& timestamp) {
+  // For abs type, notify raw event separately. When you're only interested in
+  // mapped data, you should ignore code == WG_ABS_COUNT for abs type.
+  OnAbsChange(WG_ABS_COUNT, code, value, timestamp);
+
   GamepadEventType mapped_type;
   uint16_t mapped_code;
 
@@ -220,7 +224,7 @@ void GamepadEventConverterEvdev::ProcessEvdevAbs(
 
   // If the mapped type is abs, we can send it now.
   if (mapped_type == GamepadEventType::AXIS) {
-    OnAbsChange(mapped_code, mapped_abs_value, timestamp);
+    OnAbsChange(mapped_code, 0, mapped_abs_value, timestamp);
     return;
   }
 
@@ -229,39 +233,39 @@ void GamepadEventConverterEvdev::ProcessEvdevAbs(
     bool hat_left_press = (mapped_abs_value < -kHatThreshold);
     bool hat_right_press = (mapped_abs_value > kHatThreshold);
     if (hat_left_press != last_hat_left_press_) {
-      OnButtonChange(WG_BUTTON_DPAD_LEFT, hat_left_press, timestamp);
+      OnButtonChange(WG_BUTTON_DPAD_LEFT, 0, hat_left_press, timestamp);
       last_hat_left_press_ = hat_left_press;
     }
 
     if (hat_right_press != last_hat_right_press_) {
-      OnButtonChange(WG_BUTTON_DPAD_RIGHT, hat_right_press, timestamp);
+      OnButtonChange(WG_BUTTON_DPAD_RIGHT, 0, hat_right_press, timestamp);
       last_hat_right_press_ = hat_right_press;
     }
   } else if (mapped_code == kHAT_Y) {
     bool hat_up_press = (mapped_abs_value < -kHatThreshold);
     bool hat_down_press = (mapped_abs_value > kHatThreshold);
     if (hat_up_press != last_hat_up_press_) {
-      OnButtonChange(WG_BUTTON_DPAD_UP, hat_up_press, timestamp);
+      OnButtonChange(WG_BUTTON_DPAD_UP, 0, hat_up_press, timestamp);
       last_hat_up_press_ = hat_up_press;
     }
 
     if (hat_down_press != last_hat_down_press_) {
-      OnButtonChange(WG_BUTTON_DPAD_DOWN, hat_down_press, timestamp);
+      OnButtonChange(WG_BUTTON_DPAD_DOWN, 0, hat_down_press, timestamp);
       last_hat_down_press_ = hat_down_press;
     }
   } else {
-    OnButtonChange(mapped_code, mapped_abs_value, timestamp);
+    OnButtonChange(mapped_code, 0, mapped_abs_value, timestamp);
   }
 }
 
 void GamepadEventConverterEvdev::ResetGamepad() {
   base::TimeTicks timestamp = ui::EventTimeForNow();
   for (int btn_code = 0; btn_code < WG_BUTTON_COUNT; ++btn_code) {
-    OnButtonChange(btn_code, 0, timestamp);
+    OnButtonChange(btn_code, 0, 0, timestamp);
   }
 
   for (int abs_code = 0; abs_code < WG_ABS_COUNT; ++abs_code) {
-    OnAbsChange(abs_code, 0, timestamp);
+    OnAbsChange(abs_code, 0, 0, timestamp);
   }
   OnSync(timestamp);
 }
@@ -270,7 +274,7 @@ void GamepadEventConverterEvdev::ResyncGamepad() {
   base::TimeTicks timestamp = ui::EventTimeForNow();
   // Reset all the buttons to 0.
   for (int btn_code = 0; btn_code < WG_BUTTON_COUNT; ++btn_code) {
-    OnButtonChange(btn_code, 0, timestamp);
+    OnButtonChange(btn_code, 0, 0, timestamp);
   }
   // Read the state of all axis.
   EventDeviceInfo info;
@@ -290,26 +294,28 @@ void GamepadEventConverterEvdev::ResyncGamepad() {
 
 void GamepadEventConverterEvdev::OnButtonChange(
     unsigned int code,
+    unsigned int raw_code,
     double value,
     const base::TimeTicks& timestamp) {
-  GamepadEvent event(input_device_.id, GamepadEventType::BUTTON, code, value,
-                     timestamp);
+  GamepadEvent event(input_device_.id, GamepadEventType::BUTTON, code, raw_code,
+                     value, timestamp);
   dispatcher_->DispatchGamepadEvent(event);
   will_send_frame_ = true;
 }
 
 void GamepadEventConverterEvdev::OnAbsChange(unsigned int code,
+                                             unsigned int raw_code,
                                              double value,
                                              const base::TimeTicks& timestamp) {
-  GamepadEvent event(input_device_.id, GamepadEventType::AXIS, code, value,
-                     timestamp);
+  GamepadEvent event(input_device_.id, GamepadEventType::AXIS, code, raw_code,
+                     value, timestamp);
   dispatcher_->DispatchGamepadEvent(event);
   will_send_frame_ = true;
 }
 
 void GamepadEventConverterEvdev::OnSync(const base::TimeTicks& timestamp) {
   if (will_send_frame_) {
-    GamepadEvent event(input_device_.id, GamepadEventType::FRAME, 0, 0,
+    GamepadEvent event(input_device_.id, GamepadEventType::FRAME, 0, 0, 0,
                        timestamp);
     dispatcher_->DispatchGamepadEvent(event);
     will_send_frame_ = false;

ui/events/ozone/evdev/gamepad_event_converter_evdev.h

@@ -61,9 +61,11 @@ class EVENTS_OZONE_EVDEV_EXPORT GamepadEventConverterEvdev
   void ResyncGamepad();
 
   void OnButtonChange(unsigned int code,
+                      unsigned int raw_code,
                       double value,
                       const base::TimeTicks& timestamp);
   void OnAbsChange(unsigned int code,
+                   unsigned int raw_code,
                    double value,
                    const base::TimeTicks& timestamp);
   void OnSync(const base::TimeTicks& timestamp);

ui/events/ozone/evdev/gamepad_event_converter_evdev_unittest.cc

@@ -158,16 +158,29 @@ TEST_F(GamepadEventConverterEvdevTest, XboxGamepadEvents) {
   clock.SetNowSeconds(1493076833);
 
   struct ExpectedEvent expected_events[] = {
-      {GamepadEventType::AXIS, 0, 0.583062}, {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::AXIS, 0, 0.547234}, {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::AXIS, 0, 0.530968}, {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 4, 1},      {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 4, 0},      {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 3, 1},      {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 3, 0},      {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 1, 1},      {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 1, 0},      {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 2, 1},      {GamepadEventType::FRAME, 0, 0}};
+      {GamepadEventType::AXIS, 4, 19105},
+      {GamepadEventType::AXIS, 0, 0.583062},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 17931},
+      {GamepadEventType::AXIS, 0, 0.547234},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 17398},
+      {GamepadEventType::AXIS, 0, 0.530968},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::BUTTON, 4, 1},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::BUTTON, 4, 0},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::BUTTON, 3, 1},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::BUTTON, 3, 0},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::BUTTON, 1, 1},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::BUTTON, 1, 0},
+      {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::BUTTON, 2, 1},
+      {GamepadEventType::FRAME, 0, 0}};
 
   for (unsigned i = 0; i < base::size(mock_kernel_queue); ++i) {
     dev->ProcessEvent(mock_kernel_queue[i]);
@@ -176,9 +189,12 @@ TEST_F(GamepadEventConverterEvdevTest, XboxGamepadEvents) {
   for (unsigned i = 0; i < observer.events.size(); ++i) {
     EXPECT_EQ(observer.events[i].type(), expected_events[i].type);
     EXPECT_EQ(observer.events[i].code(), expected_events[i].code);
-    double d = observer.events[i].value() - expected_events[i].value;
-    d = d > 0 ? d : -d;
-    EXPECT_LT(d, axis_delta);
+    if (observer.events[i].type() != GamepadEventType::AXIS ||
+        observer.events[i].code() != WG_ABS_COUNT) {
+      double d = observer.events[i].value() - expected_events[i].value;
+      d = d > 0 ? d : -d;
+      EXPECT_LT(d, axis_delta);
+    }
   }
 }
 
@@ -295,15 +311,28 @@ TEST_F(GamepadEventConverterEvdevTest, iBuffaloGamepadEvents) {
       {GamepadEventType::BUTTON, 4, 0},  {GamepadEventType::FRAME, 0, 0},
       {GamepadEventType::BUTTON, 5, 1},  {GamepadEventType::FRAME, 0, 0},
       {GamepadEventType::BUTTON, 5, 0},  {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 13, 1}, {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 128},  {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 127},  {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 128},  {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 255},  {GamepadEventType::BUTTON, 13, 1},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 128},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 127},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 128},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 127},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 128},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 255},
       {GamepadEventType::BUTTON, 15, 1}, {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 13, 0}, {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 128},  {GamepadEventType::BUTTON, 13, 0},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 0},
       {GamepadEventType::BUTTON, 12, 1}, {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 15, 0}, {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 128},  {GamepadEventType::BUTTON, 15, 0},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 255},
       {GamepadEventType::BUTTON, 15, 1}, {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 15, 0}, {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 128},  {GamepadEventType::BUTTON, 15, 0},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 0},
       {GamepadEventType::BUTTON, 14, 1}, {GamepadEventType::FRAME, 0, 0},
-      {GamepadEventType::BUTTON, 12, 0}, {GamepadEventType::FRAME, 0, 0},
+      {GamepadEventType::AXIS, 4, 128},  {GamepadEventType::BUTTON, 12, 0},
+      {GamepadEventType::FRAME, 0, 0},   {GamepadEventType::AXIS, 4, 255},
       {GamepadEventType::BUTTON, 13, 1}, {GamepadEventType::FRAME, 0, 0}};
 
   for (unsigned i = 0; i < base::size(mock_kernel_queue); ++i) {
@@ -313,9 +342,12 @@ TEST_F(GamepadEventConverterEvdevTest, iBuffaloGamepadEvents) {
   for (unsigned i = 0; i < observer.events.size(); ++i) {
     EXPECT_EQ(observer.events[i].type(), expected_events[i].type);
     EXPECT_EQ(observer.events[i].code(), expected_events[i].code);
-    double d = observer.events[i].value() - expected_events[i].value;
-    d = d > 0 ? d : -d;
-    EXPECT_LT(d, axis_delta);
+    if (observer.events[i].type() != GamepadEventType::AXIS ||
+        observer.events[i].code() != WG_ABS_COUNT) {
+      double d = observer.events[i].value() - expected_events[i].value;
+      d = d > 0 ? d : -d;
+      EXPECT_LT(d, axis_delta);
+    }
   }
 }
 }  // namespace ui

ui/events/ozone/gamepad/gamepad_event.cc

@@ -9,11 +9,13 @@ namespace ui {
 GamepadEvent::GamepadEvent(int device_id,
                            GamepadEventType type,
                            uint16_t code,
+                           uint16_t raw_code,
                            double value,
                            base::TimeTicks timestamp)
     : device_id_(device_id),
       type_(type),
       code_(code),
+      raw_code_(raw_code),
       value_(value),
       timestamp_(timestamp) {}
 

ui/events/ozone/gamepad/gamepad_event.h

@@ -15,6 +15,7 @@ class GamepadEvent {
   GamepadEvent(int device_id,
                GamepadEventType type,
                uint16_t code,
+               uint16_t raw_code,
                double value,
                base::TimeTicks timestamp);
 
@@ -24,6 +25,8 @@ class GamepadEvent {
 
   uint16_t code() const { return code_; }
 
+  uint16_t raw_code() const { return raw_code_; }
+
   double value() const { return value_; }
 
   base::TimeTicks timestamp() const { return timestamp_; }
@@ -33,8 +36,12 @@ class GamepadEvent {
 
   GamepadEventType type_;
 
+  // Web Gamepad keycode.
   uint16_t code_;
 
+  // Evdev scancode.
+  uint16_t raw_code_;
+
   double value_;
 
   base::TimeTicks timestamp_;