Remove TouchEvent interface, and rename TouchEventImpl to TouchEvent

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 617 matching lines @@
     if ((*it)->PreHandleKeyEvent(target, event))
       return true;
   }
 
   if (!target->delegate())
     return false;
   return target->delegate()->OnKeyEvent(event);
 }
 
 ui::TouchStatus RootWindow::ProcessTouchEvent(Window* target,
-                                              ui::TouchEventImpl* event) {
+                                              ui::TouchEvent* event) {
   if (!target->IsVisible())
     return ui::TOUCH_STATUS_UNKNOWN;
 
   EventFilters filters;
   if (target == this)
     GetEventFiltersToNotify(target, &filters);
   else
     GetEventFiltersToNotify(target->parent(), &filters);
   for (EventFilters::const_reverse_iterator it = filters.rbegin(),
            rend = filters.rend();
@@ skipping 103 matching lines @@
   if (attached->IsVisible() &&
       attached->ContainsPointInRoot(GetLastMouseLocationInRoot()))
     PostMouseMoveEventAfterWindowChange();
 }
 
 bool RootWindow::DispatchLongPressGestureEvent(ui::GestureEvent* event) {
   return DispatchGestureEvent(static_cast<ui::GestureEventImpl*>(event));
 }
 
 bool RootWindow::DispatchCancelTouchEvent(ui::TouchEvent* event) {
-  return OnHostTouchEvent(static_cast<ui::TouchEventImpl*>(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(),
                                   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::TouchEventImpl(type, location, touch_id, time_stamp);
+  return new ui::TouchEvent(type, location, touch_id, time_stamp);
 }
 
 void RootWindow::OnLayerAnimationEnded(
     ui::LayerAnimationSequence* animation) {
   OnHostResized(host_->GetBounds().size());
 }
 
 void RootWindow::OnLayerAnimationScheduled(
     ui::LayerAnimationSequence* animation) {
 }
@@ skipping 59 matching lines @@
     Window::ConvertPointToTarget(this, target, &location_in_window);
     if (IsNonClientLocation(target, location_in_window))
       flags |= ui::EF_IS_NON_CLIENT;
     ui::ScrollEvent translated_event(
         *event, static_cast<Window*>(this), target, event->type(), flags);
     return ProcessMouseEvent(target, &translated_event);
   }
   return false;
 }
 
-bool RootWindow::OnHostTouchEvent(ui::TouchEventImpl* event) {
+bool RootWindow::OnHostTouchEvent(ui::TouchEvent* event) {
   DispatchHeldMouseMove();
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       touch_ids_down_ |= (1 << event->touch_id());
       Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
     // Don't handle ET_TOUCH_CANCELLED since we always get a ET_TOUCH_RELEASED.
     case ui::ET_TOUCH_RELEASED:
       touch_ids_down_ = (touch_ids_down_ | (1 << event->touch_id())) ^
                         (1 << event->touch_id());
       Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
     default:
       break;
   }
   float scale = ui::GetDeviceScaleFactor(layer());
   ui::Transform transform = layer()->transform();
   transform.ConcatScale(scale, scale);
   event->UpdateForRootTransform(transform);
   bool handled = false;
   ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
   Window* target = client::GetCaptureWindow(this);
   if (!target) {
     target = ConsumerToWindow(
         gesture_recognizer_->GetTouchLockedTarget(event));
     if (!target) {
       target = ConsumerToWindow(
-          gesture_recognizer_->GetTargetForLocation(event->GetLocation()));
+          gesture_recognizer_->GetTargetForLocation(event->location()));
     }
   }
 
   if (!target && !bounds().Contains(event->location())) {
     // If the initial touch is outside the root window, target the root.
     target = this;
   } else {
     // We only come here when the first contact was within the root window.
     if (!target) {
       target = GetEventHandlerForPoint(event->location());
       if (!target)
         return false;
     }
 
-    ui::TouchEventImpl translated_event(
+    ui::TouchEvent translated_event(
         *event, static_cast<Window*>(this), target);
     status = ProcessTouchEvent(target, &translated_event);
     handled = status != ui::TOUCH_STATUS_UNKNOWN;
 
     if (status == ui::TOUCH_STATUS_QUEUED ||
         status == ui::TOUCH_STATUS_QUEUED_END)
       gesture_recognizer_->QueueTouchEventForGesture(target, *event);
   }
 
   // Get the list of GestureEvents from GestureRecognizer.
@@ skipping 138 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura