Extract touchscreen device management into a generic manager

ui/events/x/events_x.cc

 // Copyright (c) 2012 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/event_constants.h"
 
 #include <cmath>
 #include <string.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
-#include "ui/events/x/device_data_manager.h"
+#include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/x/x11_atom_cache.h"
 #include "ui/gfx/x/x11_types.h"
 
 namespace {
@@ skipping 82 matching lines @@
   if (ui::GetTouchForce(native_event) < 1.0f)
     return false;
 
   if (ui::EventLocationFromNative(native_event) != gfx::Point())
     return false;
 
   // Radius is in pixels, and the valuator is the diameter in pixels.
   double radius = ui::GetTouchRadiusX(native_event), min, max;
   unsigned int deviceid =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid;
-  if (!ui::DeviceDataManager::GetInstance()->GetDataRange(
-      deviceid, ui::DeviceDataManager::DT_TOUCH_MAJOR, &min, &max)) {
+  if (!ui::DeviceDataManagerX11::GetInstance()->GetDataRange(
+      deviceid, ui::DeviceDataManagerX11::DT_TOUCH_MAJOR, &min, &max)) {
     return false;
   }
 
   return radius * 2 == max;
 }
 #endif
 
 int GetEventFlagsFromXState(unsigned int state) {
   int flags = 0;
   if (state & ControlMask)
@@ skipping 68 matching lines @@
     default:
       return 0;
   }
 }
 
 int GetButtonMaskForX2Event(XIDeviceEvent* xievent) {
   int buttonflags = 0;
   for (int i = 0; i < 8 * xievent->buttons.mask_len; i++) {
     if (XIMaskIsSet(xievent->buttons.mask, i)) {
       int button = (xievent->sourceid == xievent->deviceid) ?
-                   ui::DeviceDataManager::GetInstance()->GetMappedButton(i) : i;
+          ui::DeviceDataManagerX11::GetInstance()->GetMappedButton(i) : i;
       buttonflags |= GetEventFlagsForButton(button);
     }
   }
   return buttonflags;
 }
 
 ui::EventType GetTouchEventType(const base::NativeEvent& native_event) {
   XIDeviceEvent* event =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 #if defined(USE_XI2_MT)
@@ skipping 23 matching lines @@
           GetButtonMaskForX2Event(event))
         return ui::ET_TOUCH_MOVED;
       return ui::ET_UNKNOWN;
     default:
       NOTREACHED();
   }
   return ui::ET_UNKNOWN;
 }
 
 double GetTouchParamFromXEvent(XEvent* xev,
-                              ui::DeviceDataManager::DataType val,
+                              ui::DeviceDataManagerX11::DataType val,
                               double default_value) {
-  ui::DeviceDataManager::GetInstance()->GetEventData(
+  ui::DeviceDataManagerX11::GetInstance()->GetEventData(
       *xev, val, &default_value);
   return default_value;
 }
 
 }  // namespace
 
 namespace ui {
 
 void UpdateDeviceList() {
   XDisplay* display = gfx::GetXDisplay();
   DeviceListCacheX::GetInstance()->UpdateDeviceList(display);
   TouchFactory::GetInstance()->UpdateDeviceList(display);
-  DeviceDataManager::GetInstance()->UpdateDeviceList(display);
+  DeviceDataManagerX11::GetInstance()->UpdateDeviceList(display);
 }
 
 EventType EventTypeFromNative(const base::NativeEvent& native_event) {
   switch (native_event->type) {
     case KeyPress:
       return ET_KEY_PRESSED;
     case KeyRelease:
       return ET_KEY_RELEASED;
     case ButtonPress:
       if (static_cast<int>(native_event->xbutton.button) >= kMinWheelButton &&
@@ skipping 49 matching lines @@
           int button = EventButtonFromNative(native_event);
           // Drop wheel events; we should've already scrolled on the press.
           if (button >= kMinWheelButton && button <= kMaxWheelButton)
             return ET_UNKNOWN;
           return ET_MOUSE_RELEASED;
         }
         case XI_Motion: {
           bool is_cancel;
           if (GetFlingData(native_event, NULL, NULL, NULL, NULL, &is_cancel)) {
             return is_cancel ? ET_SCROLL_FLING_CANCEL : ET_SCROLL_FLING_START;
-          } else if (DeviceDataManager::GetInstance()->IsScrollEvent(
+          } else if (DeviceDataManagerX11::GetInstance()->IsScrollEvent(
               native_event)) {
             return IsTouchpadEvent(native_event) ? ET_SCROLL : ET_MOUSEWHEEL;
-          } else if (DeviceDataManager::GetInstance()->IsCMTMetricsEvent(
+          } else if (DeviceDataManagerX11::GetInstance()->IsCMTMetricsEvent(
               native_event)) {
             return ET_UMA_DATA;
           } else if (GetButtonMaskForX2Event(xievent)) {
             return ET_MOUSE_DRAGGED;
           } else {
             return ET_MOUSE_MOVED;
           }
         }
       }
     }
@@ skipping 79 matching lines @@
     case EnterNotify:
     case LeaveNotify:
       return base::TimeDelta::FromMilliseconds(native_event->xcrossing.time);
       break;
     case GenericEvent: {
       double start, end;
       double touch_timestamp;
       if (GetGestureTimes(native_event, &start, &end)) {
         // If the driver supports gesture times, use them.
         return base::TimeDelta::FromMicroseconds(end * 1000000);
-      } else if (DeviceDataManager::GetInstance()->GetEventData(*native_event,
-                 DeviceDataManager::DT_TOUCH_RAW_TIMESTAMP, &touch_timestamp)) {
+      } else if (DeviceDataManagerX11::GetInstance()->GetEventData(
+          *native_event,
+          DeviceDataManagerX11::DT_TOUCH_RAW_TIMESTAMP,
+          &touch_timestamp)) {
         return base::TimeDelta::FromMicroseconds(touch_timestamp * 1000000);
       } else {
         XIDeviceEvent* xide =
             static_cast<XIDeviceEvent*>(native_event->xcookie.data);
         return base::TimeDelta::FromMilliseconds(xide->time);
       }
       break;
     }
   }
   NOTREACHED();
@@ skipping 13 matching lines @@
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       float x = xievent->event_x;
       float y = xievent->event_y;
 #if defined(OS_CHROMEOS)
       switch (xievent->evtype) {
         case XI_TouchBegin:
         case XI_TouchUpdate:
         case XI_TouchEnd:
-          ui::DeviceDataManager::GetInstance()->ApplyTouchTransformer(
+          ui::DeviceDataManagerX11::GetInstance()->ApplyTouchTransformer(
               xievent->deviceid, &x, &y);
           break;
         default:
           break;
       }
 #endif  // defined(OS_CHROMEOS)
       return gfx::Point(static_cast<int>(x), static_cast<int>(y));
     }
   }
   return gfx::Point();
@@ skipping 26 matching lines @@
   return gfx::Point();
 }
 
 int EventButtonFromNative(const base::NativeEvent& native_event) {
   CHECK_EQ(GenericEvent, native_event->type);
   XIDeviceEvent* xievent =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   int button = xievent->detail;
 
   return (xievent->sourceid == xievent->deviceid) ?
-         DeviceDataManager::GetInstance()->GetMappedButton(button) : button;
+         DeviceDataManagerX11::GetInstance()->GetMappedButton(button) : button;
 }
 
 KeyboardCode KeyboardCodeFromNative(const base::NativeEvent& native_event) {
   return KeyboardCodeFromXKeyEvent(native_event);
 }
 
 const char* CodeFromNative(const base::NativeEvent& native_event) {
   return CodeFromXEvent(native_event);
 }
 
