Remove TouchEvent interface, and rename TouchEventImpl to TouchEvent

ui/aura/window_unittest.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/window.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 152 matching lines @@
   int mouse_event_count() const { return mouse_event_count_; }
   int touch_event_count() const { return touch_event_count_; }
   int gesture_event_count() const { return gesture_event_count_; }
 
   virtual bool OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED)
       capture_changed_event_count_++;
     mouse_event_count_++;
     return false;
   }
-  virtual ui::TouchStatus OnTouchEvent(ui::TouchEventImpl* event) OVERRIDE {
+  virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     touch_event_count_++;
     return ui::TOUCH_STATUS_UNKNOWN;
   }
   virtual ui::GestureStatus OnGestureEvent(
       ui::GestureEventImpl* event) OVERRIDE {
     gesture_event_count_++;
     return ui::GESTURE_STATUS_UNKNOWN;
   }
   virtual void OnCaptureLost() OVERRIDE {
     capture_lost_count_++;
@@ skipping 242 matching lines @@
 
   // Points are in the Window's coordinates.
   EXPECT_TRUE(w1.HitTest(gfx::Point(1, 1)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(-1, -1)));
 
   // We can expand the bounds slightly to track events outside our border.
   w1.SetHitTestBoundsOverrideOuter(gfx::Insets(-1, -1, -1, -1), 5);
   EXPECT_TRUE(w1.HitTest(gfx::Point(-1, -1)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(-2, -2)));
 
-  ui::TouchEventImpl pressed(
+  ui::TouchEvent pressed(
       ui::ET_TOUCH_PRESSED, gfx::Point(50, 50), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&pressed);
   EXPECT_TRUE(w1.HitTest(gfx::Point(-2, -2)));
   EXPECT_TRUE(w1.HitTest(gfx::Point(-5, -5)));
   EXPECT_FALSE(w1.HitTest(gfx::Point(-5, -6)));
-  ui::TouchEventImpl released(
+  ui::TouchEvent released(
       ui::ET_TOUCH_RELEASED, gfx::Point(50, 50), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&released);
   EXPECT_FALSE(w1.HitTest(gfx::Point(-2, -2)));
 
   // TODO(beng): clip Window to parent.
 }
 
 TEST_F(WindowTest, HitTestMask) {
   Window w1(new MaskedWindowDelegate(gfx::Rect(5, 6, 20, 30)));
   w1.Init(ui::LAYER_NOT_DRAWN);
@@ skipping 306 matching lines @@
   EXPECT_EQ(0, delegate.capture_lost_count());
   EXPECT_EQ(0, delegate.capture_changed_event_count());
   EventGenerator generator(root_window(), gfx::Point(50, 50));
   generator.PressLeftButton();
   EXPECT_EQ(1, delegate.mouse_event_count());
   generator.ReleaseLeftButton();
 
   EXPECT_EQ(2, delegate.mouse_event_count());
   delegate.ResetCounts();
 
-  ui::TouchEventImpl touchev(
+  ui::TouchEvent touchev(
       ui::ET_TOUCH_PRESSED, gfx::Point(50, 50), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&touchev);
   EXPECT_EQ(1, delegate.touch_event_count());
   delegate.ResetCounts();
 
   window->ReleaseCapture();
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(1, delegate.capture_lost_count());
   EXPECT_EQ(1, delegate.capture_changed_event_count());
   EXPECT_EQ(1, delegate.mouse_event_count());
   EXPECT_EQ(1, delegate.touch_event_count());
 
   generator.PressLeftButton();
   EXPECT_EQ(1, delegate.mouse_event_count());
 
-  ui::TouchEventImpl touchev2(
+  ui::TouchEvent touchev2(
       ui::ET_TOUCH_PRESSED, gfx::Point(250, 250), 1, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&touchev2);
   EXPECT_EQ(1, delegate.touch_event_count());
 
   // Removing the capture window from parent should reset the capture window
   // in the root window.
   window->SetCapture();
   EXPECT_EQ(window.get(), aura::client::GetCaptureWindow(root_window()));
   window->parent()->RemoveChild(window.get());
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
 TEST_F(WindowTest, TouchCaptureCancelsOtherTouches) {
   CaptureWindowDelegateImpl delegate1;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
       &delegate1, 0, gfx::Rect(0, 0, 20, 20), NULL));
   CaptureWindowDelegateImpl delegate2;
   scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
       &delegate2, 0, gfx::Rect(20, 20, 20, 20), NULL));
 
   // Press on w1.
-  ui::TouchEventImpl press(
+  ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate1.gesture_event_count());
   delegate1.ResetCounts();
   w2->SetCapture();
 
   // The touch was cancelled when the other window
   // attained a touch lock.
   EXPECT_EQ(1, delegate1.touch_event_count());
   EXPECT_EQ(0, delegate2.touch_event_count());
 
   delegate1.ResetCounts();
   delegate2.ResetCounts();
 
-  ui::TouchEventImpl move(ui::ET_TOUCH_MOVED, gfx::Point(10, 10), 0, getTime());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&move);
 
   // This touch id is now ignored, no scroll fired.
   EXPECT_EQ(0, delegate1.gesture_event_count());
   EXPECT_EQ(0, delegate2.gesture_event_count());
 
-  ui::TouchEventImpl release(
+  ui::TouchEvent release(
       ui::ET_TOUCH_RELEASED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_EQ(0, delegate1.gesture_event_count());
   EXPECT_EQ(0, delegate2.gesture_event_count());
 
   // A new press is captured by w2.
 
-  ui::TouchEventImpl press2(
+  ui::TouchEvent press2(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press2);
   EXPECT_EQ(0, delegate1.gesture_event_count());
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate2.gesture_event_count());
 }
 
 TEST_F(WindowTest, TouchCaptureDoesntCancelCapturedTouches) {
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 20, 20), NULL));
 
-  ui::TouchEventImpl press(
+  ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
 
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate.gesture_event_count());
   delegate.ResetCounts();
 
   window->SetCapture();
   EXPECT_EQ(0, delegate.gesture_event_count());
   delegate.ResetCounts();
 
   // The move event should still create a gesture, as this touch was
   // on the window which was captured.
-  ui::TouchEventImpl release(ui::ET_TOUCH_RELEASED,
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED,
                              gfx::Point(10, 10), 0, getTime() +
                                  base::TimeDelta::FromMilliseconds(50));
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&release);
   EXPECT_EQ(2, delegate.gesture_event_count());
 }
 
 // Assertions around SetCapture() and touch/gestures.
 TEST_F(WindowTest, TransferCaptureTouchEvents) {
   // Touch on |w1|.
   CaptureWindowDelegateImpl d1;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 0, gfx::Rect(0, 0, 20, 20), NULL));
-  ui::TouchEventImpl p1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
+  ui::TouchEvent p1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&p1);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, d1.gesture_event_count());
   d1.ResetCounts();
 
   // Touch on |w2| with a different id.
   CaptureWindowDelegateImpl d2;
   scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
       &d2, 0, gfx::Rect(40, 0, 40, 20), NULL));
-  ui::TouchEventImpl p2(ui::ET_TOUCH_PRESSED, gfx::Point(41, 10), 1, getTime());
+  ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::Point(41, 10), 1, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&p2);
   EXPECT_EQ(0, d1.gesture_event_count());
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN for new target window.
   EXPECT_EQ(2, d2.gesture_event_count());
   d1.ResetCounts();
   d2.ResetCounts();
 
   // Set capture on |w2|, this should send a cancel to |w1| but not |w2|.
   w2->SetCapture();
   EXPECT_EQ(1, d1.gesture_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   d1.ResetCounts();
   d2.ResetCounts();
 
   CaptureWindowDelegateImpl d3;
   scoped_ptr<Window> w3(CreateTestWindowWithDelegate(
                             &d3, 0, gfx::Rect(0, 0, 100, 101), NULL));
   // Set capture on w3. No new events should be received.
   w3->SetCapture();
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
 
   // Move touch id originally associated with |w2|. Since capture was transfered
   // from 2 to 3 only |w3| should get the event.
-  ui::TouchEventImpl m3(ui::ET_TOUCH_MOVED, gfx::Point(110, 105), 1, getTime());
+  ui::TouchEvent m3(ui::ET_TOUCH_MOVED, gfx::Point(110, 105), 1, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&m3);
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   // |w3| gets two events, both scroll related.
   EXPECT_EQ(2, d3.gesture_event_count());
 }
 
 // Changes capture while capture is already ongoing.
 TEST_F(WindowTest, ChangeCaptureWhileMouseDown) {
   CaptureWindowDelegateImpl delegate;
@@ skipping 391 matching lines @@
       new GestureTrackPositionDelegate);
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(delegate.get(), -1234,
       gfx::Rect(0, 0, 20, 20), NULL));
 
   // Rotate the root-window clock-wise 90 degrees.
   ui::Transform transform;
   transform.SetRotate(90.0f);
   transform.ConcatTranslate(size.height(), 0);
   root_window()->SetTransform(transform);
 
-  ui::TouchEventImpl press(
+  ui::TouchEvent press(
       ui::ET_TOUCH_PRESSED, gfx::Point(size.height() - 10, 10), 0, getTime());
   root_window()->AsRootWindowHostDelegate()->OnHostTouchEvent(&press);
   EXPECT_EQ(gfx::Point(10, 10).ToString(), delegate->position().ToString());
 }
 
 // Various assertions for transient children.
 TEST_F(WindowTest, TransientChildren) {
   scoped_ptr<Window> parent(CreateTestWindowWithId(0, NULL));
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, parent.get()));
   scoped_ptr<Window> w3(CreateTestWindowWithId(3, parent.get()));
@@ skipping 1118 matching lines @@
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   // No bounds changed notification at the end of animation since layer
   // delegate is NULL.
   EXPECT_FALSE(delegate.bounds_changed());
   EXPECT_NE("0,0 100x100", window->bounds().ToString());
 }
 
 }  // namespace test
 }  // namespace aura