Remove TouchEvent interface, and rename TouchEventImpl to TouchEvent

ui/aura/test/event_generator.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/test/event_generator.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/event.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/base/x/x11_util.h"
 #endif
 
 namespace {
 
 class TestKeyEvent : public ui::KeyEvent {
  public:
   TestKeyEvent(const base::NativeEvent& native_event, int flags)
       : KeyEvent(native_event, false /* is_char */) {
     set_flags(flags);
   }
 };
 
-class TestTouchEvent : public ui::TouchEventImpl {
+class TestTouchEvent : public ui::TouchEvent {
  public:
   TestTouchEvent(ui::EventType type,
                  const gfx::Point& root_location,
                  int flags)
-      : TouchEventImpl(type, root_location, 0,
+      : TouchEvent(type, root_location, 0,
                        base::Time::NowFromSystemTime() - base::Time()) {
     set_flags(flags);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
 };
 
 gfx::Point CenterOfWindowInRootWindowCoordinate(aura::RootWindow* root_window,
                                                 aura::Window* window) {
@@ skipping 113 matching lines @@
   ReleaseTouch();
 }
 
 void EventGenerator::PressMoveAndReleaseTouchToCenterOf(Window* window) {
   PressMoveAndReleaseTouchTo(CenterOfWindowInRootWindowCoordinate(root_window_,
                                                                   window));
 }
 
 void EventGenerator::GestureTapAt(const gfx::Point& location) {
   const int kTouchId = 2;
-  ui::TouchEventImpl press(ui::ET_TOUCH_PRESSED, location, kTouchId,
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId,
                            base::Time::NowFromSystemTime() - base::Time());
   Dispatch(press);
 
-  ui::TouchEventImpl release(
+  ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
   Dispatch(release);
 }
 
 void EventGenerator::GestureTapDownAndUp(const gfx::Point& location) {
   const int kTouchId = 3;
-  ui::TouchEventImpl press(
+  ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, location, kTouchId,
       base::Time::NowFromSystemTime() - base::Time());
   Dispatch(press);
 
-  ui::TouchEventImpl release(
+  ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, location, kTouchId,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(1000));
   Dispatch(release);
 }
 
 void EventGenerator::GestureScrollSequence(const gfx::Point& start,
                                            const gfx::Point& end,
                                            const base::TimeDelta& step_delay,
                                            int steps) {
   const int kTouchId = 5;
   base::TimeDelta timestamp = base::Time::NowFromSystemTime() - base::Time();
-  ui::TouchEventImpl press(ui::ET_TOUCH_PRESSED, start, kTouchId, timestamp);
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, start, kTouchId, timestamp);
   Dispatch(press);
 
   int dx = (end.x() - start.x()) / steps;
   int dy = (end.y() - start.y()) / steps;
   gfx::Point location = start;
   for (int i = 0; i < steps; ++i) {
     location.Offset(dx, dy);
     timestamp += step_delay;
-    ui::TouchEventImpl move(ui::ET_TOUCH_MOVED, location, kTouchId, timestamp);
+    ui::TouchEvent move(ui::ET_TOUCH_MOVED, location, kTouchId, timestamp);
     Dispatch(move);
   }
 
-  ui::TouchEventImpl release(ui::ET_TOUCH_RELEASED, end, kTouchId, timestamp);
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, end, kTouchId, timestamp);
   Dispatch(release);
 }
 
 void EventGenerator::GestureMultiFingerScroll(int count,
                                               const gfx::Point* start,
                                               int event_separation_time_ms,
                                               int steps,
                                               int move_x,
                                               int move_y) {
   const int kMaxTouchPoints = 10;
   gfx::Point points[kMaxTouchPoints];
   CHECK_LE(count, kMaxTouchPoints);
   CHECK_GT(steps, 0);
 
   int delta_x = move_x / steps;
   int delta_y = move_y / steps;
 
   base::TimeDelta press_time = base::Time::NowFromSystemTime() - base::Time();
   for (int i = 0; i < count; ++i) {
     points[i] = start[i];
-    ui::TouchEventImpl press(ui::ET_TOUCH_PRESSED, points[i], i, press_time);
+    ui::TouchEvent press(ui::ET_TOUCH_PRESSED, points[i], i, press_time);
     Dispatch(press);
   }
 
   for (int step = 0; step < steps; ++step) {
     base::TimeDelta move_time = press_time +
         base::TimeDelta::FromMilliseconds(event_separation_time_ms * step);
     for (int i = 0; i < count; ++i) {
       points[i].Offset(delta_x, delta_y);
-      ui::TouchEventImpl move(ui::ET_TOUCH_MOVED, points[i], i, move_time);
+      ui::TouchEvent move(ui::ET_TOUCH_MOVED, points[i], i, move_time);
       Dispatch(move);
     }
   }
 
   base::TimeDelta release_time = press_time +
       base::TimeDelta::FromMilliseconds(event_separation_time_ms * steps);
   for (int i = 0; i < count; ++i) {
-    ui::TouchEventImpl release(
+    ui::TouchEvent release(
         ui::ET_TOUCH_RELEASED, points[i], i, release_time);
     Dispatch(release);
   }
 }
 
 void EventGenerator::PressKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(true, key_code, flags);
 }
 
 void EventGenerator::ReleaseKey(ui::KeyboardCode key_code, int flags) {
@@ skipping 16 matching lines @@
     case ui::ET_MOUSEWHEEL:
       root_window_->AsRootWindowHostDelegate()->OnHostMouseEvent(
           static_cast<ui::MouseEvent*>(&event));
       break;
     case ui::ET_TOUCH_RELEASED:
     case ui::ET_TOUCH_PRESSED:
     case ui::ET_TOUCH_MOVED:
     case ui::ET_TOUCH_STATIONARY:
     case ui::ET_TOUCH_CANCELLED:
       root_window_->AsRootWindowHostDelegate()->OnHostTouchEvent(
-          static_cast<ui::TouchEventImpl*>(&event));
+          static_cast<ui::TouchEvent*>(&event));
       break;
     default:
       NOTIMPLEMENTED();
       break;
   }
 }
 
 void EventGenerator::DispatchKeyEvent(bool is_press,
                                       ui::KeyboardCode key_code,
                                       int flags) {
 #if defined(OS_WIN)
   MSG native_event =
       { NULL, (is_press ? WM_KEYDOWN : WM_KEYUP), key_code, 0 };
   TestKeyEvent keyev(native_event, flags);
 #else
   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
 #if defined(USE_X11)
   scoped_ptr<XEvent> native_event(new XEvent);
   ui::InitXKeyEventForTesting(type, key_code, flags, native_event.get());
   TestKeyEvent keyev(native_event.get(), flags);
 #else
   ui::KeyEvent keyev(type, key_code, flags);
 #endif  // USE_X11
 #endif  // OS_WIN
   Dispatch(keyev);
 }
 
 }  // namespace test
 }  // namespace aura