@@ skipping 61 matching lines @@
 
 void ReleaseCopiedNativeEvent(const base::NativeEvent& event) {
   delete event;
 }
 
 void ClearTouchIdIfReleased(const base::NativeEvent& xev) {
   ui::EventType type = ui::EventTypeFromNative(xev);
   if (type == ui::ET_TOUCH_CANCELLED ||
       type == ui::ET_TOUCH_RELEASED) {
     ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
-    ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
+    ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
     double tracking_id;
     if (manager->GetEventData(
-        *xev, ui::DeviceDataManager::DT_TOUCH_TRACKING_ID, &tracking_id)) {
+        *xev, ui::DeviceDataManagerX11::DT_TOUCH_TRACKING_ID, &tracking_id)) {
       factory->ReleaseSlotForTrackingID(tracking_id);
     }
   }
 }
 
 int GetTouchId(const base::NativeEvent& xev) {
   double slot = 0;
-  ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
+  ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
   double tracking_id;
   if (!manager->GetEventData(
-      *xev, ui::DeviceDataManager::DT_TOUCH_TRACKING_ID, &tracking_id)) {
+      *xev, ui::DeviceDataManagerX11::DT_TOUCH_TRACKING_ID, &tracking_id)) {
     LOG(ERROR) << "Could not get the tracking ID for the event. Using 0.";
   } else {
     ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
     slot = factory->GetSlotForTrackingID(tracking_id);
   }
   return slot;
 }
 
 float GetTouchRadiusX(const base::NativeEvent& native_event) {
   return GetTouchParamFromXEvent(native_event,
-      ui::DeviceDataManager::DT_TOUCH_MAJOR, 0.0) / 2.0;
+      ui::DeviceDataManagerX11::DT_TOUCH_MAJOR, 0.0) / 2.0;
 }
 
 float GetTouchRadiusY(const base::NativeEvent& native_event) {
   return GetTouchParamFromXEvent(native_event,
-      ui::DeviceDataManager::DT_TOUCH_MINOR, 0.0) / 2.0;
+      ui::DeviceDataManagerX11::DT_TOUCH_MINOR, 0.0) / 2.0;
 }
 
 float GetTouchAngle(const base::NativeEvent& native_event) {
   return GetTouchParamFromXEvent(native_event,
-      ui::DeviceDataManager::DT_TOUCH_ORIENTATION, 0.0) / 2.0;
+      ui::DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.0) / 2.0;
 }
 
 float GetTouchForce(const base::NativeEvent& native_event) {
   double force = 0.0;
   force = GetTouchParamFromXEvent(native_event,
-      ui::DeviceDataManager::DT_TOUCH_PRESSURE, 0.0);
+      ui::DeviceDataManagerX11::DT_TOUCH_PRESSURE, 0.0);
   unsigned int deviceid =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid;
   // Force is normalized to fall into [0, 1]
