Ozone X11 platform

ui/events/devices/x11/device_data_manager_x11.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/devices/x11/device_data_manager_x11.h"
 
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 
@@ skipping 349 matching lines @@
       return true;
     } else if (IsTouchDataType(type)) {
       if (GetSlotNumber(xiev, &slot) && slot >= 0 && slot < kMaxSlotNum)
         *value = last_seen_valuator_[sourceid][slot][type];
     }
   }
 
   return false;
 }
 
-bool DeviceDataManagerX11::IsXIDeviceEvent(
-    const base::NativeEvent& native_event) const {
+bool DeviceDataManagerX11::IsXIDeviceEvent(const XEvent* native_event) const {
   if (native_event->type != GenericEvent ||
       native_event->xcookie.extension != xi_opcode_)
     return false;
   return xi_device_event_types_[native_event->xcookie.evtype];
 }
 
 bool DeviceDataManagerX11::IsTouchpadXInputEvent(
-    const base::NativeEvent& native_event) const {
+    const XEvent* native_event) const {
   if (native_event->type != GenericEvent)
     return false;
 
   XIDeviceEvent* xievent =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   if (xievent->sourceid >= kMaxDeviceNum)
     return false;
   return touchpads_[xievent->sourceid];
 }
 
-bool DeviceDataManagerX11::IsCMTDeviceEvent(
-    const base::NativeEvent& native_event) const {
+bool DeviceDataManagerX11::IsCMTDeviceEvent(const XEvent* native_event) const {
   if (native_event->type != GenericEvent)
     return false;
 
   XIDeviceEvent* xievent =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   if (xievent->sourceid >= kMaxDeviceNum)
     return false;
   return cmt_devices_[xievent->sourceid];
 }
 
-bool DeviceDataManagerX11::IsCMTGestureEvent(
-    const base::NativeEvent& native_event) const {
+bool DeviceDataManagerX11::IsCMTGestureEvent(const XEvent* native_event) const {
   return (IsScrollEvent(native_event) ||
           IsFlingEvent(native_event) ||
           IsCMTMetricsEvent(native_event));
 }
 
 bool DeviceDataManagerX11::HasEventData(
     const XIDeviceEvent* xiev, const DataType type) const {
   const int idx = valuator_lookup_[xiev->sourceid][type];
   return (idx >= 0) && XIMaskIsSet(xiev->valuators.mask, idx);
 }
 
-bool DeviceDataManagerX11::IsScrollEvent(
-    const base::NativeEvent& native_event) const {
+bool DeviceDataManagerX11::IsScrollEvent(const XEvent* native_event) const {
   if (!IsCMTDeviceEvent(native_event))
     return false;
 
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   return (HasEventData(xiev, DT_CMT_SCROLL_X) ||
           HasEventData(xiev, DT_CMT_SCROLL_Y));
 }
 
-bool DeviceDataManagerX11::IsFlingEvent(
-    const base::NativeEvent& native_event) const {
+bool DeviceDataManagerX11::IsFlingEvent(const XEvent* native_event) const {
   if (!IsCMTDeviceEvent(native_event))
     return false;
 
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   return (HasEventData(xiev, DT_CMT_FLING_X) &&
           HasEventData(xiev, DT_CMT_FLING_Y) &&
           HasEventData(xiev, DT_CMT_FLING_STATE));
 }
 
-bool DeviceDataManagerX11::IsCMTMetricsEvent(
-    const base::NativeEvent& native_event) const {
+bool DeviceDataManagerX11::IsCMTMetricsEvent(const XEvent* native_event) const {
   if (!IsCMTDeviceEvent(native_event))
     return false;
 
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   return (HasEventData(xiev, DT_CMT_METRICS_TYPE) &&
           HasEventData(xiev, DT_CMT_METRICS_DATA1) &&
           HasEventData(xiev, DT_CMT_METRICS_DATA2));
 }
 
-bool DeviceDataManagerX11::HasGestureTimes(
-    const base::NativeEvent& native_event) const {
+bool DeviceDataManagerX11::HasGestureTimes(const XEvent* native_event) const {
   if (!IsCMTDeviceEvent(native_event))
     return false;
 
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   return (HasEventData(xiev, DT_CMT_START_TIME) &&
           HasEventData(xiev, DT_CMT_END_TIME));
 }
 
-void DeviceDataManagerX11::GetScrollOffsets(
-    const base::NativeEvent& native_event,
-    float* x_offset,
-    float* y_offset,
-    float* x_offset_ordinal,
-    float* y_offset_ordinal,
-    int* finger_count) {
+void DeviceDataManagerX11::GetScrollOffsets(const XEvent* native_event,
+                                            float* x_offset,
+                                            float* y_offset,
+                                            float* x_offset_ordinal,
+                                            float* y_offset_ordinal,
+                                            int* finger_count) {
   *x_offset = 0;
   *y_offset = 0;
   *x_offset_ordinal = 0;
   *y_offset_ordinal = 0;
   *finger_count = 2;
 
   EventData data;
   GetEventRawData(*native_event, &data);
 
   if (data.find(DT_CMT_SCROLL_X) != data.end())
     *x_offset = data[DT_CMT_SCROLL_X];
   if (data.find(DT_CMT_SCROLL_Y) != data.end())
     *y_offset = data[DT_CMT_SCROLL_Y];
   if (data.find(DT_CMT_ORDINAL_X) != data.end())
     *x_offset_ordinal = data[DT_CMT_ORDINAL_X];
   if (data.find(DT_CMT_ORDINAL_Y) != data.end())
     *y_offset_ordinal = data[DT_CMT_ORDINAL_Y];
   if (data.find(DT_CMT_FINGER_COUNT) != data.end())
     *finger_count = static_cast<int>(data[DT_CMT_FINGER_COUNT]);
 }
 
-void DeviceDataManagerX11::GetFlingData(
-    const base::NativeEvent& native_event,
-    float* vx,
-    float* vy,
-    float* vx_ordinal,
-    float* vy_ordinal,
-    bool* is_cancel) {
+void DeviceDataManagerX11::GetFlingData(const XEvent* native_event,
+                                        float* vx,
+                                        float* vy,
+                                        float* vx_ordinal,
+                                        float* vy_ordinal,
+                                        bool* is_cancel) {
   *vx = 0;
   *vy = 0;
   *vx_ordinal = 0;
   *vy_ordinal = 0;
   *is_cancel = false;
 
   EventData data;
   GetEventRawData(*native_event, &data);
 
   if (data.find(DT_CMT_FLING_X) != data.end())
     *vx = data[DT_CMT_FLING_X];
   if (data.find(DT_CMT_FLING_Y) != data.end())
     *vy = data[DT_CMT_FLING_Y];
   if (data.find(DT_CMT_FLING_STATE) != data.end())
     *is_cancel = !!static_cast<unsigned int>(data[DT_CMT_FLING_STATE]);
   if (data.find(DT_CMT_ORDINAL_X) != data.end())
     *vx_ordinal = data[DT_CMT_ORDINAL_X];
   if (data.find(DT_CMT_ORDINAL_Y) != data.end())
     *vy_ordinal = data[DT_CMT_ORDINAL_Y];
 }
 
-void DeviceDataManagerX11::GetMetricsData(
-    const base::NativeEvent& native_event,
-    GestureMetricsType* type,
-    float* data1,
-    float* data2) {
+void DeviceDataManagerX11::GetMetricsData(const XEvent* native_event,
+                                          GestureMetricsType* type,
+                                          float* data1,
+                                          float* data2) {
   *type = kGestureMetricsTypeUnknown;
   *data1 = 0;
   *data2 = 0;
 
   EventData data;
   GetEventRawData(*native_event, &data);
 
   if (data.find(DT_CMT_METRICS_TYPE) != data.end()) {
     int val = static_cast<int>(data[DT_CMT_METRICS_TYPE]);
     if (val == 0)
@@ skipping 11 matching lines @@
   return button > 0 && button <= button_map_count_ ? button_map_[button - 1] :
                                                      button;
 }
 
 void DeviceDataManagerX11::UpdateButtonMap() {
   button_map_count_ = XGetPointerMapping(gfx::GetXDisplay(),
                                          button_map_,
                                          arraysize(button_map_));
 }
 
-void DeviceDataManagerX11::GetGestureTimes(
-    const base::NativeEvent& native_event,
-    double* start_time,
-    double* end_time) {
+void DeviceDataManagerX11::GetGestureTimes(const XEvent* native_event,
+                                           double* start_time,
+                                           double* end_time) {
   *start_time = 0;
   *end_time = 0;
 
   EventData data;
   GetEventRawData(*native_event, &data);
 
   if (data.find(DT_CMT_START_TIME) != data.end())
     *start_time = data[DT_CMT_START_TIME];
   if (data.find(DT_CMT_END_TIME) != data.end())
     *end_time = data[DT_CMT_END_TIME];
@@ skipping 135 matching lines @@
       blocked_keyboards_.find(deviceid);
   if (it != blocked_keyboards_.end()) {
     std::vector<KeyboardDevice> devices = keyboard_devices();
     // Add device to current list of active devices.
     devices.push_back((*it).second);
     blocked_keyboards_.erase(it);
     DeviceDataManager::OnKeyboardDevicesUpdated(devices);
   }
 }
 
-bool DeviceDataManagerX11::IsEventBlocked(
-    const base::NativeEvent& native_event) {
+bool DeviceDataManagerX11::IsEventBlocked(const XEvent* native_event) {
   // Only check XI2 events which have a source device id.
   if (native_event->type != GenericEvent)
     return false;
 
   XIDeviceEvent* xievent =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   // Allow any key events from blocked_keyboard_allowed_keys_.
   if (blocked_keyboard_allowed_keys_ &&
       (xievent->evtype == XI_KeyPress || xievent->evtype == XI_KeyRelease) &&
       blocked_keyboard_allowed_keys_->find(
@@ skipping 25 matching lines @@
     } else {
       keyboards.erase(it);
       ++blocked_iter;
     }
   }
   // Notify base class of updated list.
   DeviceDataManager::OnKeyboardDevicesUpdated(keyboards);
 }
 
 }  // namespace ui