Convert Aura to use ui::Event.

ash/touch/touch_uma.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 "ash/touch/touch_uma.h"
 
 #include "ash/shell_delegate.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
-#include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
+#include "ui/base/event.h"
 
 namespace {
 
 enum GestureActionType {
   GESTURE_UNKNOWN,
   GESTURE_OMNIBOX_PINCH,
   GESTURE_OMNIBOX_SCROLL,
   GESTURE_TABSTRIP_PINCH,
   GESTURE_TABSTRIP_SCROLL,
   GESTURE_BEZEL_SCROLL,
@@ skipping 58 matching lines @@
   // multi-touch gesture on the window, then this is the release-time of the
   // last touch on the window).
   base::TimeDelta last_mt_time_;
 };
 
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(WindowTouchDetails,
                                  kWindowTouchDetails,
                                  NULL);
 
 GestureActionType FindGestureActionType(aura::Window* window,
-                                        const aura::GestureEvent& event) {
+                                        const ui::GestureEventImpl& event) {
   if (!window || window->GetRootWindow() == window) {
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
       return GESTURE_BEZEL_SCROLL;
     return GESTURE_UNKNOWN;
   }
 
   std::string name = window ? window->name() : std::string();
 
   const char kDesktopBackgroundView[] = "DesktopBackgroundView";
   if (name == kDesktopBackgroundView) {
@@ skipping 39 matching lines @@
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
       return GESTURE_OMNIBOX_SCROLL;
     if (event.type() == ui::ET_GESTURE_PINCH_BEGIN)
       return GESTURE_OMNIBOX_PINCH;
     return GESTURE_UNKNOWN;
   }
 
   return GESTURE_UNKNOWN;
 }
 
-UMAEventType UMAEventTypeFromEvent(const aura::Event& event) {
+UMAEventType UMAEventTypeFromEvent(const ui::Event& event) {
   switch (event.type()) {
     case ui::ET_TOUCH_RELEASED:
       return UMA_ET_TOUCH_RELEASED;
     case ui::ET_TOUCH_PRESSED:
       return UMA_ET_TOUCH_PRESSED;
     case ui::ET_TOUCH_MOVED:
       return UMA_ET_TOUCH_MOVED;
     case ui::ET_TOUCH_STATIONARY:
       return UMA_ET_TOUCH_STATIONARY;
     case ui::ET_TOUCH_CANCELLED:
       return UMA_ET_TOUCH_CANCELLED;
     case ui::ET_GESTURE_SCROLL_BEGIN:
       return UMA_ET_GESTURE_SCROLL_BEGIN;
     case ui::ET_GESTURE_SCROLL_END:
       return UMA_ET_GESTURE_SCROLL_END;
     case ui::ET_GESTURE_SCROLL_UPDATE: {
-      const aura::GestureEvent& gesture =
-          static_cast<const aura::GestureEvent&>(event);
+      const ui::GestureEventImpl& gesture =
+          static_cast<const ui::GestureEventImpl&>(event);
       if (gesture.details().touch_points() >= 4)
         return UMA_ET_GESTURE_SCROLL_UPDATE_4P;
       else if (gesture.details().touch_points() == 3)
         return UMA_ET_GESTURE_SCROLL_UPDATE_3;
       else if (gesture.details().touch_points() == 2)
         return UMA_ET_GESTURE_SCROLL_UPDATE_2;
       return UMA_ET_GESTURE_SCROLL_UPDATE;
     }
     case ui::ET_GESTURE_TAP:
       return UMA_ET_GESTURE_TAP;
     case ui::ET_GESTURE_TAP_DOWN:
       return UMA_ET_GESTURE_TAP_DOWN;
     case ui::ET_GESTURE_BEGIN:
       return UMA_ET_GESTURE_BEGIN;
     case ui::ET_GESTURE_END:
       return UMA_ET_GESTURE_END;
     case ui::ET_GESTURE_DOUBLE_TAP:
       return UMA_ET_GESTURE_DOUBLE_TAP;
     case ui::ET_GESTURE_TWO_FINGER_TAP:
       return UMA_ET_GESTURE_TWO_FINGER_TAP;
     case ui::ET_GESTURE_PINCH_BEGIN:
       return UMA_ET_GESTURE_PINCH_BEGIN;
     case ui::ET_GESTURE_PINCH_END:
       return UMA_ET_GESTURE_PINCH_END;
     case ui::ET_GESTURE_PINCH_UPDATE: {
-      const aura::GestureEvent& gesture =
-          static_cast<const aura::GestureEvent&>(event);
+      const ui::GestureEventImpl& gesture =
+          static_cast<const ui::GestureEventImpl&>(event);
       if (gesture.details().touch_points() >= 4)
         return UMA_ET_GESTURE_PINCH_UPDATE_4P;
       else if (gesture.details().touch_points() == 3)
         return UMA_ET_GESTURE_PINCH_UPDATE_3;
       return UMA_ET_GESTURE_PINCH_UPDATE;
     }
     case ui::ET_GESTURE_LONG_PRESS:
       return UMA_ET_GESTURE_LONG_PRESS;
     case ui::ET_GESTURE_MULTIFINGER_SWIPE: {
-      const aura::GestureEvent& gesture =
-          static_cast<const aura::GestureEvent&>(event);
+      const ui::GestureEventImpl& gesture =
+          static_cast<const ui::GestureEventImpl&>(event);
       if (gesture.details().touch_points() >= 4)
         return UMA_ET_GESTURE_MULTIFINGER_SWIPE_4P;
       else if (gesture.details().touch_points() == 3)
         return UMA_ET_GESTURE_MULTIFINGER_SWIPE_3;
       return UMA_ET_GESTURE_MULTIFINGER_SWIPE;
     }
     case ui::ET_SCROLL:
       return UMA_ET_SCROLL;
     case ui::ET_SCROLL_FLING_START:
       return UMA_ET_SCROLL_FLING_START;
     case ui::ET_SCROLL_FLING_CANCEL:
       return UMA_ET_SCROLL_FLING_CANCEL;
     default:
       return UMA_ET_UNKNOWN;
   }
 }
 
 }
 
 namespace ash {
 namespace internal {
 
 TouchUMA::TouchUMA() {
 }
 
 TouchUMA::~TouchUMA() {
 }
 
 void TouchUMA::RecordGestureEvent(aura::Window* target,
-                                  const aura::GestureEvent& event) {
+                                  const ui::GestureEventImpl& event) {
   UMA_HISTOGRAM_ENUMERATION("Ash.GestureCreated",
                             UMAEventTypeFromEvent(event),
                             UMA_ET_COUNT);
 
   GestureActionType action = FindGestureActionType(target, event);
   if (action != GESTURE_UNKNOWN) {
     UMA_HISTOGRAM_ENUMERATION("Ash.GestureTarget",
                               action,
                               GESTURE_ACTION_COUNT);
   }
 
   if (event.type() == ui::ET_GESTURE_END &&
       event.details().touch_points() == 2) {
     WindowTouchDetails* details = target->GetProperty(kWindowTouchDetails);
     CHECK(details) << "Window received gesture but no touch events?";
     details->last_mt_time_ = event.time_stamp();
   }
 }
 
 void TouchUMA::RecordTouchEvent(aura::Window* target,
-                                const aura::TouchEvent& event) {
+                                const ui::TouchEventImpl& event) {
   UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchRadius",
       static_cast<int>(std::max(event.radius_x(), event.radius_y())),
       1, 500, 100);
 
   WindowTouchDetails* details = target->GetProperty(kWindowTouchDetails);
   if (!details) {
     details = new WindowTouchDetails;
     target->SetProperty(kWindowTouchDetails, details);
   }
 
@@ skipping 43 matching lines @@
 
     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchMoveSteps", distance, 1, 1000, 50);
 
     details->last_move_time_[event.touch_id()] = event.time_stamp();
     details->last_touch_position_[event.touch_id()] = event.location();
   }
 }
 
 }  // namespace internal
 }  // namespace ash