-  if (!ui::DeviceDataManager::GetInstance()->NormalizeData(
-      deviceid, ui::DeviceDataManager::DT_TOUCH_PRESSURE, &force))
+  if (!ui::DeviceDataManagerX11::GetInstance()->NormalizeData(
+      deviceid, ui::DeviceDataManagerX11::DT_TOUCH_PRESSURE, &force))
     force = 0.0;
   return force;
 }
 
 bool GetScrollOffsets(const base::NativeEvent& native_event,
                       float* x_offset,
                       float* y_offset,
                       float* x_offset_ordinal,
                       float* y_offset_ordinal,
                       int* finger_count) {
-  if (!DeviceDataManager::GetInstance()->IsScrollEvent(native_event))
+  if (!DeviceDataManagerX11::GetInstance()->IsScrollEvent(native_event))
     return false;
 
   // Temp values to prevent passing NULLs to DeviceDataManager.
   float x_offset_, y_offset_;
   float x_offset_ordinal_, y_offset_ordinal_;
   int finger_count_;
   if (!x_offset)
     x_offset = &x_offset_;
   if (!y_offset)
     y_offset = &y_offset_;
   if (!x_offset_ordinal)
     x_offset_ordinal = &x_offset_ordinal_;
   if (!y_offset_ordinal)
     y_offset_ordinal = &y_offset_ordinal_;
   if (!finger_count)
     finger_count = &finger_count_;
 
-  DeviceDataManager::GetInstance()->GetScrollOffsets(
+  DeviceDataManagerX11::GetInstance()->GetScrollOffsets(
       native_event,
       x_offset, y_offset,
       x_offset_ordinal, y_offset_ordinal,
       finger_count);
   return true;
 }
 
 bool GetFlingData(const base::NativeEvent& native_event,
                   float* vx,
                   float* vy,
                   float* vx_ordinal,
                   float* vy_ordinal,
                   bool* is_cancel) {
-  if (!DeviceDataManager::GetInstance()->IsFlingEvent(native_event))
+  if (!DeviceDataManagerX11::GetInstance()->IsFlingEvent(native_event))
     return false;
 
   float vx_, vy_;
   float vx_ordinal_, vy_ordinal_;
   bool is_cancel_;
   if (!vx)
     vx = &vx_;
   if (!vy)
     vy = &vy_;
   if (!vx_ordinal)
     vx_ordinal = &vx_ordinal_;
   if (!vy_ordinal)
     vy_ordinal = &vy_ordinal_;
   if (!is_cancel)
     is_cancel = &is_cancel_;
 
-  DeviceDataManager::GetInstance()->GetFlingData(
+  DeviceDataManagerX11::GetInstance()->GetFlingData(
       native_event, vx, vy, vx_ordinal, vy_ordinal, is_cancel);
   return true;
 }
 
 bool GetGestureTimes(const base::NativeEvent& native_event,
                      double* start_time,
                      double* end_time) {
-  if (!DeviceDataManager::GetInstance()->HasGestureTimes(native_event))
+  if (!DeviceDataManagerX11::GetInstance()->HasGestureTimes(native_event))
     return false;
 
   double start_time_, end_time_;
   if (!start_time)
     start_time = &start_time_;
   if (!end_time)
     end_time = &end_time_;
 
-  DeviceDataManager::GetInstance()->GetGestureTimes(
+  DeviceDataManagerX11::GetInstance()->GetGestureTimes(
       native_event, start_time, end_time);
   return true;
 }
 
 bool IsTouchpadEvent(const base::NativeEvent& event) {
-  return DeviceDataManager::GetInstance()->IsTouchpadXInputEvent(event);
+  return DeviceDataManagerX11::GetInstance()->IsTouchpadXInputEvent(event);
 }
 
 }  // namespace ui