Extract touchscreen device management into a generic manager

ui/events/x/events_x_unittest.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 <cstring>
 
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/XKBlib.h>
 
 // Generically-named #defines from Xlib that conflict with symbols in GTest.
 #undef Bool
 #undef None
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/events_test_utils_x11.h"
+#include "ui/events/x/device_data_manager_x11.h"
 #include "ui/gfx/point.h"
 
 namespace ui {
 
 namespace {
 
 // Initializes the passed-in Xlib event.
 void InitButtonEvent(XEvent* event,
                      bool is_press,
                      const gfx::Point& location,
@@ skipping 37 matching lines @@
   if (x_keycode) {
     InitKeyEvent(display, &event, true, x_keycode, 0);
     ui::KeyEvent ui_key_event(&event, false);
     return (ui_key_event.flags() & ui::EF_FUNCTION_KEY);
   }
   return true;
 }
 
 }  // namespace
 
-TEST(EventsXTest, ButtonEvents) {
+class EventsXTest : public testing::Test {
+ public:
+  EventsXTest() {}
+  virtual ~EventsXTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    DeviceDataManagerX11::CreateInstance();
+  }
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EventsXTest);
+};
+
+TEST_F(EventsXTest, ButtonEvents) {
   XEvent event;
   gfx::Point location(5, 10);
   gfx::Vector2d offset;
 
   InitButtonEvent(&event, true, location, 1, 0);
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, ui::EventTypeFromNative(&event));
   EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, ui::EventFlagsFromNative(&event));
   EXPECT_EQ(location, ui::EventLocationFromNative(&event));
 
   InitButtonEvent(&event, true, location, 2, Button1Mask | ShiftMask);
@@ skipping 40 matching lines @@
   EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event));
   EXPECT_EQ(0, ui::EventFlagsFromNative(&event));
   EXPECT_EQ(location, ui::EventLocationFromNative(&event));
   offset = ui::GetMouseWheelOffset(&event);
   EXPECT_EQ(0, offset.y());
   EXPECT_LT(offset.x(), 0);
 
   // TODO(derat): Test XInput code.
 }
 
