Ozone X11 platform

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 "ui/events/x/events_x.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 <X11/XKBlib.h>
 
 #include "base/logging.h"
@@ skipping 36 matching lines @@
         return ShiftMask;
       case ui::VKEY_MENU:
         return Mod1Mask;
       case ui::VKEY_CAPITAL:
         return LockMask;
       default:
         return 0;
     }
   }
 
-  void UpdateStateFromXEvent(const base::NativeEvent& native_event) {
+  void UpdateStateFromXEvent(const XEvent* native_event) {
     ui::KeyboardCode keyboard_code = ui::KeyboardCodeFromNative(native_event);
     unsigned int mask = StateFromKeyboardCode(keyboard_code);
     // Floating device can't access the modifer state from master device.
     // We need to track the states of modifier keys in a singleton for
     // floating devices such as touch screen. Issue 106426 is one example
     // of why we need the modifier states for floating device.
     switch (native_event->type) {
       case KeyPress:
         state_ = native_event->xkey.state | mask;
         break;
@@ skipping 33 matching lines @@
 
   unsigned int state_;
 
   DISALLOW_COPY_AND_ASSIGN(XModifierStateWatcher);
 };
 
 // Detects if a touch event is a driver-generated 'special event'.
 // A 'special event' is a touch event with maximum radius and pressure at
 // location (0, 0).
 // This needs to be done in a cleaner way: http://crbug.com/169256
-bool TouchEventIsGeneratedHack(const base::NativeEvent& native_event) {
+bool TouchEventIsGeneratedHack(const XEvent* native_event) {
   XIDeviceEvent* event =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   CHECK(event->evtype == XI_TouchBegin ||
         event->evtype == XI_TouchUpdate ||
         event->evtype == XI_TouchEnd);
 
   // Force is normalized to [0, 1].
   if (ui::GetTouchForce(native_event) < 1.0f)
     return false;
 
@@ skipping 30 matching lines @@
     flags |= ui::EF_ALTGR_DOWN;
   if (state & Button1Mask)
     flags |= ui::EF_LEFT_MOUSE_BUTTON;
   if (state & Button2Mask)
     flags |= ui::EF_MIDDLE_MOUSE_BUTTON;
   if (state & Button3Mask)
     flags |= ui::EF_RIGHT_MOUSE_BUTTON;
   return flags;
 }
 
-int GetEventFlagsFromXKeyEvent(XEvent* xevent) {
+int GetEventFlagsFromXKeyEvent(const XEvent* xevent) {
   DCHECK(xevent->type == KeyPress || xevent->type == KeyRelease);
 
 #if defined(OS_CHROMEOS)
   const int ime_fabricated_flag = 0;
 #else
   // XIM fabricates key events for the character compositions by XK_Multi_key.
   // For example, when a user hits XK_Multi_key, XK_apostrophe, and XK_e in
   // order to input "é", then XIM generates a key event with keycode=0 and
   // state=0 for the composition, and the sequence of X11 key events will be
   // XK_Multi_key, XK_apostrophe, **NoSymbol**, and XK_e.  If the user used
   // shift key and/or caps lock key, state can be ShiftMask, LockMask or both.
   //
   // We have to send these fabricated key events to XIM so it can correctly
   // handle the character compositions.
   const unsigned int shift_lock_mask = ShiftMask | LockMask;
   const bool fabricated_by_xim =
       xevent->xkey.keycode == 0 &&
       (xevent->xkey.state & ~shift_lock_mask) == 0;
   const int ime_fabricated_flag =
       fabricated_by_xim ? ui::EF_IME_FABRICATED_KEY : 0;
 #endif
 
+  KeySym key = XLookupKeysym(const_cast<XKeyEvent*>(&xevent->xkey), 0);
+
   return GetEventFlagsFromXState(xevent->xkey.state) |
-      (xevent->xkey.send_event ? ui::EF_FINAL : 0) |
-      (IsKeypadKey(XLookupKeysym(&xevent->xkey, 0)) ? ui::EF_NUMPAD_KEY : 0) |
-      (IsFunctionKey(XLookupKeysym(&xevent->xkey, 0)) ?
-          ui::EF_FUNCTION_KEY : 0) |
-      ime_fabricated_flag;
+         (xevent->xkey.send_event ? ui::EF_FINAL : 0) |
+         (IsKeypadKey(key) ? ui::EF_NUMPAD_KEY : 0) |
+         (IsFunctionKey(key) ? ui::EF_FUNCTION_KEY : 0) | ime_fabricated_flag;
 }
 
-int GetEventFlagsFromXGenericEvent(XEvent* xevent) {
+int GetEventFlagsFromXGenericEvent(const XEvent* xevent) {
   DCHECK(xevent->type == GenericEvent);
-  XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xevent->xcookie.data);
+  const XIDeviceEvent* xievent =
+      static_cast<const XIDeviceEvent*>(xevent->xcookie.data);
   DCHECK((xievent->evtype == XI_KeyPress) ||
          (xievent->evtype == XI_KeyRelease));
   return GetEventFlagsFromXState(xievent->mods.effective) |
          (xevent->xkey.send_event ? ui::EF_FINAL : 0) |
          (IsKeypadKey(
               XkbKeycodeToKeysym(xievent->display, xievent->detail, 0, 0))
               ? ui::EF_NUMPAD_KEY
               : 0);
 }
 
@@ skipping 23 matching lines @@
   for (int i = 0; i < 8 * xievent->buttons.mask_len; i++) {
     if (XIMaskIsSet(xievent->buttons.mask, i)) {
       int button = (xievent->sourceid == xievent->deviceid) ?
           ui::DeviceDataManagerX11::GetInstance()->GetMappedButton(i) : i;
       buttonflags |= GetEventFlagsForButton(button);
     }
   }
   return buttonflags;
 }
 
-ui::EventType GetTouchEventType(const base::NativeEvent& native_event) {
+ui::EventType GetTouchEventType(const XEvent* native_event) {
   XIDeviceEvent* event =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
   switch(event->evtype) {
     case XI_TouchBegin:
       return TouchEventIsGeneratedHack(native_event) ? ui::ET_UNKNOWN :
                                                        ui::ET_TOUCH_PRESSED;
     case XI_TouchUpdate:
       return TouchEventIsGeneratedHack(native_event) ? ui::ET_UNKNOWN :
                                                        ui::ET_TOUCH_MOVED;
     case XI_TouchEnd:
@@ skipping 13 matching lines @@
       if (!(event->flags & XIPointerEmulated) &&
           GetButtonMaskForX2Event(event))
         return ui::ET_TOUCH_MOVED;
       return ui::ET_UNKNOWN;
     default:
       NOTREACHED();
   }
   return ui::ET_UNKNOWN;
 }
 
-double GetTouchParamFromXEvent(XEvent* xev,
-                              ui::DeviceDataManagerX11::DataType val,
-                              double default_value) {
+double GetTouchParamFromXEvent(const XEvent* xev,
+                               ui::DeviceDataManagerX11::DataType val,
+                               double default_value) {
   ui::DeviceDataManagerX11::GetInstance()->GetEventData(
       *xev, val, &default_value);
   return default_value;
 }
 
-void ScaleTouchRadius(XEvent* xev, double* radius) {
+void ScaleTouchRadius(const XEvent* xev, double* radius) {
   DCHECK_EQ(GenericEvent, xev->type);
   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
   ui::DeviceDataManagerX11::GetInstance()->ApplyTouchRadiusScale(
       xiev->sourceid, radius);
 }
 
+#if defined(USE_X11)
 unsigned int UpdateX11EventFlags(int ui_flags, unsigned int old_x_flags) {
   static struct {
     int ui;
     int x;
   } flags[] = {
     {ui::EF_CONTROL_DOWN, ControlMask},
     {ui::EF_SHIFT_DOWN, ShiftMask},
     {ui::EF_ALT_DOWN, Mod1Mask},
     {ui::EF_CAPS_LOCK_DOWN, LockMask},
     {ui::EF_ALTGR_DOWN, Mod5Mask},
@@ skipping 20 matching lines @@
       return Button1;
     case ui::EF_MIDDLE_MOUSE_BUTTON:
       return Button2;
     case ui::EF_RIGHT_MOUSE_BUTTON:
       return Button3;
     default:
       return old_x_button;
   }
   NOTREACHED();
 }
+#endif
 
-bool GetGestureTimes(const base::NativeEvent& native_event,
+bool GetGestureTimes(const XEvent* native_event,
                      double* start_time,
                      double* end_time) {
   if (!ui::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_;
 
   ui::DeviceDataManagerX11::GetInstance()->GetGestureTimes(
       native_event, start_time, end_time);
   return true;
 }
 
 }  // namespace
 
 namespace ui {
 
 void UpdateDeviceList() {
   XDisplay* display = gfx::GetXDisplay();
   DeviceListCacheX11::GetInstance()->UpdateDeviceList(display);
   TouchFactory::GetInstance()->UpdateDeviceList(display);
   DeviceDataManagerX11::GetInstance()->UpdateDeviceList(display);
 }
 
-EventType EventTypeFromNative(const base::NativeEvent& native_event) {
+EventType EventTypeFromNative(const XEvent* native_event) {
   // Allow the DeviceDataManager to block the event. If blocked return
   // ET_UNKNOWN as the type so this event will not be further processed.
   // NOTE: During some events unittests there is no device data manager.
   if (DeviceDataManager::HasInstance() &&
       static_cast<DeviceDataManagerX11*>(DeviceDataManager::GetInstance())->
           IsEventBlocked(native_event)) {
     return ET_UNKNOWN;
   }
 
   switch (native_event->type) {
@@ skipping 78 matching lines @@
         case XI_KeyRelease:
           return ET_KEY_RELEASED;
       }
     }
     default:
       break;
   }
   return ET_UNKNOWN;
 }
 
-int EventFlagsFromNative(const base::NativeEvent& native_event) {
+int EventFlagsFromNative(const XEvent* native_event) {
   switch (native_event->type) {
     case KeyPress:
     case KeyRelease: {
       XModifierStateWatcher::GetInstance()->UpdateStateFromXEvent(native_event);
       return GetEventFlagsFromXKeyEvent(native_event);
     }
     case ButtonPress:
     case ButtonRelease: {
       int flags = GetEventFlagsFromXState(native_event->xbutton.state);
       const EventType type = EventTypeFromNative(native_event);
@@ skipping 44 matching lines @@
           XModifierStateWatcher::GetInstance()->UpdateStateFromXEvent(
               native_event);
           return GetEventFlagsFromXGenericEvent(native_event);
         }
       }
     }
   }
   return 0;
 }
 
-base::TimeDelta EventTimeFromNative(const base::NativeEvent& native_event) {
+base::TimeDelta EventTimeFromNative(const XEvent* native_event) {
   switch(native_event->type) {
     case KeyPress:
     case KeyRelease:
       return base::TimeDelta::FromMilliseconds(native_event->xkey.time);
     case ButtonPress:
     case ButtonRelease:
       return base::TimeDelta::FromMilliseconds(native_event->xbutton.time);
       break;
     case MotionNotify:
       return base::TimeDelta::FromMilliseconds(native_event->xmotion.time);
@@ skipping 18 matching lines @@
             static_cast<XIDeviceEvent*>(native_event->xcookie.data);
         return base::TimeDelta::FromMilliseconds(xide->time);
       }
       break;
     }
   }
   NOTREACHED();
   return base::TimeDelta();
 }
 
-gfx::Point EventLocationFromNative(const base::NativeEvent& native_event) {
+gfx::Point EventLocationFromNative(const XEvent* native_event) {
   switch (native_event->type) {
     case EnterNotify:
     case LeaveNotify:
       return gfx::Point(native_event->xcrossing.x, native_event->xcrossing.y);
     case ButtonPress:
     case ButtonRelease:
       return gfx::Point(native_event->xbutton.x, native_event->xbutton.y);
     case MotionNotify:
       return gfx::Point(native_event->xmotion.x, native_event->xmotion.y);
     case GenericEvent: {
@@ skipping 12 matching lines @@
         default:
           break;
       }
 #endif  // defined(OS_CHROMEOS)
       return gfx::Point(static_cast<int>(x), static_cast<int>(y));
     }
   }
   return gfx::Point();
 }
 
-gfx::Point EventSystemLocationFromNative(
-    const base::NativeEvent& native_event) {
+gfx::Point EventSystemLocationFromNative(const XEvent* native_event) {
   switch (native_event->type) {
     case EnterNotify:
     case LeaveNotify: {
       return gfx::Point(native_event->xcrossing.x_root,
                         native_event->xcrossing.y_root);
     }
     case ButtonPress:
     case ButtonRelease: {
       return gfx::Point(native_event->xbutton.x_root,
                         native_event->xbutton.y_root);
     }
     case MotionNotify: {
       return gfx::Point(native_event->xmotion.x_root,
                         native_event->xmotion.y_root);
     }
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       return gfx::Point(xievent->root_x, xievent->root_y);
     }
   }
 
   return gfx::Point();
 }
 
-int EventButtonFromNative(const base::NativeEvent& native_event) {
+int EventButtonFromNative(const XEvent* 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) ?
          DeviceDataManagerX11::GetInstance()->GetMappedButton(button) : button;
 }
 
-KeyboardCode KeyboardCodeFromNative(const base::NativeEvent& native_event) {
+KeyboardCode KeyboardCodeFromNative(const XEvent* native_event) {
   return KeyboardCodeFromXKeyEvent(native_event);
 }
 
-const char* CodeFromNative(const base::NativeEvent& native_event) {
+const char* CodeFromNative(const XEvent* native_event) {
   return CodeFromXEvent(native_event);
 }
 
-uint32 PlatformKeycodeFromNative(const base::NativeEvent& native_event) {
-  XKeyEvent* xkey = NULL;
+uint32 PlatformKeycodeFromNative(const XEvent* native_event) {
+  const XKeyEvent* xkey = NULL;
   XEvent xkey_from_xi2;
   switch (native_event->type) {
     case KeyPress:
     case KeyRelease:
       xkey = &native_event->xkey;
       break;
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       switch (xievent->evtype) {
         case XI_KeyPress:
         case XI_KeyRelease:
           // Build an XKeyEvent corresponding to the XI2 event,
           // so that we can call XLookupString on it.
           InitXKeyEventFromXIDeviceEvent(*native_event, &xkey_from_xi2);
           xkey = &xkey_from_xi2.xkey;
           break;
         default:
           NOTREACHED();
           break;
       }
       break;
     }
     default:
       NOTREACHED();
       break;
   }
   KeySym keysym = XK_VoidSymbol;
   if (xkey)
-    XLookupString(xkey, NULL, 0, &keysym, NULL);
+    XLookupString(const_cast<XKeyEvent*>(xkey), NULL, 0, &keysym, NULL);
   return keysym;
 }
 
-bool IsCharFromNative(const base::NativeEvent& native_event) {
+bool IsCharFromNative(const XEvent* native_event) {
   return false;
 }
 
-int GetChangedMouseButtonFlagsFromNative(
-    const base::NativeEvent& native_event) {
+int GetChangedMouseButtonFlagsFromNative(const XEvent* native_event) {
   switch (native_event->type) {
     case ButtonPress:
     case ButtonRelease:
       return GetEventFlagsFromXState(native_event->xbutton.state);
     case GenericEvent: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       switch (xievent->evtype) {
         case XI_ButtonPress:
         case XI_ButtonRelease:
           return GetEventFlagsForButton(EventButtonFromNative(native_event));
         default:
           break;
       }
     }
     default:
       break;
   }
   return 0;
 }
 
-gfx::Vector2d GetMouseWheelOffset(const base::NativeEvent& native_event) {
+gfx::Vector2d GetMouseWheelOffset(const XEvent* native_event) {
   float x_offset, y_offset;
   if (GetScrollOffsets(
       native_event, &x_offset, &y_offset, NULL, NULL, NULL)) {
     return gfx::Vector2d(static_cast<int>(x_offset),
                          static_cast<int>(y_offset));
   }
 
   int button = native_event->type == GenericEvent ?
       EventButtonFromNative(native_event) : native_event->xbutton.button;
 
   switch (button) {
     case 4:
       return gfx::Vector2d(0, kWheelScrollAmount);
     case 5:
       return gfx::Vector2d(0, -kWheelScrollAmount);
     case 6:
       return gfx::Vector2d(kWheelScrollAmount, 0);
     case 7:
       return gfx::Vector2d(-kWheelScrollAmount, 0);
     default:
       return gfx::Vector2d();
   }
 }
 
-base::NativeEvent CopyNativeEvent(const base::NativeEvent& event) {
+XEvent* CopyNativeEvent(const XEvent* event) {
   if (!event || event->type == GenericEvent)
     return NULL;
   XEvent* copy = new XEvent;
   *copy = *event;
   return copy;
 }
 
-void ReleaseCopiedNativeEvent(const base::NativeEvent& event) {
+void ReleaseCopiedNativeEvent(const XEvent* event) {
   delete event;
 }
 
-void IncrementTouchIdRefCount(const base::NativeEvent& xev) {
+void IncrementTouchIdRefCount(const XEvent* xev) {
   ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
   double tracking_id;
   if (!manager->GetEventData(
           *xev, ui::DeviceDataManagerX11::DT_TOUCH_TRACKING_ID, &tracking_id)) {
     return;
   }
 
   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
   factory->AcquireSlotForTrackingID(tracking_id);
 }
 
-void ClearTouchIdIfReleased(const base::NativeEvent& xev) {
+void ClearTouchIdIfReleased(const XEvent* 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::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
     double tracking_id;
     if (manager->GetEventData(
         *xev, ui::DeviceDataManagerX11::DT_TOUCH_TRACKING_ID, &tracking_id)) {
       factory->ReleaseSlotForTrackingID(tracking_id);
     }
   }
 }
 
-int GetTouchId(const base::NativeEvent& xev) {
+int GetTouchId(const XEvent* xev) {
   double slot = 0;
   ui::DeviceDataManagerX11* manager = ui::DeviceDataManagerX11::GetInstance();
   double tracking_id;
   if (!manager->GetEventData(
       *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) {
+float GetTouchRadiusX(const XEvent* native_event) {
   double radius = GetTouchParamFromXEvent(native_event,
       ui::DeviceDataManagerX11::DT_TOUCH_MAJOR, 0.0) / 2.0;
   ScaleTouchRadius(native_event, &radius);
   return radius;
 }
 
-float GetTouchRadiusY(const base::NativeEvent& native_event) {
+float GetTouchRadiusY(const XEvent* native_event) {
   double radius = GetTouchParamFromXEvent(native_event,
       ui::DeviceDataManagerX11::DT_TOUCH_MINOR, 0.0) / 2.0;
   ScaleTouchRadius(native_event, &radius);
   return radius;
 }
 
-float GetTouchAngle(const base::NativeEvent& native_event) {
+float GetTouchAngle(const XEvent* native_event) {
   return GetTouchParamFromXEvent(native_event,
       ui::DeviceDataManagerX11::DT_TOUCH_ORIENTATION, 0.0) / 2.0;
 }
 
-float GetTouchForce(const base::NativeEvent& native_event) {
+float GetTouchForce(const XEvent* native_event) {
   double force = 0.0;
   force = GetTouchParamFromXEvent(native_event,
       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::DeviceDataManagerX11::GetInstance()->NormalizeData(
       deviceid, ui::DeviceDataManagerX11::DT_TOUCH_PRESSURE, &force))
     force = 0.0;
   return force;
 }
 
-bool GetScrollOffsets(const base::NativeEvent& native_event,
+bool GetScrollOffsets(const XEvent* native_event,
                       float* x_offset,
                       float* y_offset,
                       float* x_offset_ordinal,
                       float* y_offset_ordinal,
                       int* finger_count) {
   if (!DeviceDataManagerX11::GetInstance()->IsScrollEvent(native_event))
     return false;
 
   // Temp values to prevent passing NULLs to DeviceDataManager.
   float x_offset_, y_offset_;
@@ skipping 11 matching lines @@
     finger_count = &finger_count_;
 
   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,
+bool GetFlingData(const XEvent* native_event,
                   float* vx,
                   float* vy,
                   float* vx_ordinal,
                   float* vy_ordinal,
                   bool* is_cancel) {
   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_;
 
   DeviceDataManagerX11::GetInstance()->GetFlingData(
       native_event, vx, vy, vx_ordinal, vy_ordinal, is_cancel);
   return true;
 }
 
+#if defined(USE_X11)
 void UpdateX11EventForFlags(Event* event) {
   XEvent* xev = event->native_event();
   if (!xev)
     return;
   switch (xev->type) {
     case KeyPress:
     case KeyRelease:
       xev->xkey.state = UpdateX11EventFlags(event->flags(), xev->xkey.state);
       break;
     case ButtonPress:
@@ skipping 28 matching lines @@
       CHECK(xievent && (xievent->evtype == XI_ButtonPress ||
                         xievent->evtype == XI_ButtonRelease));
       xievent->detail =
           UpdateX11EventButton(event->changed_button_flags(), xievent->detail);
       break;
     }
     default:
       break;
   }
 }
+#endif
+
+#if defined(USE_OZONE) && !defined(USE_X11)
+
+base::NativeEvent TranslateXI2Event(XEvent* xev) {
+  XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
+  EventType event_type = EventTypeFromNative(xev);
+  gfx::PointF location = gfx::PointF(xievent->event_x, xievent->event_y);
+  gfx::PointF root_location = gfx::PointF(xievent->root_x, xievent->root_y);
+  int flags = EventFlagsFromNative(xev);
+  switch (event_type) {
+    case ET_KEY_PRESSED:
+    case ET_KEY_RELEASED:
+      return new KeyEvent(event_type, KeyboardCodeFromNative(xev), flags);
+    case ET_MOUSE_PRESSED:
+    case ET_MOUSE_MOVED:
+    case ET_MOUSE_DRAGGED:
+    case ET_MOUSE_RELEASED:
+      return new MouseEvent(event_type, location, root_location, flags,
+                            GetChangedMouseButtonFlagsFromNative(xev));
+    case ET_MOUSEWHEEL:
+      return new MouseWheelEvent(GetMouseWheelOffset(xev), location,
+                                 root_location, flags,
+                                 GetChangedMouseButtonFlagsFromNative(xev));
+    case ET_SCROLL_FLING_START:
+    case ET_SCROLL_FLING_CANCEL: {
+      float x_offset, y_offset, x_offset_ordinal, y_offset_ordinal;
+      GetFlingData(xev, &x_offset, &y_offset, &x_offset_ordinal,
+                   &y_offset_ordinal, nullptr);
+      return new ScrollEvent(event_type, location, EventTimeFromNative(xev),
+                             flags, x_offset, y_offset, x_offset_ordinal,
+                             y_offset_ordinal, 0);
+    }
+    case ET_SCROLL: {
+      float x_offset, y_offset, x_offset_ordinal, y_offset_ordinal;
+      int finger_count;
+      GetScrollOffsets(xev, &x_offset, &y_offset, &x_offset_ordinal,
+                       &y_offset_ordinal, &finger_count);
+      return new ScrollEvent(event_type, location, EventTimeFromNative(xev),
+                             flags, x_offset, y_offset, x_offset_ordinal,
+                             y_offset_ordinal, finger_count);
+    }
+    case ET_TOUCH_MOVED:
+    case ET_TOUCH_PRESSED:
+    case ET_TOUCH_CANCELLED:
+    case ET_TOUCH_RELEASED:
+      return new TouchEvent(event_type, location, GetTouchId(xev),
+                            EventTimeFromNative(xev));
+    case ET_UNKNOWN:
+      return nullptr;
+    default:
+      break;
+  }
+  return nullptr;
+}
+
+base::NativeEvent TranslateXEventToNativeEvent(XEvent* xev) {
+  int flags = EventFlagsFromNative(xev);
+  switch (xev->type) {
+    case LeaveNotify:
+    case EnterNotify:
+      // EnterNotify creates ET_MOUSE_MOVED. Mark as synthesized as this is
+      // not real mouse move event.
+      // int flags = GetEventFlagsFromXState(xev->xcrossing.state);
+      if (xev->type == EnterNotify)
+        flags |= EF_IS_SYNTHESIZED;
+      return new MouseEvent(
+          ET_MOUSE_MOVED, gfx::PointF(xev->xcrossing.x, xev->xcrossing.y),
+          gfx::PointF(xev->xcrossing.x_root, xev->xcrossing.y_root), flags, 0);
+
+    case KeyPress:
+    case KeyRelease:
+      return new KeyEvent(EventTypeFromNative(xev), KeyboardCodeFromNative(xev),
+                          flags);
+
+    case ButtonPress:
+    case ButtonRelease: {
+      gfx::PointF location = gfx::PointF(xev->xbutton.x, xev->xbutton.y);
+      gfx::PointF root_location =
+          gfx::PointF(xev->xbutton.x_root, xev->xbutton.y_root);
+      switch (EventTypeFromNative(xev)) {
+        case ET_MOUSEWHEEL:
+          return new MouseWheelEvent(GetMouseWheelOffset(xev), location,
+                                     root_location, flags, 0);
+        case ET_MOUSE_PRESSED:
+        case ET_MOUSE_RELEASED:
+          return new MouseEvent(EventTypeFromNative(xev), location,
+                                root_location, flags,
+                                GetChangedMouseButtonFlagsFromNative(xev));
+        case ET_UNKNOWN:
+          // No event is created for X11-release events for mouse-wheel
+          // buttons.
+          break;
+        default:
+          NOTREACHED();
+      }
+      break;
+    }
+
+    case FocusOut:
+    case Expose:
+    case ConfigureNotify:
+    case ClientMessage:
+      return new CustomEvent(ET_X_RAW_EVENT, base::TimeDelta(), xev);
+
+    case GenericEvent:
+      return TranslateXI2Event(xev);
+  }
+  return nullptr;
+}
+#endif
 
 }  // namespace ui