Remove GestureEvent interface, and rename GestureEventImpl to GestureEvent.

ui/aura/root_window.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/aura/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 254 matching lines @@
   TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::Draw",
                            compositor_->last_started_frame() + 1);
 
   compositor_->Draw(false);
 }
 
 void RootWindow::ScheduleFullDraw() {
   compositor_->ScheduleFullDraw();
 }
 
-bool RootWindow::DispatchGestureEvent(ui::GestureEventImpl* event) {
+bool RootWindow::DispatchGestureEvent(ui::GestureEvent* event) {
   DispatchHeldMouseMove();
 
   Window* target = client::GetCaptureWindow(this);
   if (!target) {
     target = ConsumerToWindow(
         gesture_recognizer_->GetTargetForGestureEvent(event));
     if (!target)
       return false;
   }
 
   if (target) {
-    ui::GestureEventImpl translated_event(
+    ui::GestureEvent translated_event(
         *event, static_cast<Window*>(this), target);
     ui::GestureStatus status = ProcessGestureEvent(target, &translated_event);
     return status != ui::GESTURE_STATUS_UNKNOWN;
   }
 
   return false;
 }
 
 void RootWindow::OnWindowDestroying(Window* window) {
   OnWindowHidden(window, true);
@@ skipping 354 matching lines @@
       return status;
   }
 
   if (target->delegate())
     return target->delegate()->OnTouchEvent(event);
 
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
 ui::GestureStatus RootWindow::ProcessGestureEvent(Window* target,
-                                                  ui::GestureEventImpl* event) {
+                                                  ui::GestureEvent* event) {
   if (!target->IsVisible())
     return ui::GESTURE_STATUS_UNKNOWN;
 
   EventFilters filters;
   if (target == this)
     GetEventFiltersToNotify(target, &filters);
   else
     GetEventFiltersToNotify(target->parent(), &filters);
   ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
   for (EventFilters::const_reverse_iterator it = filters.rbegin(),
            rend = filters.rend();
        it != rend; ++it) {
     status = (*it)->PreHandleGestureEvent(target, event);
     if (status != ui::GESTURE_STATUS_UNKNOWN)
       return status;
   }
 
   if (target->delegate())
     status = target->delegate()->OnGestureEvent(event);
 
   return status;
 }
 
 bool RootWindow::ProcessGestures(ui::GestureRecognizer::Gestures* gestures) {
   if (!gestures)
     return false;
   bool handled = false;
   for (unsigned int i = 0; i < gestures->size(); i++) {
-    ui::GestureEventImpl* gesture =
-        static_cast<ui::GestureEventImpl*>(gestures->get().at(i));
+    ui::GestureEvent* gesture =
+        static_cast<ui::GestureEvent*>(gestures->get().at(i));
     if (DispatchGestureEvent(gesture) != ui::GESTURE_STATUS_UNKNOWN)
       handled = true;
   }
   return handled;
 }
 
 void RootWindow::OnWindowRemovedFromRootWindow(Window* detached) {
   DCHECK(aura::client::GetCaptureWindow(this) != this);
 
   OnWindowHidden(detached, false);
@@ skipping 45 matching lines @@
   gesture_recognizer_->FlushTouchQueue(invisible);
 }
 
 void RootWindow::OnWindowAddedToRootWindow(Window* attached) {
   if (attached->IsVisible() &&
       attached->ContainsPointInRoot(GetLastMouseLocationInRoot()))
     PostMouseMoveEventAfterWindowChange();
 }
 
 bool RootWindow::DispatchLongPressGestureEvent(ui::GestureEvent* event) {
-  return DispatchGestureEvent(static_cast<ui::GestureEventImpl*>(event));
+  return DispatchGestureEvent(static_cast<ui::GestureEvent*>(event));
 }
 
 bool RootWindow::DispatchCancelTouchEvent(ui::TouchEvent* event) {
   return OnHostTouchEvent(event);
 }
 
 ui::GestureEvent* RootWindow::CreateGestureEvent(
     const ui::GestureEventDetails& details,
     const gfx::Point& location,
     int flags,
     base::Time time,
     unsigned int touch_id_bitfield) {
-  return new ui::GestureEventImpl(details.type(), location.x(), location.y(),
+  return new ui::GestureEvent(details.type(), location.x(), location.y(),
                                   flags, time, details, touch_id_bitfield);
 }
 
 ui::TouchEvent* RootWindow::CreateTouchEvent(ui::EventType type,
                                              const gfx::Point& location,
                                              int touch_id,
                                              base::TimeDelta time_stamp) {
   return new ui::TouchEvent(type, location, touch_id, time_stamp);
 }
 
@@ skipping 271 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura