Consolidate ui::NativeEvent and base::NativeEvent

ui/base/x/events_x.cc

 // Copyright (c) 2011 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/base/events.h"
 
 #include <X11/extensions/XInput2.h>
 
 #include "base/logging.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
@@ skipping 48 matching lines @@
 int GetButtonMaskForX2Event(XIDeviceEvent* xievent) {
   int buttonflags = 0;
   for (int i = 0; i < 8 * xievent->buttons.mask_len; i++) {
     if (XIMaskIsSet(xievent->buttons.mask, i)) {
       buttonflags |= GetEventFlagsForButton(i);
     }
   }
   return buttonflags;
 }
 
-ui::EventType GetTouchEventType(const ui::NativeEvent& native_event) {
+ui::EventType GetTouchEventType(const base::NativeEvent& native_event) {
   XIDeviceEvent* event =
       static_cast<XIDeviceEvent*>(native_event->xcookie.data);
 #if defined(USE_XI2_MT)
   switch(event->evtype) {
     case XI_TouchBegin:
       return ui::ET_TOUCH_PRESSED;
     case XI_TouchUpdate:
       return ui::ET_TOUCH_MOVED;
     case XI_TouchEnd:
       return ui::ET_TOUCH_RELEASED;
@@ skipping 44 matching lines @@
   }
 
   return ui::ET_TOUCH_MOVED;
 #endif  // defined(USE_XI2_MT)
 }
 
 }  // namespace
 
 namespace ui {
 
-EventType EventTypeFromNative(const NativeEvent& native_event) {
+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 (native_event->xbutton.button == 4 ||
           native_event->xbutton.button == 5)
         return ET_MOUSEWHEEL;
       return ET_MOUSE_PRESSED;
@@ skipping 24 matching lines @@
               ET_MOUSE_DRAGGED : ET_MOUSE_MOVED;
       }
     }
     default:
       NOTREACHED();
       break;
   }
   return ET_UNKNOWN;
 }
 
-int EventFlagsFromNative(const NativeEvent& native_event) {
+int EventFlagsFromNative(const base::NativeEvent& native_event) {
   switch (native_event->type) {
     case KeyPress:
     case KeyRelease:
       return GetEventFlagsFromXState(native_event->xbutton.state);
     case ButtonPress:
     case ButtonRelease:
       return GetEventFlagsFromXState(native_event->xbutton.state) |
              GetEventFlagsForButton(native_event->xbutton.button);
     case MotionNotify:
       return GetEventFlagsFromXState(native_event->xmotion.state);
@@ skipping 10 matching lines @@
                  (touch ? 0 : GetEventFlagsForButton(xievent->detail));
         case XI_Motion:
            return GetButtonMaskForX2Event(xievent) |
                   GetEventFlagsFromXState(xievent->mods.effective);
       }
     }
   }
   return 0;
 }
 
-gfx::Point EventLocationFromNative(const NativeEvent& native_event) {
+gfx::Point EventLocationFromNative(const base::NativeEvent& native_event) {
   switch (native_event->type) {
     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: {
       XIDeviceEvent* xievent =
           static_cast<XIDeviceEvent*>(native_event->xcookie.data);
       return gfx::Point(static_cast<int>(xievent->event_x),
                         static_cast<int>(xievent->event_y));
     }
   }
   return gfx::Point();
 }
 
-KeyboardCode KeyboardCodeFromNative(const NativeEvent& native_event) {
+KeyboardCode KeyboardCodeFromNative(const base::NativeEvent& native_event) {
   return KeyboardCodeFromXKeyEvent(native_event);
 }
 
-bool IsMouseEvent(const NativeEvent& native_event) {
+bool IsMouseEvent(const base::NativeEvent& native_event) {
   if (native_event->type == ButtonPress ||
       native_event->type == ButtonRelease ||
       native_event->type == MotionNotify)
     return true;
   if (native_event->type == GenericEvent) {
     XIDeviceEvent* xievent =
         static_cast<XIDeviceEvent*>(native_event->xcookie.data);
     return xievent->evtype == XI_ButtonPress ||
            xievent->evtype == XI_ButtonRelease ||
            xievent->evtype == XI_Motion;
   }
   return false;
 }
 
-int GetMouseWheelOffset(const NativeEvent& native_event) {
+int GetMouseWheelOffset(const base::NativeEvent& native_event) {
   if (native_event->type == GenericEvent) {
     XIDeviceEvent* xiev =
         static_cast<XIDeviceEvent*>(native_event->xcookie.data);
     return xiev->detail == 4 ? kWheelScrollAmount : -kWheelScrollAmount;
   }
   return native_event->xbutton.button == 4 ?
       kWheelScrollAmount : -kWheelScrollAmount;
 }
 
 }  // namespace ui