Convert Aura to use ui::Event.

content/browser/renderer_host/web_input_event_aurax11.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.
 
 // Portions based heavily on:
 // third_party/WebKit/Source/WebKit/chromium/public/gtk/WebInputEventFactory.cpp
 //
 /*
  * Copyright (C) 2006-2011 Google Inc. All rights reserved.
  *
@@ skipping 26 matching lines @@
 
 #include "content/browser/renderer_host/web_input_event_aura.h"
 
 #include <cstdlib>
 #include <X11/keysym.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include "base/event_types.h"
 #include "base/logging.h"
-#include "ui/aura/event.h"
+#include "ui/base/event.h"
 #include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 
 namespace content {
 
 // chromium WebKit does not provide a WebInputEventFactory for X11, so we have
 // to do the work here ourselves.
 
 namespace {
 
 // This matches Firefox behavior.
 const int kPixelsPerTick = 53;
 
 // Normalizes event.flags() to make it Windows/Mac compatible. Since the way
 // of setting modifier mask on X is very different than Windows/Mac as shown
 // in http://crbug.com/127142#c8, the normalization is necessary.
-int NormalizeEventFlags(const aura::KeyEvent& event) {
+int NormalizeEventFlags(const ui::KeyEvent& event) {
   int mask = 0;
   switch (event.key_code()) {
     case ui::VKEY_CONTROL:
       mask = ui::EF_CONTROL_DOWN;
       break;
     case ui::VKEY_SHIFT:
       mask = ui::EF_SHIFT_DOWN;
       break;
     case ui::VKEY_MENU:
       mask = ui::EF_ALT_DOWN;
@@ skipping 99 matching lines @@
         return 0x0A;
       // Returns 0 for all other keys to avoid inputting unexpected chars.
       default:
         break;
     }
   }
   return 0;
 }
 
 WebKit::WebTouchPoint::State TouchPointStateFromEvent(
-    const aura::TouchEvent* event) {
+    const ui::TouchEventImpl* event) {
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       return WebKit::WebTouchPoint::StatePressed;
     case ui::ET_TOUCH_RELEASED:
       return WebKit::WebTouchPoint::StateReleased;
     case ui::ET_TOUCH_MOVED:
       return WebKit::WebTouchPoint::StateMoved;
     case ui::ET_TOUCH_CANCELLED:
       return WebKit::WebTouchPoint::StateCancelled;
     default:
       return WebKit::WebTouchPoint::StateUndefined;
   }
 }
 
 WebKit::WebInputEvent::Type TouchEventTypeFromEvent(
-    const aura::TouchEvent* event) {
+    const ui::TouchEventImpl* event) {
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       return WebKit::WebInputEvent::TouchStart;
     case ui::ET_TOUCH_RELEASED:
       return WebKit::WebInputEvent::TouchEnd;
     case ui::ET_TOUCH_MOVED:
       return WebKit::WebInputEvent::TouchMove;
     case ui::ET_TOUCH_CANCELLED:
       return WebKit::WebInputEvent::TouchCancel;
     default:
       return WebKit::WebInputEvent::Undefined;
   }
 }
 
 }  // namespace
 
-WebKit::WebMouseEvent MakeWebMouseEventFromAuraEvent(aura::MouseEvent* event) {
+WebKit::WebMouseEvent MakeWebMouseEventFromAuraEvent(ui::MouseEvent* event) {
   WebKit::WebMouseEvent webkit_event;
 
   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
 
   webkit_event.button = WebKit::WebMouseEvent::ButtonNone;
   if (event->flags() & ui::EF_LEFT_MOUSE_BUTTON)
     webkit_event.button = WebKit::WebMouseEvent::ButtonLeft;
   if (event->flags() & ui::EF_MIDDLE_MOUSE_BUTTON)
     webkit_event.button = WebKit::WebMouseEvent::ButtonMiddle;
@@ skipping 16 matching lines @@
       break;
     default:
       NOTIMPLEMENTED() << "Received unexpected event: " << event->type();
       break;
   }
 
   return webkit_event;
 }
 
 WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
-    aura::MouseEvent* event) {
+    ui::MouseEvent* event) {
   WebKit::WebMouseWheelEvent webkit_event;
 
   webkit_event.type = WebKit::WebInputEvent::MouseWheel;
   webkit_event.button = WebKit::WebMouseEvent::ButtonNone;
   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
   webkit_event.deltaY = ui::GetMouseWheelOffset(event->native_event());
   webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
 
   return webkit_event;
 }
 
 WebKit::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
-    aura::ScrollEvent* event) {
+    ui::ScrollEvent* event) {
   WebKit::WebMouseWheelEvent webkit_event;
 
   webkit_event.type = WebKit::WebInputEvent::MouseWheel;
   webkit_event.button = WebKit::WebMouseEvent::ButtonNone;
   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
   webkit_event.hasPreciseScrollingDeltas = true;
   webkit_event.deltaX = event->x_offset();
   webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick;
   webkit_event.deltaY = event->y_offset();
   webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
 
   return webkit_event;
 }
 
 WebKit::WebGestureEvent MakeWebGestureEventFromAuraEvent(
-    aura::ScrollEvent* event) {
+    ui::ScrollEvent* event) {
   WebKit::WebGestureEvent webkit_event;
 
   switch (event->type()) {
     case ui::ET_SCROLL:
       webkit_event.type = WebKit::WebInputEvent::GestureScrollUpdate;
       break;
     case ui::ET_SCROLL_FLING_START:
       webkit_event.type = WebKit::WebInputEvent::GestureFlingStart;
       break;
     case ui::ET_SCROLL_FLING_CANCEL:
       webkit_event.type = WebKit::WebInputEvent::GestureFlingCancel;
       break;
     default:
       NOTREACHED() << "Unknown gesture type: " << event->type();
   }
 
   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
   webkit_event.deltaX = event->x_offset();
   webkit_event.deltaY = event->y_offset();
 
   return webkit_event;
 }
 
 WebKit::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent(
-    aura::KeyEvent* event) {
+    ui::KeyEvent* event) {
   base::NativeEvent native_event = event->native_event();
   WebKit::WebKeyboardEvent webkit_event;
   XKeyEvent* native_key_event = &native_event->xkey;
 
   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
   webkit_event.modifiers =
       EventFlagsToWebEventModifiers(NormalizeEventFlags(*event));
 
   switch (native_event->type) {
     case KeyPress:
@@ skipping 28 matching lines @@
   }
 
   webkit_event.setKeyIdentifierFromWindowsKeyCode();
 
   // TODO: IsAutoRepeat/IsKeyPad?
 
   return webkit_event;
 }
 
 WebKit::WebGestureEvent MakeWebGestureEventFromAuraEvent(
-    aura::GestureEvent* event) {
+    ui::GestureEventImpl* event) {
   WebKit::WebGestureEvent gesture_event;
 
   switch (event->type()) {
     case ui::ET_GESTURE_TAP:
       gesture_event.type = WebKit::WebInputEvent::GestureTap;
       gesture_event.deltaX = event->details().tap_count();
       break;
     case ui::ET_GESTURE_TAP_DOWN:
       gesture_event.type = WebKit::WebInputEvent::GestureTapDown;
       break;
@@ skipping 43 matching lines @@
       NOTREACHED() << "Unknown gesture type: " << event->type();
   }
 
   gesture_event.boundingBox = event->details().bounding_box();
   gesture_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
 
   return gesture_event;
 }
 
 WebKit::WebTouchPoint* UpdateWebTouchEventFromAuraEvent(
-    aura::TouchEvent* event, WebKit::WebTouchEvent* web_event) {
+    ui::TouchEventImpl* event, WebKit::WebTouchEvent* web_event) {
   WebKit::WebTouchPoint* point = NULL;
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       // Add a new touch point.
       if (web_event->touchesLength < WebKit::WebTouchEvent::touchesLengthCap) {
         point = &web_event->touches[web_event->touchesLength++];
         point->id = event->touch_id();
       }
       break;
     case ui::ET_TOUCH_RELEASED:
@@ skipping 50 matching lines @@
 
   // Update the type of the touch event.
   web_event->type = TouchEventTypeFromEvent(event);
   web_event->timeStampSeconds = event->time_stamp().InSecondsF();
   web_event->modifiers = EventFlagsToWebEventModifiers(event->flags());
 
   return point;
 }
 
 }  // namespace content