-TEST(EventsXTest, AvoidExtraEventsOnWheelRelease) {
+TEST_F(EventsXTest, AvoidExtraEventsOnWheelRelease) {
   XEvent event;
   gfx::Point location(5, 10);
 
   InitButtonEvent(&event, true, location, 4, 0);
   EXPECT_EQ(ui::ET_MOUSEWHEEL, ui::EventTypeFromNative(&event));
 
   // We should return ET_UNKNOWN for the release event instead of returning
   // ET_MOUSEWHEEL; otherwise we'll scroll twice for each scrollwheel step.
   InitButtonEvent(&event, false, location, 4, 0);
   EXPECT_EQ(ui::ET_UNKNOWN, ui::EventTypeFromNative(&event));
 
   // TODO(derat): Test XInput code.
 }
 
-TEST(EventsXTest, EnterLeaveEvent) {
+TEST_F(EventsXTest, EnterLeaveEvent) {
   XEvent event;
   event.xcrossing.type = EnterNotify;
   event.xcrossing.x = 10;
   event.xcrossing.y = 20;
   event.xcrossing.x_root = 110;
   event.xcrossing.y_root = 120;
 
   // Mouse enter events are converted to mouse move events to be consistent with
   // the way views handle mouse enter. See comments for EnterNotify case in
   // ui::EventTypeFromNative for more details.
   EXPECT_EQ(ui::ET_MOUSE_MOVED, ui::EventTypeFromNative(&event));
   EXPECT_EQ("10,20", ui::EventLocationFromNative(&event).ToString());
   EXPECT_EQ("110,120", ui::EventSystemLocationFromNative(&event).ToString());
 
   event.xcrossing.type = LeaveNotify;
   event.xcrossing.x = 30;
   event.xcrossing.y = 40;
   event.xcrossing.x_root = 230;
   event.xcrossing.y_root = 240;
   EXPECT_EQ(ui::ET_MOUSE_EXITED, ui::EventTypeFromNative(&event));
   EXPECT_EQ("30,40", ui::EventLocationFromNative(&event).ToString());
   EXPECT_EQ("230,240", ui::EventSystemLocationFromNative(&event).ToString());
 }
 
-TEST(EventsXTest, ClickCount) {
+TEST_F(EventsXTest, ClickCount) {
   XEvent event;
   gfx::Point location(5, 10);
 
   for (int i = 1; i <= 3; ++i) {
     InitButtonEvent(&event, true, location, 1, 0);
     {
       MouseEvent mouseev(&event);
       EXPECT_EQ(ui::ET_MOUSE_PRESSED, mouseev.type());
       EXPECT_EQ(i, mouseev.GetClickCount());
     }
 
     InitButtonEvent(&event, false, location, 1, 0);
     {
       MouseEvent mouseev(&event);
       EXPECT_EQ(ui::ET_MOUSE_RELEASED, mouseev.type());
       EXPECT_EQ(i, mouseev.GetClickCount());
     }
   }
 }
 
 #if defined(USE_XI2_MT)
-TEST(EventsXTest, TouchEventBasic) {
+TEST_F(EventsXTest, TouchEventBasic) {
   std::vector<unsigned int> devices;
   devices.push_back(0);
   ui::SetUpTouchDevicesForTest(devices);
   std::vector<Valuator> valuators;
 
   // Init touch begin with tracking id 5, touch id 0.
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_MAJOR, 20));
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_ORIENTATION, 0.3f));
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_PRESSURE, 100));
+  valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 20));
+  valuators.push_back(
+      Valuator(DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.3f));
+  valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 100));
   ui::ScopedXI2Event scoped_xevent;
   scoped_xevent.InitTouchEvent(
       0, XI_TouchBegin, 5, gfx::Point(10, 10), valuators);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent));
   EXPECT_EQ("10,10", ui::EventLocationFromNative(scoped_xevent).ToString());
   EXPECT_EQ(GetTouchId(scoped_xevent), 0);
   EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
   EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.15f);
   EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f);
 
   // Touch update, with new orientation info.
   valuators.clear();
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_ORIENTATION, 0.5f));
+  valuators.push_back(
+      Valuator(DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.5f));
   scoped_xevent.InitTouchEvent(
       0, XI_TouchUpdate, 5, gfx::Point(20, 20), valuators);
   EXPECT_EQ(ui::ET_TOUCH_MOVED, ui::EventTypeFromNative(scoped_xevent));
   EXPECT_EQ("20,20", ui::EventLocationFromNative(scoped_xevent).ToString());
   EXPECT_EQ(GetTouchId(scoped_xevent), 0);
   EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
   EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f);
   EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.1f);
 
   // Another touch with tracking id 6, touch id 1.
   valuators.clear();
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_MAJOR, 100));
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_ORIENTATION, 0.9f));
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_PRESSURE, 500));
+  valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 100));
+  valuators.push_back(Valuator(
+      DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.9f));
+  valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 500));
   scoped_xevent.InitTouchEvent(
       0, XI_TouchBegin, 6, gfx::Point(200, 200), valuators);
   EXPECT_EQ(ui::ET_TOUCH_PRESSED, ui::EventTypeFromNative(scoped_xevent));
   EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString());
   EXPECT_EQ(GetTouchId(scoped_xevent), 1);
   EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 50);
   EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f);
   EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f);
 
   // Touch with tracking id 5 should have old radius/angle value and new pressue
   // value.
   valuators.clear();
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_PRESSURE, 50));
+  valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_PRESSURE, 50));
   scoped_xevent.InitTouchEvent(
       0, XI_TouchEnd, 5, gfx::Point(30, 30), valuators);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent));
   EXPECT_EQ("30,30", ui::EventLocationFromNative(scoped_xevent).ToString());
   EXPECT_EQ(GetTouchId(scoped_xevent), 0);
   EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 10);
   EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.25f);
   EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.05f);
 
   // Touch with tracking id 6 should have old angle/pressure value and new
   // radius value.
   valuators.clear();
-  valuators.push_back(Valuator(DeviceDataManager::DT_TOUCH_MAJOR, 50));
+  valuators.push_back(Valuator(DeviceDataManagerX11::DT_TOUCH_MAJOR, 50));
   scoped_xevent.InitTouchEvent(
       0, XI_TouchEnd, 6, gfx::Point(200, 200), valuators);
   EXPECT_EQ(ui::ET_TOUCH_RELEASED, ui::EventTypeFromNative(scoped_xevent));
   EXPECT_EQ("200,200", ui::EventLocationFromNative(scoped_xevent).ToString());
   EXPECT_EQ(GetTouchId(scoped_xevent), 1);
   EXPECT_EQ(GetTouchRadiusX(scoped_xevent), 25);
   EXPECT_FLOAT_EQ(GetTouchAngle(scoped_xevent), 0.45f);
   EXPECT_FLOAT_EQ(GetTouchForce(scoped_xevent), 0.5f);
 }
 #endif
 
-TEST(EventsXTest, NumpadKeyEvents) {
+TEST_F(EventsXTest, NumpadKeyEvents) {
   XEvent event;
   Display* display = gfx::GetXDisplay();
 
   struct {
     bool is_numpad_key;
     int x_keysym;
   } keys[] = {
     // XK_KP_Space and XK_KP_Equal are the extrema in the conventional
     // keysymdef.h numbering.
     { true,  XK_KP_Space },
@@ skipping 90 matching lines @@
       InitKeyEvent(display, &event, true, x_keycode, 0);
       // int keysym = XLookupKeysym(&event.xkey, 0);
       // if (keysym) {
       ui::KeyEvent ui_key_event(&event, false);
       EXPECT_EQ(keys[k].is_numpad_key ? ui::EF_NUMPAD_KEY : 0,
                 ui_key_event.flags() & ui::EF_NUMPAD_KEY);
     }
   }
 }
 
-TEST(EventsXTest, FunctionKeyEvents) {
+TEST_F(EventsXTest, FunctionKeyEvents) {
   Display* display = gfx::GetXDisplay();
 
   // Min  function key code minus 1.
   EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F1 - 1));
   // All function keys.
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F1));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F2));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F3));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F4));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F5));
@@ skipping 25 matching lines @@
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F31));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F32));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F33));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F34));
   EXPECT_TRUE(HasFunctionKeyFlagSetIfSupported(display, XK_F35));
   // Max function key code plus 1.
   EXPECT_FALSE(HasFunctionKeyFlagSetIfSupported(display, XK_F35 + 1));
 }
 
 #if !defined(OS_CHROMEOS)
-TEST(EventsXTest, ImeFabricatedKeyEvents) {
+TEST_F(EventsXTest, ImeFabricatedKeyEvents) {
   Display* display = gfx::GetXDisplay();
 
   unsigned int state_to_be_fabricated[] = {
     0, ShiftMask, LockMask, ShiftMask | LockMask,
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(state_to_be_fabricated); ++i) {
     unsigned int state = state_to_be_fabricated[i];
     for (int is_char = 0; is_char < 2; ++is_char) {
       XEvent x_event;
       InitKeyEvent(display, &x_event, true, 0, state);
@@ skipping 11 matching lines @@
       XEvent x_event;
       InitKeyEvent(display, &x_event, true, 0, state);
       ui::KeyEvent key_event(&x_event, is_char);
       EXPECT_FALSE(key_event.flags() & ui::EF_IME_FABRICATED_KEY);
     }
   }
 }
 #endif
 
 }  // namespace ui