ozone: evdev: Fix possibility of stuck keys with libevdev

ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.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 "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 
 #include <gestures/gestures.h>
 #include <libevdev/libevdev.h>
 #include <linux/input.h>
 
@@ skipping 61 matching lines @@
       static_cast<GestureInterpreterLibevdevCros*>(client_data);
   interpreter->OnGestureReady(gesture);
 }
 
 // Convert gestures timestamp (stime_t) to ui::Event timestamp.
 base::TimeDelta StimeToTimedelta(stime_t timestamp) {
   return base::TimeDelta::FromMicroseconds(timestamp *
                                            base::Time::kMicrosecondsPerSecond);
 }
 
-base::TimeDelta TimeValToTimeDelta(const timeval& tv) {
-  return base::TimeDelta::FromMicroseconds(tv.tv_sec * 1000000 + tv.tv_usec);
-}
-
 // Number of fingers for scroll gestures.
 const int kGestureScrollFingerCount = 2;
 
 // Number of fingers for swipe gestures.
 const int kGestureSwipeFingerCount = 3;
 
 }  // namespace
 
 GestureInterpreterLibevdevCros::GestureInterpreterLibevdevCros(
     int id,
@@ skipping 57 matching lines @@
   GestureInterpreterSetTimerProvider(
       interpreter_,
       const_cast<GesturesTimerProvider*>(&kGestureTimerProvider),
       this);
   GestureInterpreterSetCallback(interpreter_, OnGestureReadyHelper, this);
 }
 
 void GestureInterpreterLibevdevCros::OnLibEvdevCrosEvent(Evdev* evdev,
                                                          EventStateRec* evstate,
                                                          const timeval& time) {
-  // If the device has keys no it, dispatch any presses/release.
-  DispatchChangedKeys(evdev, time);
+  stime_t timestamp = StimeFromTimeval(&time);
+
+  // If the device has keys on it, dispatch any presses/release.
+  DispatchChangedKeys(evdev->key_state_bitmask, timestamp);
 
   HardwareState hwstate;
   memset(&hwstate, 0, sizeof(hwstate));
-  hwstate.timestamp = StimeFromTimeval(&time);
+  hwstate.timestamp = timestamp;
 
   // Mouse.
   hwstate.rel_x = evstate->rel_x;
   hwstate.rel_y = evstate->rel_y;
   hwstate.rel_wheel = evstate->rel_wheel;
   hwstate.rel_hwheel = evstate->rel_hwheel;
 
   // Touch.
   FingerState fingers[Event_Get_Slot_Count(evdev)];
   memset(&fingers, 0, sizeof(fingers));
@@ skipping 21 matching lines @@
   if (Event_Get_Button_Left(evdev))
     hwstate.buttons_down |= GESTURES_BUTTON_LEFT;
   if (Event_Get_Button_Middle(evdev))
     hwstate.buttons_down |= GESTURES_BUTTON_MIDDLE;
   if (Event_Get_Button_Right(evdev))
     hwstate.buttons_down |= GESTURES_BUTTON_RIGHT;
 
   GestureInterpreterPushHardwareState(interpreter_, &hwstate);
 }
 
+void GestureInterpreterLibevdevCros::OnLibEvdevCrosStopped(
+    Evdev* evdev,
+    EventStateRec* state) {
+  ReleaseKeys();
+}
+
 void GestureInterpreterLibevdevCros::SetAllowedKeys(
     scoped_ptr<std::set<DomCode>> allowed_keys) {
   if (!allowed_keys) {
     allowed_keys_.reset();
     return;
   }
 
   allowed_keys_.reset(new std::set<int>());
   for (const auto& it : *allowed_keys) {
     int evdev_code =
@@ skipping 194 matching lines @@
 
 void GestureInterpreterLibevdevCros::DispatchMouseButton(unsigned int button,
                                                          bool down,
                                                          stime_t time) {
   bool allow_remap = is_mouse_;
   dispatcher_->DispatchMouseButtonEvent(
       MouseButtonEventParams(id_, cursor_->GetLocation(), button, down,
                              allow_remap, StimeToTimedelta(time)));
 }
 
-void GestureInterpreterLibevdevCros::DispatchChangedKeys(Evdev* evdev,
-                                                         const timeval& time) {
+void GestureInterpreterLibevdevCros::DispatchChangedKeys(
+    unsigned long* new_key_state,
+    stime_t timestamp) {
   unsigned long key_state_diff[EVDEV_BITS_TO_LONGS(KEY_CNT)];
 
   // Find changed keys.
   for (unsigned long i = 0; i < arraysize(key_state_diff); ++i)
-    key_state_diff[i] = evdev->key_state_bitmask[i] ^ prev_key_state_[i];
+    key_state_diff[i] = new_key_state[i] ^ prev_key_state_[i];
 
   // Dispatch events for changed keys.
   for (unsigned long key = 0; key < KEY_CNT; ++key) {
     if (EvdevBitIsSet(key_state_diff, key)) {
-      bool value = EvdevBitIsSet(evdev->key_state_bitmask, key);
+      bool value = EvdevBitIsSet(new_key_state, key);
 
       // Mouse buttons are handled by DispatchMouseButton.
       if (key >= BTN_MOUSE && key < BTN_JOYSTICK)
         continue;
 
       // Ignore digi buttons (e.g. BTN_TOOL_FINGER).
       if (key >= BTN_DIGI && key < BTN_WHEEL)
         continue;
 
       if (allowed_keys_ && !allowed_keys_->count(key))
         continue;
 
       // Dispatch key press or release to keyboard.
       dispatcher_->DispatchKeyEvent(
-          KeyEventParams(id_, key, value, TimeValToTimeDelta(time)));
+          KeyEventParams(id_, key, value, StimeToTimedelta(timestamp)));
     }
   }
 
   // Update internal key state.
   for (unsigned long i = 0; i < EVDEV_BITS_TO_LONGS(KEY_CNT); ++i)
-    prev_key_state_[i] = evdev->key_state_bitmask[i];
+    prev_key_state_[i] = new_key_state[i];
+}
+
+void GestureInterpreterLibevdevCros::ReleaseKeys() {
+  unsigned long new_key_state[EVDEV_BITS_TO_LONGS(KEY_CNT)];
+  memset(&new_key_state, 0, sizeof(new_key_state));
+
+  DispatchChangedKeys(new_key_state, StimeNow());
 }
 
 }  // namespace ui